Add system generated users (#15291)

* Add system generated users

* Fix typing

tests/auth_providers/test_insecure_example.py

@@ -54,7 +54,7 @@ async def test_match_existing_credentials(store, provider):
         },
         is_new=False,
     )
-    store.credentials_for_provider = Mock(return_value=mock_coro([existing]))
+    provider.async_credentials = Mock(return_value=mock_coro([existing]))
     credentials = await provider.async_get_or_create_credentials({
         'username': 'user-test',
         'password': 'password-test',

tests/auth_providers/test_legacy_api_password.py

@@ -21,6 +21,14 @@ def provider(hass, store):
     })
 
 
+@pytest.fixture
+def manager(hass, store, provider):
+    """Mock manager."""
+    return auth.AuthManager(hass, store, {
+        (provider.type, provider.id): provider
+    })
+
+
 async def test_create_new_credential(provider):
     """Test that we create a new credential."""
     credentials = await provider.async_get_or_create_credentials({})
@@ -28,13 +36,13 @@ async def test_create_new_credential(provider):
     assert credentials.is_new is True
 
 
-async def test_only_one_credentials(store, provider):
+async def test_only_one_credentials(manager, provider):
     """Call create twice will return same credential."""
     credentials = await provider.async_get_or_create_credentials({})
-    await store.async_get_or_create_user(credentials, provider)
+    await manager.async_get_or_create_user(credentials)
     credentials2 = await provider.async_get_or_create_credentials({})
-    assert credentials2.data["username"] is legacy_api_password.LEGACY_USER
-    assert credentials2.id is credentials.id
+    assert credentials2.data["username"] == legacy_api_password.LEGACY_USER
+    assert credentials2.id == credentials.id
     assert credentials2.is_new is False
 
 

tests/common.py

@@ -312,7 +312,8 @@ class MockUser(auth.User):
     def __init__(self, id='mock-id', is_owner=True, is_active=True,
                  name='Mock User'):
         """Initialize mock user."""
-        super().__init__(id, is_owner, is_active, name)
+        super().__init__(
+            id=id, is_owner=is_owner, is_active=is_active, name=name)
 
     def add_to_hass(self, hass):
         """Test helper to add entry to hass."""

tests/components/conftest.py

@@ -34,5 +34,5 @@ def hass_access_token(hass):
         no_secret=True,
     ))
     refresh_token = hass.loop.run_until_complete(
-        hass.auth.async_create_refresh_token(user, client.id))
+        hass.auth.async_create_refresh_token(user, client))
     yield hass.auth.async_create_access_token(refresh_token)

tests/test_auth.py

@@ -184,7 +184,7 @@ async def test_saving_loading(hass, hass_storage):
     client = await manager.async_create_client(
         'test', redirect_uris=['https://example.com'])
 
-    refresh_token = await manager.async_create_refresh_token(user, client.id)
+    refresh_token = await manager.async_create_refresh_token(user, client)
 
     manager.async_create_access_token(refresh_token)
 
@@ -226,13 +226,8 @@ async def test_cannot_retrieve_expired_access_token(hass):
     """Test that we cannot retrieve expired access tokens."""
     manager = await auth.auth_manager_from_config(hass, [])
     client = await manager.async_create_client('test')
-    user = MockUser(
-        id='mock-user',
-        is_owner=False,
-        is_active=False,
-        name='Paulus',
-    ).add_to_auth_manager(manager)
-    refresh_token = await manager.async_create_refresh_token(user, client.id)
+    user = MockUser().add_to_auth_manager(manager)
+    refresh_token = await manager.async_create_refresh_token(user, client)
     assert refresh_token.user.id is user.id
     assert refresh_token.client_id is client.id
 
@@ -260,23 +255,41 @@ async def test_get_or_create_client(hass):
     assert client2.id is client1.id
 
 
-async def test_cannot_create_refresh_token_with_invalide_client_id(hass):
-    """Test that we cannot create refresh token with invalid client id."""
+async def test_generating_system_user(hass):
+    """Test that we can add a system user."""
     manager = await auth.auth_manager_from_config(hass, [])
-    user = MockUser(
-        id='mock-user',
-        is_owner=False,
-        is_active=False,
-        name='Paulus',
-    ).add_to_auth_manager(manager)
-    with pytest.raises(ValueError):
-        await manager.async_create_refresh_token(user, 'bla')
+    user = await manager.async_create_system_user('Hass.io')
+    token = await manager.async_create_refresh_token(user)
+    assert user.system_generated
+    assert token is not None
+    assert token.client_id is None
 
 
-async def test_cannot_create_refresh_token_with_invalide_user(hass):
-    """Test that we cannot create refresh token with invalid client id."""
+async def test_refresh_token_requires_client_for_user(hass):
+    """Test that we can add a system user."""
     manager = await auth.auth_manager_from_config(hass, [])
-    client = await manager.async_create_client('test')
-    user = MockUser(id='invalid-user')
+    user = MockUser().add_to_auth_manager(manager)
+    assert user.system_generated is False
+
     with pytest.raises(ValueError):
-        await manager.async_create_refresh_token(user, client.id)
+        await manager.async_create_refresh_token(user)
+
+    client = await manager.async_get_or_create_client('Test client')
+    token = await manager.async_create_refresh_token(user, client)
+    assert token is not None
+    assert token.client_id == client.id
+
+
+async def test_refresh_token_not_requires_client_for_system_user(hass):
+    """Test that we can add a system user."""
+    manager = await auth.auth_manager_from_config(hass, [])
+    user = await manager.async_create_system_user('Hass.io')
+    assert user.system_generated is True
+    client = await manager.async_get_or_create_client('Test client')
+
+    with pytest.raises(ValueError):
+        await manager.async_create_refresh_token(user, client)
+
+    token = await manager.async_create_refresh_token(user)
+    assert token is not None
+    assert token.client_id is None