async def test_execute_view_async(module: Module) -> None: name = 'view' mock = AsyncMock(name='view') module.view(name, function=mock) await module.execute_action(f'view_submission:{name}') mock.assert_awaited_once()
async def test_execute_action_async(module: Module) -> None: name = 'action' mock = AsyncMock(name='action') module.action(name, function=mock) await module.execute_action(f'block_actions:{name}') mock.assert_awaited_once()
async def test_add_x_trace_id_no_trace_id_set_args_length_long_enough(): args = ["a", 2, "b", 3, {"key": "value"}, "c", 4] func_return_value = "value" func = AsyncMock() func.return_value = func_return_value actual_return_value = await add_x_trace_id(func)(*deepcopy(args)) assert actual_return_value == func_return_value func.assert_awaited_once() actual_args = list(func.call_args.args) assert_args_except_trace_id_kept_as_is(args, actual_args) assert len(actual_args[4][X_TRACE_ID]) == TRACE_ID_LENGTH
async def test_process_request(test_action_metadata: Dict, test_request: Dict, monkeypatch) -> None: mock_get_request = AsyncMock(name='get_request_by_id') mock_get_request.return_value = test_request monkeypatch.setattr(bl, 'get_request_by_id', mock_get_request) mock_update = AsyncMock(name='update_request_status') monkeypatch.setattr(bl, 'update_request_status', mock_update) mock_send = AsyncMock(name='_send_notification') monkeypatch.setattr(bl, '_send_notification', mock_send) await bl._process_request(None, test_request['_id'], 'approved') mock_update.assert_awaited_once() assert mock_send.await_count == 2
async def test_app_with_lifespan_uses_callbacks(): startup = AsyncMock(return_value=None) shutdown = AsyncMock(return_value=None) seal(startup), seal(shutdown) async with TestClient( AppWithLifespan( app=AppBasic(MgFixed(RsText("Hello there!"))), startup=startup, shutdown=shutdown, ), ) as client: startup.assert_awaited_once() shutdown.assert_not_awaited() resp = await client.get("/") assert resp.status_code == 200 assert resp.content == b"Hello there!" shutdown.assert_awaited_once()
def test_fire_registered_event_cancel(self, client_mock): bot = Bot("app_name", "version") bot.guild_logs_file = None on_ready = AsyncMock() on_ready.__name__ = "on_ready" on_ready.return_value = False bot.register_event(on_ready) ex = Exception("test") client_mock.change_presence.side_effect = ex try: with patch("discord.Game") as game_mock: game_mock.return_value = "activity" self._await(bot.on_ready()) except Exception as error: self.assertEqual(ex, error) on_ready.assert_awaited_once() client_mock.change_presence.assert_not_called()
async def test_add_x_trace_id_trace_id_set_args_length_long_enough(): args = ["a", 2, "b", 3, {"key": "value"}, "c", 4] func_return_value = "value" trace_id = "trace-id" func = AsyncMock() func.return_value = func_return_value DistributedTracingContext.set_trace_id(trace_id) actual_return_value = await add_x_trace_id(func)(*deepcopy(args)) assert actual_return_value == func_return_value func.assert_awaited_once() actual_args = list(func.call_args.args) assert_args_except_trace_id_kept_as_is(args, actual_args) assert actual_args[4][X_TRACE_ID] == trace_id
async def test_subscription_calls_retry_policy(app): handler_mock = AsyncMock() @app.schema("Foo", version=1) class Foo(pydantic.BaseModel): bar: str @app.subscribe("foo.bar", group="test_group", retry_handlers={Exception: handler_mock}) async def noop(data: Foo): raise Exception("Unhandled Exception") async with app: fut = asyncio.create_task(app.consume_for(1, seconds=5)) await asyncio.sleep(0.2) await app.publish("foo.bar", Foo(bar=1)) await app.flush() await fut handler_mock.assert_awaited_once()
def test_listeners_on_secondary_app(app_one, app_two, run_multi): app_one.prepare(port=23456) app_two.prepare(port=23457) before_start = AsyncMock() after_start = AsyncMock() before_stop = AsyncMock() after_stop = AsyncMock() app_two.before_server_start(before_start) app_two.after_server_start(after_start) app_two.before_server_stop(before_stop) app_two.after_server_stop(after_stop) run_multi(app_one) before_start.assert_awaited_once() after_start.assert_awaited_once() before_stop.assert_awaited_once() after_stop.assert_awaited_once()
async def test_create_request(test_command_metadata: Dict, monkeypatch) -> None: mock_get_days = AsyncMock(name='get_days_by_user_id') monkeypatch.setattr(bl, 'get_days_by_user_id', mock_get_days) mock_save = AsyncMock(name='save_request') mock_save.return_value = '123asd' monkeypatch.setattr(bl, 'save_request', mock_save) mock_send = AsyncMock(name='_send_notification') monkeypatch.setattr(bl, '_send_notification', mock_send) mock_notify = AsyncMock(name='_notify_admins') monkeypatch.setattr(bl, '_notify_admins', mock_notify) users = 'users' history = 'history' await bl.create_request(history, users, 'test', date.today(), date.today(), '') mock_get_days.assert_awaited_once() mock_save.assert_awaited_once() mock_send.assert_awaited_once() mock_notify.assert_awaited_once()
class AsyncMockAssert(unittest.TestCase): def setUp(self): self.mock = AsyncMock() async def _runnable_test(self, *args): if not args: await self.mock() else: await self.mock(*args) def test_assert_awaited(self): with self.assertRaises(AssertionError): self.mock.assert_awaited() asyncio.run(self._runnable_test()) self.mock.assert_awaited() def test_assert_awaited_once(self): with self.assertRaises(AssertionError): self.mock.assert_awaited_once() asyncio.run(self._runnable_test()) self.mock.assert_awaited_once() asyncio.run(self._runnable_test()) with self.assertRaises(AssertionError): self.mock.assert_awaited_once() def test_assert_awaited_with(self): asyncio.run(self._runnable_test()) msg = 'expected await not found' with self.assertRaisesRegex(AssertionError, msg): self.mock.assert_awaited_with('foo') asyncio.run(self._runnable_test('foo')) self.mock.assert_awaited_with('foo') asyncio.run(self._runnable_test('SomethingElse')) with self.assertRaises(AssertionError): self.mock.assert_awaited_with('foo') def test_assert_awaited_once_with(self): with self.assertRaises(AssertionError): self.mock.assert_awaited_once_with('foo') asyncio.run(self._runnable_test('foo')) self.mock.assert_awaited_once_with('foo') asyncio.run(self._runnable_test('foo')) with self.assertRaises(AssertionError): self.mock.assert_awaited_once_with('foo') def test_assert_any_wait(self): with self.assertRaises(AssertionError): self.mock.assert_any_await('NormalFoo') asyncio.run(self._runnable_test('foo')) with self.assertRaises(AssertionError): self.mock.assert_any_await('NormalFoo') asyncio.run(self._runnable_test('NormalFoo')) self.mock.assert_any_await('NormalFoo') asyncio.run(self._runnable_test('SomethingElse')) self.mock.assert_any_await('NormalFoo') def test_assert_has_awaits_no_order(self): calls = [call('NormalFoo'), call('baz')] with self.assertRaises(AssertionError) as cm: self.mock.assert_has_awaits(calls) self.assertEqual(len(cm.exception.args), 1) asyncio.run(self._runnable_test('foo')) with self.assertRaises(AssertionError): self.mock.assert_has_awaits(calls) asyncio.run(self._runnable_test('NormalFoo')) with self.assertRaises(AssertionError): self.mock.assert_has_awaits(calls) asyncio.run(self._runnable_test('baz')) self.mock.assert_has_awaits(calls) asyncio.run(self._runnable_test('SomethingElse')) self.mock.assert_has_awaits(calls) def test_assert_has_awaits_ordered(self): calls = [call('NormalFoo'), call('baz')] with self.assertRaises(AssertionError): self.mock.assert_has_awaits(calls, any_order=True) asyncio.run(self._runnable_test('baz')) with self.assertRaises(AssertionError): self.mock.assert_has_awaits(calls, any_order=True) asyncio.run(self._runnable_test('foo')) with self.assertRaises(AssertionError): self.mock.assert_has_awaits(calls, any_order=True) asyncio.run(self._runnable_test('NormalFoo')) self.mock.assert_has_awaits(calls, any_order=True) asyncio.run(self._runnable_test('qux')) self.mock.assert_has_awaits(calls, any_order=True) def test_assert_not_awaited(self): self.mock.assert_not_awaited() asyncio.run(self._runnable_test()) with self.assertRaises(AssertionError): self.mock.assert_not_awaited()
class AsyncMockAssert(unittest.TestCase): def setUp(self): self.mock = AsyncMock() async def _runnable_test(self, *args, **kwargs): await self.mock(*args, **kwargs) async def _await_coroutine(self, coroutine): return await coroutine def test_assert_called_but_not_awaited(self): mock = AsyncMock(AsyncClass) with self.assertWarns(RuntimeWarning): # Will raise a warning because never awaited mock.async_method() self.assertTrue(asyncio.iscoroutinefunction(mock.async_method)) mock.async_method.assert_called() mock.async_method.assert_called_once() mock.async_method.assert_called_once_with() with self.assertRaises(AssertionError): mock.assert_awaited() with self.assertRaises(AssertionError): mock.async_method.assert_awaited() def test_assert_called_then_awaited(self): mock = AsyncMock(AsyncClass) mock_coroutine = mock.async_method() mock.async_method.assert_called() mock.async_method.assert_called_once() mock.async_method.assert_called_once_with() with self.assertRaises(AssertionError): mock.async_method.assert_awaited() asyncio.run(self._await_coroutine(mock_coroutine)) # Assert we haven't re-called the function mock.async_method.assert_called_once() mock.async_method.assert_awaited() mock.async_method.assert_awaited_once() mock.async_method.assert_awaited_once_with() def test_assert_called_and_awaited_at_same_time(self): with self.assertRaises(AssertionError): self.mock.assert_awaited() with self.assertRaises(AssertionError): self.mock.assert_called() asyncio.run(self._runnable_test()) self.mock.assert_called_once() self.mock.assert_awaited_once() def test_assert_called_twice_and_awaited_once(self): mock = AsyncMock(AsyncClass) coroutine = mock.async_method() with self.assertWarns(RuntimeWarning): # The first call will be awaited so no warning there # But this call will never get awaited, so it will warn here mock.async_method() with self.assertRaises(AssertionError): mock.async_method.assert_awaited() mock.async_method.assert_called() asyncio.run(self._await_coroutine(coroutine)) mock.async_method.assert_awaited() mock.async_method.assert_awaited_once() def test_assert_called_once_and_awaited_twice(self): mock = AsyncMock(AsyncClass) coroutine = mock.async_method() mock.async_method.assert_called_once() asyncio.run(self._await_coroutine(coroutine)) with self.assertRaises(RuntimeError): # Cannot reuse already awaited coroutine asyncio.run(self._await_coroutine(coroutine)) mock.async_method.assert_awaited() def test_assert_awaited_but_not_called(self): with self.assertRaises(AssertionError): self.mock.assert_awaited() with self.assertRaises(AssertionError): self.mock.assert_called() with self.assertRaises(TypeError): # You cannot await an AsyncMock, it must be a coroutine asyncio.run(self._await_coroutine(self.mock)) with self.assertRaises(AssertionError): self.mock.assert_awaited() with self.assertRaises(AssertionError): self.mock.assert_called() def test_assert_has_calls_not_awaits(self): kalls = [call('foo')] with self.assertWarns(RuntimeWarning): # Will raise a warning because never awaited self.mock('foo') self.mock.assert_has_calls(kalls) with self.assertRaises(AssertionError): self.mock.assert_has_awaits(kalls) def test_assert_has_mock_calls_on_async_mock_no_spec(self): with self.assertWarns(RuntimeWarning): # Will raise a warning because never awaited self.mock() kalls_empty = [('', (), {})] self.assertEqual(self.mock.mock_calls, kalls_empty) with self.assertWarns(RuntimeWarning): # Will raise a warning because never awaited self.mock('foo') self.mock('baz') mock_kalls = ([call(), call('foo'), call('baz')]) self.assertEqual(self.mock.mock_calls, mock_kalls) def test_assert_has_mock_calls_on_async_mock_with_spec(self): a_class_mock = AsyncMock(AsyncClass) with self.assertWarns(RuntimeWarning): # Will raise a warning because never awaited a_class_mock.async_method() kalls_empty = [('', (), {})] self.assertEqual(a_class_mock.async_method.mock_calls, kalls_empty) self.assertEqual(a_class_mock.mock_calls, [call.async_method()]) with self.assertWarns(RuntimeWarning): # Will raise a warning because never awaited a_class_mock.async_method(1, 2, 3, a=4, b=5) method_kalls = [call(), call(1, 2, 3, a=4, b=5)] mock_kalls = [ call.async_method(), call.async_method(1, 2, 3, a=4, b=5) ] self.assertEqual(a_class_mock.async_method.mock_calls, method_kalls) self.assertEqual(a_class_mock.mock_calls, mock_kalls) def test_async_method_calls_recorded(self): with self.assertWarns(RuntimeWarning): # Will raise warnings because never awaited self.mock.something(3, fish=None) self.mock.something_else.something(6, cake=sentinel.Cake) self.assertEqual(self.mock.method_calls, [("something", (3, ), { 'fish': None }), ("something_else.something", (6, ), { 'cake': sentinel.Cake })], "method calls not recorded correctly") self.assertEqual(self.mock.something_else.method_calls, [("something", (6, ), { 'cake': sentinel.Cake })], "method calls not recorded correctly") def test_async_arg_lists(self): def assert_attrs(mock): names = ('call_args_list', 'method_calls', 'mock_calls') for name in names: attr = getattr(mock, name) self.assertIsInstance(attr, _CallList) self.assertIsInstance(attr, list) self.assertEqual(attr, []) assert_attrs(self.mock) with self.assertWarns(RuntimeWarning): # Will raise warnings because never awaited self.mock() self.mock(1, 2) self.mock(a=3) self.mock.reset_mock() assert_attrs(self.mock) a_mock = AsyncMock(AsyncClass) with self.assertWarns(RuntimeWarning): # Will raise warnings because never awaited a_mock.async_method() a_mock.async_method(1, a=3) a_mock.reset_mock() assert_attrs(a_mock) def test_assert_awaited(self): with self.assertRaises(AssertionError): self.mock.assert_awaited() asyncio.run(self._runnable_test()) self.mock.assert_awaited() def test_assert_awaited_once(self): with self.assertRaises(AssertionError): self.mock.assert_awaited_once() asyncio.run(self._runnable_test()) self.mock.assert_awaited_once() asyncio.run(self._runnable_test()) with self.assertRaises(AssertionError): self.mock.assert_awaited_once() def test_assert_awaited_with(self): msg = 'Not awaited' with self.assertRaisesRegex(AssertionError, msg): self.mock.assert_awaited_with('foo') asyncio.run(self._runnable_test()) msg = 'expected await not found' with self.assertRaisesRegex(AssertionError, msg): self.mock.assert_awaited_with('foo') asyncio.run(self._runnable_test('foo')) self.mock.assert_awaited_with('foo') asyncio.run(self._runnable_test('SomethingElse')) with self.assertRaises(AssertionError): self.mock.assert_awaited_with('foo') def test_assert_awaited_once_with(self): with self.assertRaises(AssertionError): self.mock.assert_awaited_once_with('foo') asyncio.run(self._runnable_test('foo')) self.mock.assert_awaited_once_with('foo') asyncio.run(self._runnable_test('foo')) with self.assertRaises(AssertionError): self.mock.assert_awaited_once_with('foo') def test_assert_any_wait(self): with self.assertRaises(AssertionError): self.mock.assert_any_await('foo') asyncio.run(self._runnable_test('baz')) with self.assertRaises(AssertionError): self.mock.assert_any_await('foo') asyncio.run(self._runnable_test('foo')) self.mock.assert_any_await('foo') asyncio.run(self._runnable_test('SomethingElse')) self.mock.assert_any_await('foo') def test_assert_has_awaits_no_order(self): calls = [call('foo'), call('baz')] with self.assertRaises(AssertionError) as cm: self.mock.assert_has_awaits(calls) self.assertEqual(len(cm.exception.args), 1) asyncio.run(self._runnable_test('foo')) with self.assertRaises(AssertionError): self.mock.assert_has_awaits(calls) asyncio.run(self._runnable_test('foo')) with self.assertRaises(AssertionError): self.mock.assert_has_awaits(calls) asyncio.run(self._runnable_test('baz')) self.mock.assert_has_awaits(calls) asyncio.run(self._runnable_test('SomethingElse')) self.mock.assert_has_awaits(calls) def test_assert_has_awaits_ordered(self): calls = [call('foo'), call('baz')] with self.assertRaises(AssertionError): self.mock.assert_has_awaits(calls, any_order=True) asyncio.run(self._runnable_test('baz')) with self.assertRaises(AssertionError): self.mock.assert_has_awaits(calls, any_order=True) asyncio.run(self._runnable_test('bamf')) with self.assertRaises(AssertionError): self.mock.assert_has_awaits(calls, any_order=True) asyncio.run(self._runnable_test('foo')) self.mock.assert_has_awaits(calls, any_order=True) asyncio.run(self._runnable_test('qux')) self.mock.assert_has_awaits(calls, any_order=True) def test_assert_not_awaited(self): self.mock.assert_not_awaited() asyncio.run(self._runnable_test()) with self.assertRaises(AssertionError): self.mock.assert_not_awaited() def test_assert_has_awaits_not_matching_spec_error(self): async def f(x=None): pass self.mock = AsyncMock(spec=f) asyncio.run(self._runnable_test(1)) with self.assertRaisesRegex( AssertionError, '^{}$'.format( re.escape('Awaits not found.\n' 'Expected: [call()]\n' 'Actual: [call(1)]'))) as cm: self.mock.assert_has_awaits([call()]) self.assertIsNone(cm.exception.__cause__) with self.assertRaisesRegex( AssertionError, '^{}$'.format( re.escape('Error processing expected awaits.\n' "Errors: [None, TypeError('too many positional " "arguments')]\n" 'Expected: [call(), call(1, 2)]\n' 'Actual: [call(1)]'))) as cm: self.mock.assert_has_awaits([call(), call(1, 2)]) self.assertIsInstance(cm.exception.__cause__, TypeError)
class AsyncMockAssert(unittest.TestCase): def setUp(self): self.mock = AsyncMock() async def _runnable_test(self, *args): if not args: await self.mock() else: await self.mock(*args) def test_assert_awaited(self): with self.assertRaises(AssertionError): self.mock.assert_awaited() asyncio.run(self._runnable_test()) self.mock.assert_awaited() def test_assert_awaited_once(self): with self.assertRaises(AssertionError): self.mock.assert_awaited_once() asyncio.run(self._runnable_test()) self.mock.assert_awaited_once() asyncio.run(self._runnable_test()) with self.assertRaises(AssertionError): self.mock.assert_awaited_once() def test_assert_awaited_with(self): asyncio.run(self._runnable_test()) msg = 'expected await not found' with self.assertRaisesRegex(AssertionError, msg): self.mock.assert_awaited_with('foo') asyncio.run(self._runnable_test('foo')) self.mock.assert_awaited_with('foo') asyncio.run(self._runnable_test('SomethingElse')) with self.assertRaises(AssertionError): self.mock.assert_awaited_with('foo') def test_assert_awaited_once_with(self): with self.assertRaises(AssertionError): self.mock.assert_awaited_once_with('foo') asyncio.run(self._runnable_test('foo')) self.mock.assert_awaited_once_with('foo') asyncio.run(self._runnable_test('foo')) with self.assertRaises(AssertionError): self.mock.assert_awaited_once_with('foo') def test_assert_any_wait(self): with self.assertRaises(AssertionError): self.mock.assert_any_await('NormalFoo') asyncio.run(self._runnable_test('foo')) with self.assertRaises(AssertionError): self.mock.assert_any_await('NormalFoo') asyncio.run(self._runnable_test('NormalFoo')) self.mock.assert_any_await('NormalFoo') asyncio.run(self._runnable_test('SomethingElse')) self.mock.assert_any_await('NormalFoo') def test_assert_has_awaits_no_order(self): calls = [call('NormalFoo'), call('baz')] with self.assertRaises(AssertionError) as cm: self.mock.assert_has_awaits(calls) self.assertEqual(len(cm.exception.args), 1) asyncio.run(self._runnable_test('foo')) with self.assertRaises(AssertionError): self.mock.assert_has_awaits(calls) asyncio.run(self._runnable_test('NormalFoo')) with self.assertRaises(AssertionError): self.mock.assert_has_awaits(calls) asyncio.run(self._runnable_test('baz')) self.mock.assert_has_awaits(calls) asyncio.run(self._runnable_test('SomethingElse')) self.mock.assert_has_awaits(calls) def test_awaits_asserts_with_any(self): class Foo: def __eq__(self, other): pass asyncio.run(self._runnable_test(Foo(), 1)) self.mock.assert_has_awaits([call(ANY, 1)]) self.mock.assert_awaited_with(ANY, 1) self.mock.assert_any_await(ANY, 1) def test_awaits_asserts_with_spec_and_any(self): class Foo: def __eq__(self, other): pass mock_with_spec = AsyncMock(spec=Foo) async def _custom_mock_runnable_test(*args): await mock_with_spec(*args) asyncio.run(_custom_mock_runnable_test(Foo(), 1)) mock_with_spec.assert_has_awaits([call(ANY, 1)]) mock_with_spec.assert_awaited_with(ANY, 1) mock_with_spec.assert_any_await(ANY, 1) def test_assert_has_awaits_ordered(self): calls = [call('NormalFoo'), call('baz')] with self.assertRaises(AssertionError): self.mock.assert_has_awaits(calls, any_order=True) asyncio.run(self._runnable_test('baz')) with self.assertRaises(AssertionError): self.mock.assert_has_awaits(calls, any_order=True) asyncio.run(self._runnable_test('foo')) with self.assertRaises(AssertionError): self.mock.assert_has_awaits(calls, any_order=True) asyncio.run(self._runnable_test('NormalFoo')) self.mock.assert_has_awaits(calls, any_order=True) asyncio.run(self._runnable_test('qux')) self.mock.assert_has_awaits(calls, any_order=True) def test_assert_not_awaited(self): self.mock.assert_not_awaited() asyncio.run(self._runnable_test()) with self.assertRaises(AssertionError): self.mock.assert_not_awaited()
async def test_create_request_invalid_leave_type_fails( test_command_metadata: Dict, monkeypatch) -> None: mock = AsyncMock(name='send_ephemeral') monkeypatch.setattr(bl, 'send_ephemeral', mock) await bl.create_request(None, None, 'asd', None, None, '') mock.assert_awaited_once()
async def test_good( running_backend, backend, user_fs_factory, with_labels, data_base_dir, backend_version, monkeypatch, ): org_id = OrganizationID("NewOrg") org_token = "123456" await backend.organization.create(org_id, org_token) organization_addr = BackendOrganizationBootstrapAddr.build( running_backend.addr, org_id, org_token) if with_labels: human_handle = HumanHandle(email="*****@*****.**", label="Zack") device_label = DeviceLabel("PC1") else: human_handle = None device_label = None if backend_version == "2.5": _handle_request = AsyncMock( return_value=HTTPResponse.build_msgpack(404, {})) monkeypatch.setattr("parsec.backend.http.HTTPComponent.handle_request", _handle_request) if backend_version == "2.6": _handle_request = AsyncMock(return_value=HTTPResponse.build_msgpack( 200, {"status": "unknown_command"})) monkeypatch.setattr("parsec.backend.http.HTTPComponent.handle_request", _handle_request) if backend_version == "latest": _handle_request = None new_device = await bootstrap_organization(organization_addr, human_handle=human_handle, device_label=device_label) if _handle_request is not None: _handle_request.assert_awaited_once() assert new_device is not None assert new_device.organization_id == org_id assert new_device.device_label == device_label assert new_device.human_handle == human_handle assert new_device.profile == UserProfile.ADMIN # This function should always be called as part of bootstrap organization # (yeah, we should improve the ergonomics...) await user_storage_non_speculative_init(data_base_dir=data_base_dir, device=new_device) # Test the behavior of this new device async with user_fs_factory(new_device, data_base_dir=data_base_dir) as newfs: # New user should start with a non-speculative user manifest um = newfs.get_user_manifest() assert um.is_placeholder assert not um.speculative await newfs.workspace_create(EntryName("wa")) await newfs.sync() um = newfs.get_user_manifest() assert not um.is_placeholder assert not um.speculative # Test the device in correct in the backend backend_user, backend_device = await backend.user.get_user_with_device( org_id, new_device.device_id) assert backend_user.user_id == new_device.user_id assert backend_user.human_handle == new_device.human_handle assert backend_user.profile == new_device.profile assert backend_user.user_certifier is None if with_labels: assert backend_user.user_certificate != backend_user.redacted_user_certificate else: assert backend_user.user_certificate == backend_user.redacted_user_certificate assert backend_device.device_id == new_device.device_id assert backend_device.device_label == new_device.device_label assert backend_device.device_certifier is None if with_labels: assert backend_device.device_certificate != backend_device.redacted_device_certificate else: assert backend_device.device_certificate == backend_device.redacted_device_certificate
async def test_init(self, mocked_init_connections: AsyncMock): db_config = {"default": {"HOST": "some_host", "PORT": "1234"}} await self.conn_handler._init(db_config, True) mocked_init_connections.assert_awaited_once() self.assertEqual(db_config, self.conn_handler._db_config) self.assertTrue(self.conn_handler._create_db)