Allow for make_awaitable's return value to be re-used.

clokep · clokep · commit 3336a23f4eb4 · 2020-09-04T14:26:33.000-04:00
diff --git a/changelog.d/8261.misc b/changelog.d/8261.misc
@@ -0,0 +1 @@
+Simplify tests that mock asynchronous functions.
diff --git a/tests/federation/test_complexity.py b/tests/federation/test_complexity.py
@@ -78,10 +78,10 @@ def test_join_too_large(self):
 
         # Mock out some things, because we don't want to test the whole join
         fed_transport.client.get_json = Mock(
-            side_effect=lambda *args, **kwargs: make_awaitable({"v1": 9999})
+            return_value=make_awaitable({"v1": 9999})
         )
         handler.federation_handler.do_invite_join = Mock(
-            side_effect=lambda *args, **kwargs: make_awaitable(("", 1))
+            return_value=make_awaitable(("", 1))
         )
 
         d = handler._remote_join(
@@ -111,10 +111,10 @@ def test_join_too_large_admin(self):
 
         # Mock out some things, because we don't want to test the whole join
         fed_transport.client.get_json = Mock(
-            side_effect=lambda *args, **kwargs: make_awaitable({"v1": 9999})
+            return_value=make_awaitable({"v1": 9999})
         )
         handler.federation_handler.do_invite_join = Mock(
-            side_effect=lambda *args, **kwargs: make_awaitable(("", 1))
+            return_value=make_awaitable(("", 1))
         )
 
         d = handler._remote_join(
@@ -151,10 +151,10 @@ def test_join_too_large_once_joined(self):
 
         # Mock out some things, because we don't want to test the whole join
         fed_transport.client.get_json = Mock(
-            side_effect=lambda *args, **kwargs: make_awaitable(None)
+            return_value=make_awaitable(None)
         )
         handler.federation_handler.do_invite_join = Mock(
-            side_effect=lambda *args, **kwargs: make_awaitable(("", 1))
+            return_value=make_awaitable(("", 1))
         )
 
         # Artificially raise the complexity
@@ -209,10 +209,10 @@ def test_join_too_large_no_admin(self):
 
         # Mock out some things, because we don't want to test the whole join
         fed_transport.client.get_json = Mock(
-            side_effect=lambda *args, **kwargs: make_awaitable({"v1": 9999})
+            return_value=make_awaitable({"v1": 9999})
         )
         handler.federation_handler.do_invite_join = Mock(
-            side_effect=lambda *args, **kwargs: make_awaitable(("", 1))
+            return_value=make_awaitable(("", 1))
         )
 
         d = handler._remote_join(
@@ -241,10 +241,10 @@ def test_join_too_large_admin(self):
 
         # Mock out some things, because we don't want to test the whole join
         fed_transport.client.get_json = Mock(
-            side_effect=lambda *args, **kwargs: make_awaitable({"v1": 9999})
+            return_value=make_awaitable({"v1": 9999})
         )
         handler.federation_handler.do_invite_join = Mock(
-            side_effect=lambda *args, **kwargs: make_awaitable(("", 1))
+            return_value=make_awaitable(("", 1))
         )
 
         d = handler._remote_join(
diff --git a/tests/federation/test_federation_sender.py b/tests/federation/test_federation_sender.py
@@ -34,7 +34,7 @@ class FederationSenderReceiptsTestCases(HomeserverTestCase):
     def make_homeserver(self, reactor, clock):
         mock_state_handler = Mock(spec=["get_current_hosts_in_room"])
         # Ensure a new Awaitable is created for each call.
-        mock_state_handler.get_current_hosts_in_room.side_effect = lambda room_Id: make_awaitable(
+        mock_state_handler.get_current_hosts_in_room.return_value = make_awaitable(
             ["test", "host2"]
         )
         return self.setup_test_homeserver(
diff --git a/tests/handlers/test_auth.py b/tests/handlers/test_auth.py
@@ -143,7 +143,7 @@ def test_mau_limits_disabled(self):
     def test_mau_limits_exceeded_large(self):
         self.auth_blocking._limit_usage_by_mau = True
         self.hs.get_datastore().get_monthly_active_count = Mock(
-            side_effect=lambda: make_awaitable(self.large_number_of_users)
+            return_value=make_awaitable(self.large_number_of_users)
         )
 
         with self.assertRaises(ResourceLimitError):
@@ -154,7 +154,7 @@ def test_mau_limits_exceeded_large(self):
             )
 
         self.hs.get_datastore().get_monthly_active_count = Mock(
-            side_effect=lambda: make_awaitable(self.large_number_of_users)
+            return_value=make_awaitable(self.large_number_of_users)
         )
         with self.assertRaises(ResourceLimitError):
             yield defer.ensureDeferred(
@@ -169,7 +169,7 @@ def test_mau_limits_parity(self):
 
         # If not in monthly active cohort
         self.hs.get_datastore().get_monthly_active_count = Mock(
-            side_effect=lambda: make_awaitable(self.auth_blocking._max_mau_value)
+            return_value=make_awaitable(self.auth_blocking._max_mau_value)
         )
         with self.assertRaises(ResourceLimitError):
             yield defer.ensureDeferred(
@@ -179,7 +179,7 @@ def test_mau_limits_parity(self):
             )
 
         self.hs.get_datastore().get_monthly_active_count = Mock(
-            side_effect=lambda: make_awaitable(self.auth_blocking._max_mau_value)
+            return_value=make_awaitable(self.auth_blocking._max_mau_value)
         )
         with self.assertRaises(ResourceLimitError):
             yield defer.ensureDeferred(
@@ -189,21 +189,21 @@ def test_mau_limits_parity(self):
             )
         # If in monthly active cohort
         self.hs.get_datastore().user_last_seen_monthly_active = Mock(
-            side_effect=lambda user_id: make_awaitable(self.hs.get_clock().time_msec())
+            return_value=make_awaitable(self.hs.get_clock().time_msec())
         )
         self.hs.get_datastore().get_monthly_active_count = Mock(
-            side_effect=lambda: make_awaitable(self.auth_blocking._max_mau_value)
+            return_value=make_awaitable(self.auth_blocking._max_mau_value)
         )
         yield defer.ensureDeferred(
             self.auth_handler.get_access_token_for_user_id(
                 "user_a", device_id=None, valid_until_ms=None
             )
         )
         self.hs.get_datastore().user_last_seen_monthly_active = Mock(
-            side_effect=lambda user_id: make_awaitable(self.hs.get_clock().time_msec())
+            return_value=make_awaitable(self.hs.get_clock().time_msec())
         )
         self.hs.get_datastore().get_monthly_active_count = Mock(
-            side_effect=lambda: make_awaitable(self.auth_blocking._max_mau_value)
+            return_value=make_awaitable(self.auth_blocking._max_mau_value)
         )
         yield defer.ensureDeferred(
             self.auth_handler.validate_short_term_login_token_and_get_user_id(
@@ -216,7 +216,7 @@ def test_mau_limits_not_exceeded(self):
         self.auth_blocking._limit_usage_by_mau = True
 
         self.hs.get_datastore().get_monthly_active_count = Mock(
-            side_effect=lambda: make_awaitable(self.small_number_of_users)
+            return_value=make_awaitable(self.small_number_of_users)
         )
         # Ensure does not raise exception
         yield defer.ensureDeferred(
@@ -226,7 +226,7 @@ def test_mau_limits_not_exceeded(self):
         )
 
         self.hs.get_datastore().get_monthly_active_count = Mock(
-            side_effect=lambda: make_awaitable(self.small_number_of_users)
+            return_value=make_awaitable(self.small_number_of_users)
         )
         yield defer.ensureDeferred(
             self.auth_handler.validate_short_term_login_token_and_get_user_id(
diff --git a/tests/handlers/test_register.py b/tests/handlers/test_register.py
@@ -100,23 +100,23 @@ def test_mau_limits_when_disabled(self):
     def test_get_or_create_user_mau_not_blocked(self):
         self.hs.config.limit_usage_by_mau = True
         self.store.count_monthly_users = Mock(
-            side_effect=lambda: make_awaitable(self.hs.config.max_mau_value - 1)
+            return_value=make_awaitable(self.hs.config.max_mau_value - 1)
         )
         # Ensure does not throw exception
         self.get_success(self.get_or_create_user(self.requester, "c", "User"))
 
     def test_get_or_create_user_mau_blocked(self):
         self.hs.config.limit_usage_by_mau = True
         self.store.get_monthly_active_count = Mock(
-            side_effect=lambda: make_awaitable(self.lots_of_users)
+            return_value=make_awaitable(self.lots_of_users)
         )
         self.get_failure(
             self.get_or_create_user(self.requester, "b", "display_name"),
             ResourceLimitError,
         )
 
         self.store.get_monthly_active_count = Mock(
-            side_effect=lambda: make_awaitable(self.hs.config.max_mau_value)
+            return_value=make_awaitable(self.hs.config.max_mau_value)
         )
         self.get_failure(
             self.get_or_create_user(self.requester, "b", "display_name"),
@@ -126,14 +126,14 @@ def test_get_or_create_user_mau_blocked(self):
     def test_register_mau_blocked(self):
         self.hs.config.limit_usage_by_mau = True
         self.store.get_monthly_active_count = Mock(
-            side_effect=lambda: make_awaitable(self.lots_of_users)
+            return_value=make_awaitable(self.lots_of_users)
         )
         self.get_failure(
             self.handler.register_user(localpart="local_part"), ResourceLimitError
         )
 
         self.store.get_monthly_active_count = Mock(
-            side_effect=lambda: make_awaitable(self.hs.config.max_mau_value)
+            return_value=make_awaitable(self.hs.config.max_mau_value)
         )
         self.get_failure(
             self.handler.register_user(localpart="local_part"), ResourceLimitError
diff --git a/tests/handlers/test_typing.py b/tests/handlers/test_typing.py
@@ -116,7 +116,7 @@ def prepare(self, reactor, clock, hs):
             retry_timings_res
         )
 
-        self.datastore.get_device_updates_by_remote.side_effect = lambda destination, from_stream_id, limit: make_awaitable(
+        self.datastore.get_device_updates_by_remote.return_value = make_awaitable(
             (0, [])
         )
 
diff --git a/tests/replication/test_federation_sender_shard.py b/tests/replication/test_federation_sender_shard.py
@@ -45,7 +45,7 @@ def test_send_event_single_sender(self):
         new event.
         """
         mock_client = Mock(spec=["put_json"])
-        mock_client.put_json.side_effect = lambda *_, **__: make_awaitable({})
+        mock_client.put_json.return_value = make_awaitable({})
 
         self.make_worker_hs(
             "synapse.app.federation_sender",
@@ -73,7 +73,7 @@ def test_send_event_sharded(self):
         new events.
         """
         mock_client1 = Mock(spec=["put_json"])
-        mock_client1.put_json.side_effect = lambda *_, **__: make_awaitable({})
+        mock_client1.put_json.return_value = make_awaitable({})
         self.make_worker_hs(
             "synapse.app.federation_sender",
             {
@@ -85,7 +85,7 @@ def test_send_event_sharded(self):
         )
 
         mock_client2 = Mock(spec=["put_json"])
-        mock_client2.put_json.side_effect = lambda *_, **__: make_awaitable({})
+        mock_client2.put_json.return_value = make_awaitable({})
         self.make_worker_hs(
             "synapse.app.federation_sender",
             {
@@ -136,7 +136,7 @@ def test_send_typing_sharded(self):
         new typing EDUs.
         """
         mock_client1 = Mock(spec=["put_json"])
-        mock_client1.put_json.side_effect = lambda *_, **__: make_awaitable({})
+        mock_client1.put_json.return_value = make_awaitable({})
         self.make_worker_hs(
             "synapse.app.federation_sender",
             {
@@ -148,7 +148,7 @@ def test_send_typing_sharded(self):
         )
 
         mock_client2 = Mock(spec=["put_json"])
-        mock_client2.put_json.side_effect = lambda *_, **__: make_awaitable({})
+        mock_client2.put_json.return_value = make_awaitable({})
         self.make_worker_hs(
             "synapse.app.federation_sender",
             {
diff --git a/tests/rest/admin/test_user.py b/tests/rest/admin/test_user.py
@@ -337,7 +337,7 @@ def test_register_mau_limit_reached(self):
 
         # Set monthly active users to the limit
         store.get_monthly_active_count = Mock(
-            side_effect=lambda: make_awaitable(self.hs.config.max_mau_value)
+            return_value=make_awaitable(self.hs.config.max_mau_value)
         )
         # Check that the blocking of monthly active users is working as expected
         # The registration of a new user fails due to the limit
@@ -591,7 +591,7 @@ def test_create_user_mau_limit_reached_active_admin(self):
 
         # Set monthly active users to the limit
         self.store.get_monthly_active_count = Mock(
-            side_effect=lambda: make_awaitable(self.hs.config.max_mau_value)
+            return_value=make_awaitable(self.hs.config.max_mau_value)
         )
         # Check that the blocking of monthly active users is working as expected
         # The registration of a new user fails due to the limit
@@ -631,7 +631,7 @@ def test_create_user_mau_limit_reached_passive_admin(self):
 
         # Set monthly active users to the limit
         self.store.get_monthly_active_count = Mock(
-            side_effect=lambda: make_awaitable(self.hs.config.max_mau_value)
+            return_value=make_awaitable(self.hs.config.max_mau_value)
         )
         # Check that the blocking of monthly active users is working as expected
         # The registration of a new user fails due to the limit
diff --git a/tests/server_notices/test_resource_limits_server_notices.py b/tests/server_notices/test_resource_limits_server_notices.py
@@ -67,7 +67,7 @@ def prepare(self, reactor, clock, hs):
             raise Exception("Failed to find reference to ResourceLimitsServerNotices")
 
         self._rlsn._store.user_last_seen_monthly_active = Mock(
-            side_effect=lambda user_id: make_awaitable(1000)
+            return_value=make_awaitable(1000)
         )
         self._rlsn._server_notices_manager.send_notice = Mock(
             return_value=defer.succeed(Mock())
@@ -81,7 +81,7 @@ def prepare(self, reactor, clock, hs):
         )
         self._rlsn._store.add_tag_to_room = Mock(return_value=defer.succeed(None))
         self._rlsn._store.get_tags_for_room = Mock(
-            side_effect=lambda user_id, room_id: make_awaitable({})
+            return_value=make_awaitable({})
         )
 
     @override_config({"hs_disabled": True})
@@ -158,7 +158,7 @@ def test_maybe_send_server_notice_to_user_not_in_mau_cohort(self):
         """
         self._rlsn._auth.check_auth_blocking = Mock(return_value=defer.succeed(None))
         self._rlsn._store.user_last_seen_monthly_active = Mock(
-            side_effect=lambda user_id: make_awaitable(None)
+            return_value=make_awaitable(None)
         )
         self.get_success(self._rlsn.maybe_send_server_notice_to_user(self.user_id))
 
@@ -262,11 +262,11 @@ def prepare(self, reactor, clock, hs):
 
     def test_server_notice_only_sent_once(self):
         self.store.get_monthly_active_count = Mock(
-            side_effect=lambda: make_awaitable(1000)
+            return_value=make_awaitable(1000)
         )
 
         self.store.user_last_seen_monthly_active = Mock(
-            side_effect=lambda user_id: make_awaitable(1000)
+            return_value=make_awaitable(1000)
         )
 
         # Call the function multiple times to ensure we only send the notice once
diff --git a/tests/storage/test_client_ips.py b/tests/storage/test_client_ips.py
@@ -154,7 +154,7 @@ def test_adding_monthly_active_user_when_full(self):
         user_id = "@user:server"
 
         self.store.get_monthly_active_count = Mock(
-            side_effect=lambda: make_awaitable(lots_of_users)
+            return_value=make_awaitable(lots_of_users)
         )
         self.get_success(
             self.store.insert_client_ip(
diff --git a/tests/storage/test_monthly_active_users.py b/tests/storage/test_monthly_active_users.py
@@ -232,7 +232,7 @@ def test_populate_monthly_users_is_guest(self):
         self.get_success(d)
 
         self.store.upsert_monthly_active_user = Mock(
-            side_effect=lambda user_id: make_awaitable(None)
+            return_value=make_awaitable(None)
         )
 
         d = self.store.populate_monthly_active_users(user_id)
@@ -242,7 +242,7 @@ def test_populate_monthly_users_is_guest(self):
 
     def test_populate_monthly_users_should_update(self):
         self.store.upsert_monthly_active_user = Mock(
-            side_effect=lambda user_id: make_awaitable(None)
+            return_value=make_awaitable(None)
         )
 
         self.store.is_trial_user = Mock(return_value=defer.succeed(False))
@@ -257,7 +257,7 @@ def test_populate_monthly_users_should_update(self):
 
     def test_populate_monthly_users_should_not_update(self):
         self.store.upsert_monthly_active_user = Mock(
-            side_effect=lambda user_id: make_awaitable(None)
+            return_value=make_awaitable(None)
         )
 
         self.store.is_trial_user = Mock(return_value=defer.succeed(False))
@@ -345,7 +345,7 @@ def test_track_monthly_users_without_cap(self):
     @override_config({"limit_usage_by_mau": False, "mau_stats_only": False})
     def test_no_users_when_not_tracking(self):
         self.store.upsert_monthly_active_user = Mock(
-            side_effect=lambda user_id: make_awaitable(None)
+            return_value=make_awaitable(None)
         )
 
         self.get_success(self.store.populate_monthly_active_users("@user:sever"))
diff --git a/tests/test_utils/__init__.py b/tests/test_utils/__init__.py
@@ -17,6 +17,7 @@
 """
 Utilities for running the unit tests
 """
+from asyncio import Future
 from typing import Any, Awaitable, TypeVar
 
 TV = TypeVar("TV")
@@ -38,6 +39,12 @@ def get_awaitable_result(awaitable: Awaitable[TV]) -> TV:
     raise Exception("awaitable has not yet completed")
 
 
-async def make_awaitable(result: Any):
-    """Create an awaitable that just returns a result."""
-    return result
+def make_awaitable(result: Any) -> Awaitable[Any]:
+    """
+    Makes an awaitable, suitable for mocking an `async` function.
+    This uses Futures as they can be awaited multiple times so can be returned
+    to multiple callers.
+    """
+    future = Future()
+    future.set_result(result)
+    return future

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+Simplify tests that mock asynchronous functions.`
Original file line number	Diff line number	Diff line change
`@@ -78,10 +78,10 @@ def test_join_too_large(self):`
`78`	`78`
`79`	`79`	`# Mock out some things, because we don't want to test the whole join`
`80`	`80`	`fed_transport.client.get_json = Mock(`
`81`		`- side_effect=lambda args, *kwargs: make_awaitable({"v1": 9999})`
	`81`	`+ return_value=make_awaitable({"v1": 9999})`
`82`	`82`	`)`
`83`	`83`	`handler.federation_handler.do_invite_join = Mock(`
`84`		`- side_effect=lambda args, *kwargs: make_awaitable(("", 1))`
	`84`	`+ return_value=make_awaitable(("", 1))`
`85`	`85`	`)`
`86`	`86`
`87`	`87`	`d = handler._remote_join(`
`@@ -111,10 +111,10 @@ def test_join_too_large_admin(self):`
`111`	`111`
`112`	`112`	`# Mock out some things, because we don't want to test the whole join`
`113`	`113`	`fed_transport.client.get_json = Mock(`
`114`		`- side_effect=lambda args, *kwargs: make_awaitable({"v1": 9999})`
	`114`	`+ return_value=make_awaitable({"v1": 9999})`
`115`	`115`	`)`
`116`	`116`	`handler.federation_handler.do_invite_join = Mock(`
`117`		`- side_effect=lambda args, *kwargs: make_awaitable(("", 1))`
	`117`	`+ return_value=make_awaitable(("", 1))`
`118`	`118`	`)`
`119`	`119`
`120`	`120`	`d = handler._remote_join(`
`@@ -151,10 +151,10 @@ def test_join_too_large_once_joined(self):`
`151`	`151`
`152`	`152`	`# Mock out some things, because we don't want to test the whole join`
`153`	`153`	`fed_transport.client.get_json = Mock(`
`154`		`- side_effect=lambda args, *kwargs: make_awaitable(None)`
	`154`	`+ return_value=make_awaitable(None)`
`155`	`155`	`)`
`156`	`156`	`handler.federation_handler.do_invite_join = Mock(`
`157`		`- side_effect=lambda args, *kwargs: make_awaitable(("", 1))`
	`157`	`+ return_value=make_awaitable(("", 1))`
`158`	`158`	`)`
`159`	`159`
`160`	`160`	`# Artificially raise the complexity`
`@@ -209,10 +209,10 @@ def test_join_too_large_no_admin(self):`
`209`	`209`
`210`	`210`	`# Mock out some things, because we don't want to test the whole join`
`211`	`211`	`fed_transport.client.get_json = Mock(`
`212`		`- side_effect=lambda args, *kwargs: make_awaitable({"v1": 9999})`
	`212`	`+ return_value=make_awaitable({"v1": 9999})`
`213`	`213`	`)`
`214`	`214`	`handler.federation_handler.do_invite_join = Mock(`
`215`		`- side_effect=lambda args, *kwargs: make_awaitable(("", 1))`
	`215`	`+ return_value=make_awaitable(("", 1))`
`216`	`216`	`)`
`217`	`217`
`218`	`218`	`d = handler._remote_join(`
`@@ -241,10 +241,10 @@ def test_join_too_large_admin(self):`
`241`	`241`
`242`	`242`	`# Mock out some things, because we don't want to test the whole join`
`243`	`243`	`fed_transport.client.get_json = Mock(`
`244`		`- side_effect=lambda args, *kwargs: make_awaitable({"v1": 9999})`
	`244`	`+ return_value=make_awaitable({"v1": 9999})`
`245`	`245`	`)`
`246`	`246`	`handler.federation_handler.do_invite_join = Mock(`
`247`		`- side_effect=lambda args, *kwargs: make_awaitable(("", 1))`
	`247`	`+ return_value=make_awaitable(("", 1))`
`248`	`248`	`)`
`249`	`249`
`250`	`250`	`d = handler._remote_join(`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ class FederationSenderReceiptsTestCases(HomeserverTestCase):`
`34`	`34`	`def make_homeserver(self, reactor, clock):`
`35`	`35`	`mock_state_handler = Mock(spec=["get_current_hosts_in_room"])`
`36`	`36`	`# Ensure a new Awaitable is created for each call.`
`37`		`- mock_state_handler.get_current_hosts_in_room.side_effect = lambda room_Id: make_awaitable(`
	`37`	`+ mock_state_handler.get_current_hosts_in_room.return_value = make_awaitable(`
`38`	`38`	`["test", "host2"]`
`39`	`39`	`)`
`40`	`40`	`return self.setup_test_homeserver(`
Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,7 @@ def test_mau_limits_disabled(self):`
`143`	`143`	`def test_mau_limits_exceeded_large(self):`
`144`	`144`	`self.auth_blocking._limit_usage_by_mau = True`
`145`	`145`	`self.hs.get_datastore().get_monthly_active_count = Mock(`
`146`		`- side_effect=lambda: make_awaitable(self.large_number_of_users)`
	`146`	`+ return_value=make_awaitable(self.large_number_of_users)`
`147`	`147`	`)`
`148`	`148`
`149`	`149`	`with self.assertRaises(ResourceLimitError):`
`@@ -154,7 +154,7 @@ def test_mau_limits_exceeded_large(self):`
`154`	`154`	`)`
`155`	`155`
`156`	`156`	`self.hs.get_datastore().get_monthly_active_count = Mock(`
`157`		`- side_effect=lambda: make_awaitable(self.large_number_of_users)`
	`157`	`+ return_value=make_awaitable(self.large_number_of_users)`
`158`	`158`	`)`
`159`	`159`	`with self.assertRaises(ResourceLimitError):`
`160`	`160`	`yield defer.ensureDeferred(`
`@@ -169,7 +169,7 @@ def test_mau_limits_parity(self):`
`169`	`169`
`170`	`170`	`# If not in monthly active cohort`
`171`	`171`	`self.hs.get_datastore().get_monthly_active_count = Mock(`
`172`		`- side_effect=lambda: make_awaitable(self.auth_blocking._max_mau_value)`
	`172`	`+ return_value=make_awaitable(self.auth_blocking._max_mau_value)`
`173`	`173`	`)`
`174`	`174`	`with self.assertRaises(ResourceLimitError):`
`175`	`175`	`yield defer.ensureDeferred(`
`@@ -179,7 +179,7 @@ def test_mau_limits_parity(self):`
`179`	`179`	`)`
`180`	`180`
`181`	`181`	`self.hs.get_datastore().get_monthly_active_count = Mock(`
`182`		`- side_effect=lambda: make_awaitable(self.auth_blocking._max_mau_value)`
	`182`	`+ return_value=make_awaitable(self.auth_blocking._max_mau_value)`
`183`	`183`	`)`
`184`	`184`	`with self.assertRaises(ResourceLimitError):`
`185`	`185`	`yield defer.ensureDeferred(`
`@@ -189,21 +189,21 @@ def test_mau_limits_parity(self):`
`189`	`189`	`)`
`190`	`190`	`# If in monthly active cohort`
`191`	`191`	`self.hs.get_datastore().user_last_seen_monthly_active = Mock(`
`192`		`- side_effect=lambda user_id: make_awaitable(self.hs.get_clock().time_msec())`
	`192`	`+ return_value=make_awaitable(self.hs.get_clock().time_msec())`
`193`	`193`	`)`
`194`	`194`	`self.hs.get_datastore().get_monthly_active_count = Mock(`
`195`		`- side_effect=lambda: make_awaitable(self.auth_blocking._max_mau_value)`
	`195`	`+ return_value=make_awaitable(self.auth_blocking._max_mau_value)`
`196`	`196`	`)`
`197`	`197`	`yield defer.ensureDeferred(`
`198`	`198`	`self.auth_handler.get_access_token_for_user_id(`
`199`	`199`	`"user_a", device_id=None, valid_until_ms=None`
`200`	`200`	`)`
`201`	`201`	`)`
`202`	`202`	`self.hs.get_datastore().user_last_seen_monthly_active = Mock(`
`203`		`- side_effect=lambda user_id: make_awaitable(self.hs.get_clock().time_msec())`
	`203`	`+ return_value=make_awaitable(self.hs.get_clock().time_msec())`
`204`	`204`	`)`
`205`	`205`	`self.hs.get_datastore().get_monthly_active_count = Mock(`
`206`		`- side_effect=lambda: make_awaitable(self.auth_blocking._max_mau_value)`
	`206`	`+ return_value=make_awaitable(self.auth_blocking._max_mau_value)`
`207`	`207`	`)`
`208`	`208`	`yield defer.ensureDeferred(`
`209`	`209`	`self.auth_handler.validate_short_term_login_token_and_get_user_id(`
`@@ -216,7 +216,7 @@ def test_mau_limits_not_exceeded(self):`
`216`	`216`	`self.auth_blocking._limit_usage_by_mau = True`
`217`	`217`
`218`	`218`	`self.hs.get_datastore().get_monthly_active_count = Mock(`
`219`		`- side_effect=lambda: make_awaitable(self.small_number_of_users)`
	`219`	`+ return_value=make_awaitable(self.small_number_of_users)`
`220`	`220`	`)`
`221`	`221`	`# Ensure does not raise exception`
`222`	`222`	`yield defer.ensureDeferred(`
`@@ -226,7 +226,7 @@ def test_mau_limits_not_exceeded(self):`
`226`	`226`	`)`
`227`	`227`
`228`	`228`	`self.hs.get_datastore().get_monthly_active_count = Mock(`
`229`		`- side_effect=lambda: make_awaitable(self.small_number_of_users)`
	`229`	`+ return_value=make_awaitable(self.small_number_of_users)`
`230`	`230`	`)`
`231`	`231`	`yield defer.ensureDeferred(`
`232`	`232`	`self.auth_handler.validate_short_term_login_token_and_get_user_id(`
Original file line number	Diff line number	Diff line change
`@@ -116,7 +116,7 @@ def prepare(self, reactor, clock, hs):`
`116`	`116`	`retry_timings_res`
`117`	`117`	`)`
`118`	`118`
`119`		`- self.datastore.get_device_updates_by_remote.side_effect = lambda destination, from_stream_id, limit: make_awaitable(`
	`119`	`+ self.datastore.get_device_updates_by_remote.return_value = make_awaitable(`
`120`	`120`	`(0, [])`
`121`	`121`	`)`
`122`	`122`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ def prepare(self, reactor, clock, hs):`
`67`	`67`	`raise Exception("Failed to find reference to ResourceLimitsServerNotices")`
`68`	`68`
`69`	`69`	`self._rlsn._store.user_last_seen_monthly_active = Mock(`
`70`		`- side_effect=lambda user_id: make_awaitable(1000)`
	`70`	`+ return_value=make_awaitable(1000)`
`71`	`71`	`)`
`72`	`72`	`self._rlsn._server_notices_manager.send_notice = Mock(`
`73`	`73`	`return_value=defer.succeed(Mock())`
`@@ -81,7 +81,7 @@ def prepare(self, reactor, clock, hs):`
`81`	`81`	`)`
`82`	`82`	`self._rlsn._store.add_tag_to_room = Mock(return_value=defer.succeed(None))`
`83`	`83`	`self._rlsn._store.get_tags_for_room = Mock(`
`84`		`- side_effect=lambda user_id, room_id: make_awaitable({})`
	`84`	`+ return_value=make_awaitable({})`
`85`	`85`	`)`
`86`	`86`
`87`	`87`	`@override_config({"hs_disabled": True})`
`@@ -158,7 +158,7 @@ def test_maybe_send_server_notice_to_user_not_in_mau_cohort(self):`
`158`	`158`	`"""`
`159`	`159`	`self._rlsn._auth.check_auth_blocking = Mock(return_value=defer.succeed(None))`
`160`	`160`	`self._rlsn._store.user_last_seen_monthly_active = Mock(`
`161`		`- side_effect=lambda user_id: make_awaitable(None)`
	`161`	`+ return_value=make_awaitable(None)`
`162`	`162`	`)`
`163`	`163`	`self.get_success(self._rlsn.maybe_send_server_notice_to_user(self.user_id))`
`164`	`164`
`@@ -262,11 +262,11 @@ def prepare(self, reactor, clock, hs):`
`262`	`262`
`263`	`263`	`def test_server_notice_only_sent_once(self):`
`264`	`264`	`self.store.get_monthly_active_count = Mock(`
`265`		`- side_effect=lambda: make_awaitable(1000)`
	`265`	`+ return_value=make_awaitable(1000)`
`266`	`266`	`)`
`267`	`267`
`268`	`268`	`self.store.user_last_seen_monthly_active = Mock(`
`269`		`- side_effect=lambda user_id: make_awaitable(1000)`
	`269`	`+ return_value=make_awaitable(1000)`
`270`	`270`	`)`
`271`	`271`
`272`	`272`	`# Call the function multiple times to ensure we only send the notice once`
Original file line number	Diff line number	Diff line change
`@@ -154,7 +154,7 @@ def test_adding_monthly_active_user_when_full(self):`
`154`	`154`	`user_id = "@user:server"`
`155`	`155`
`156`	`156`	`self.store.get_monthly_active_count = Mock(`
`157`		`- side_effect=lambda: make_awaitable(lots_of_users)`
	`157`	`+ return_value=make_awaitable(lots_of_users)`
`158`	`158`	`)`
`159`	`159`	`self.get_success(`
`160`	`160`	`self.store.insert_client_ip(`