Remove MockClock() usage

Author: MadLittleMods

synapse/app/phone_stats_home.py

@@ -33,15 +33,17 @@
     run_as_background_process,
 )
 from synapse.types import JsonDict
-from synapse.util.constants import ONE_HOUR_SECONDS, ONE_MINUTE_SECONDS
+from synapse.util.constants import (
+    MILLISECONDS_PER_SECOND,
+    ONE_HOUR_SECONDS,
+    ONE_MINUTE_SECONDS,
+)
 
 if TYPE_CHECKING:
     from synapse.server import HomeServer
 
 logger = logging.getLogger("synapse.app.homeserver")
 
-MILLISECONDS_PER_SECOND = 1000
-
 INITIAL_DELAY_BEFORE_FIRST_PHONE_HOME_SECONDS = 5 * ONE_MINUTE_SECONDS
 """
 We wait 5 minutes to send the first set of stats as the server can be quite busy the

synapse/util/constants.py

@@ -18,3 +18,5 @@
 # readability and catching bugs.
 ONE_MINUTE_SECONDS = 60
 ONE_HOUR_SECONDS = 60 * ONE_MINUTE_SECONDS
+
+MILLISECONDS_PER_SECOND = 1000

tests/appservice/test_scheduler.py

@@ -18,7 +18,7 @@
 # [This file includes modifications made by New Vector Limited]
 #
 #
-from typing import List, Optional, Sequence, Tuple, cast
+from typing import List, Optional, Sequence, Tuple
 from unittest.mock import AsyncMock, Mock
 
 from typing_extensions import TypeAlias
@@ -44,13 +44,12 @@
 from synapse.util.clock import Clock
 
 from tests import unittest
-
-from ..utils import MockClock
+from tests.server import get_clock
 
 
 class ApplicationServiceSchedulerTransactionCtrlTestCase(unittest.TestCase):
     def setUp(self) -> None:
-        self.clock = MockClock()
+        self.reactor, self.clock = get_clock()
         self.store = Mock()
         self.as_api = Mock()
 
@@ -170,14 +169,14 @@ def test_single_service_up_txn_not_sent(self) -> None:
 
 class ApplicationServiceSchedulerRecovererTestCase(unittest.TestCase):
     def setUp(self) -> None:
-        self.clock = MockClock()
+        self.reactor, self.clock = get_clock()
         self.as_api = Mock()
         self.store = Mock()
         self.service = Mock()
         self.callback = AsyncMock()
         self.recoverer = _Recoverer(
             server_name="test_server",
-            clock=cast(Clock, self.clock),
+            clock=self.clock,
             as_api=self.as_api,
             store=self.store,
             service=self.service,
@@ -202,7 +201,7 @@ def take_txn(
         txn.send = AsyncMock(return_value=True)
         txn.complete = AsyncMock(return_value=None)
         # wait for exp backoff
-        self.clock.advance_time(2)
+        self.reactor.advance(2)
         self.assertEqual(1, txn.send.call_count)
         self.assertEqual(1, txn.complete.call_count)
         # 2 because it needs to get None to know there are no more txns
@@ -229,21 +228,21 @@ def take_txn(
         self.assertEqual(0, self.store.get_oldest_unsent_txn.call_count)
         txn.send = AsyncMock(return_value=False)
         txn.complete = AsyncMock(return_value=None)
-        self.clock.advance_time(2)
+        self.reactor.advance(2)
         self.assertEqual(1, txn.send.call_count)
         self.assertEqual(0, txn.complete.call_count)
         self.assertEqual(0, self.callback.call_count)
-        self.clock.advance_time(4)
+        self.reactor.advance(4)
         self.assertEqual(2, txn.send.call_count)
         self.assertEqual(0, txn.complete.call_count)
         self.assertEqual(0, self.callback.call_count)
-        self.clock.advance_time(8)
+        self.reactor.advance(8)
         self.assertEqual(3, txn.send.call_count)
         self.assertEqual(0, txn.complete.call_count)
         self.assertEqual(0, self.callback.call_count)
         txn.send = AsyncMock(return_value=True)  # successfully send the txn
         pop_txn = True  # returns the txn the first time, then no more.
-        self.clock.advance_time(16)
+        self.reactor.advance(16)
         self.assertEqual(1, txn.send.call_count)  # new mock reset call count
         self.assertEqual(1, txn.complete.call_count)
         self.callback.assert_called_once_with(self.recoverer)
@@ -268,7 +267,7 @@ def take_txn(
         self.assertEqual(0, self.store.get_oldest_unsent_txn.call_count)
         txn.send = AsyncMock(return_value=False)
         txn.complete = AsyncMock(return_value=None)
-        self.clock.advance_time(2)
+        self.reactor.advance(2)
         self.assertEqual(1, txn.send.call_count)
         self.assertEqual(0, txn.complete.call_count)
         self.assertEqual(0, self.callback.call_count)

tests/handlers/test_appservice.py

@@ -49,9 +49,9 @@
 from synapse.util.stringutils import random_string
 
 from tests import unittest
+from tests.server import get_clock
 from tests.test_utils import event_injection
 from tests.unittest import override_config
-from tests.utils import MockClock
 
 
 class AppServiceHandlerTestCase(unittest.TestCase):
@@ -61,14 +61,16 @@ def setUp(self) -> None:
         self.mock_store = Mock()
         self.mock_as_api = AsyncMock()
         self.mock_scheduler = Mock()
+        self.reactor, self.clock = get_clock()
+
         hs = Mock()
         hs.get_datastores.return_value = Mock(main=self.mock_store)
         self.mock_store.get_appservice_last_pos = AsyncMock(return_value=None)
         self.mock_store.set_appservice_last_pos = AsyncMock(return_value=None)
         self.mock_store.set_appservice_stream_type_pos = AsyncMock(return_value=None)
         hs.get_application_service_api.return_value = self.mock_as_api
         hs.get_application_service_scheduler.return_value = self.mock_scheduler
-        hs.get_clock.return_value = MockClock()
+        hs.get_clock.return_value = self.clock
         self.handler = ApplicationServicesHandler(hs)
         self.event_source = hs.get_event_sources()
 

tests/handlers/test_e2e_room_keys.py

@@ -21,7 +21,6 @@
 #
 
 import copy
-from unittest import mock
 
 from twisted.internet.testing import MemoryReactor
 

tests/http/federation/test_srv_resolver.py

@@ -30,7 +30,7 @@
 from synapse.logging.context import LoggingContext, current_context
 
 from tests import unittest
-from tests.utils import MockClock
+from tests.server import get_clock
 
 
 class SrvResolverTestCase(unittest.TestCase):
@@ -105,7 +105,7 @@ def test_from_cache_expired_and_dns_fail(
 
     @defer.inlineCallbacks
     def test_from_cache(self) -> Generator["Deferred[object]", object, None]:
-        clock = MockClock()
+        reactor, clock = get_clock()
 
         dns_client_mock = Mock(spec_set=["lookupService"])
         dns_client_mock.lookupService = Mock(spec_set=[])

tests/rest/client/test_transactions.py

@@ -29,16 +29,19 @@
 from synapse.rest.client.transactions import CLEANUP_PERIOD_MS, HttpTransactionCache
 from synapse.types import ISynapseReactor, JsonDict
 from synapse.util.clock import Clock
+from synapse.util.constants import (
+    MILLISECONDS_PER_SECOND,
+)
 
 from tests import unittest
-from tests.utils import MockClock
+from tests.server import get_clock
 
 reactor = cast(ISynapseReactor, _reactor)
 
 
 class HttpTransactionCacheTestCase(unittest.TestCase):
     def setUp(self) -> None:
-        self.clock = MockClock()
+        self.reactor, self.clock = get_clock()
         self.hs = Mock()
         self.hs.get_clock = Mock(return_value=self.clock)
         self.hs.get_auth = Mock()
@@ -180,16 +183,18 @@ def test_cleans_up(self) -> Generator["defer.Deferred[Any]", object, None]:
         yield self.cache.fetch_or_execute_request(
             self.mock_request, self.mock_requester, cb, "an arg"
         )
-        # should NOT have cleaned up yet
-        self.clock.advance_time_msec(CLEANUP_PERIOD_MS / 2)
+        # Advance time just under the cleanup period.
+        # Should NOT have cleaned up yet
+        self.reactor.advance((CLEANUP_PERIOD_MS - 1) / MILLISECONDS_PER_SECOND)
 
         yield self.cache.fetch_or_execute_request(
             self.mock_request, self.mock_requester, cb, "an arg"
         )
         # still using cache
         cb.assert_called_once_with("an arg")
 
-        self.clock.advance_time_msec(CLEANUP_PERIOD_MS)
+        # Advance time just after the cleanup period.
+        self.reactor.advance(2 / MILLISECONDS_PER_SECOND)
 
         yield self.cache.fetch_or_execute_request(
             self.mock_request, self.mock_requester, cb, "an arg"

tests/server.py

@@ -1037,10 +1037,10 @@ def setup_test_homeserver(
     Args:
         cleanup_func: The function used to register a cleanup routine for after the
             test.
-        server_name: homeserver name
-        config: TODO
-        reactor: TODO
-        homeserver_to_use: TODO
+        server_name: Homeserver name
+        config: Homeserver config
+        reactor: Twisted reactor
+        homeserver_to_use: Homeserver class to instantiate.
         db_txn_limit: Gives the maximum number of database transactions to run per
             connection before reconnecting. 0 means no limit. If unset, defaults to None
             here which will default upstream to `0`.

tests/test_state.py

@@ -29,7 +29,6 @@
     Optional,
     Set,
     Tuple,
-    cast,
 )
 from unittest.mock import AsyncMock, Mock
 
@@ -43,12 +42,11 @@
 from synapse.state import StateHandler, StateResolutionHandler, _make_state_cache_entry
 from synapse.types import MutableStateMap, StateMap
 from synapse.types.state import StateFilter
-from synapse.util.clock import Clock
 from synapse.util.macaroons import MacaroonGenerator
 
 from tests import unittest
-
-from .utils import MockClock, default_config
+from tests.server import get_clock
+from tests.utils import default_config
 
 _next_event_id = 1000
 
@@ -248,7 +246,7 @@ def setUp(self) -> None:
                 "hostname",
             ]
         )
-        clock = cast(Clock, MockClock())
+        reactor, clock = get_clock()
         hs.config = default_config("tesths", True)
         hs.get_datastores.return_value = Mock(
             main=self.dummy_store,

tests/util/test_expiring_cache.py

@@ -19,23 +19,22 @@
 #
 #
 
-from typing import List, cast
+from typing import List
 
 from synapse.util.caches.expiringcache import ExpiringCache
-from synapse.util.clock import Clock
 
-from tests.utils import MockClock
+from tests.server import get_clock
 
 from .. import unittest
 
 
 class ExpiringCacheTestCase(unittest.HomeserverTestCase):
     def test_get_set(self) -> None:
-        clock = MockClock()
+        reactor, clock = get_clock()
         cache: ExpiringCache[str, str] = ExpiringCache(
             cache_name="test",
             server_name="testserver",
-            clock=cast(Clock, clock),
+            clock=clock,
             max_len=1,
         )
 
@@ -44,11 +43,11 @@ def test_get_set(self) -> None:
         self.assertEqual(cache["key"], "value")
 
     def test_eviction(self) -> None:
-        clock = MockClock()
+        reactor, clock = get_clock()
         cache: ExpiringCache[str, str] = ExpiringCache(
             cache_name="test",
             server_name="testserver",
-            clock=cast(Clock, clock),
+            clock=clock,
             max_len=2,
         )
 
@@ -63,11 +62,11 @@ def test_eviction(self) -> None:
         self.assertEqual(cache.get("key3"), "value3")
 
     def test_iterable_eviction(self) -> None:
-        clock = MockClock()
+        reactor, clock = get_clock()
         cache: ExpiringCache[str, List[int]] = ExpiringCache(
             cache_name="test",
             server_name="testserver",
-            clock=cast(Clock, clock),
+            clock=clock,
             max_len=5,
             iterable=True,
         )
@@ -87,25 +86,25 @@ def test_iterable_eviction(self) -> None:
         self.assertEqual(cache.get("key4"), [6, 7])
 
     def test_time_eviction(self) -> None:
-        clock = MockClock()
+        reactor, clock = get_clock()
         cache: ExpiringCache[str, int] = ExpiringCache(
             cache_name="test",
             server_name="testserver",
-            clock=cast(Clock, clock),
+            clock=clock,
             expiry_ms=1000,
         )
 
         cache["key"] = 1
-        clock.advance_time(0.5)
+        reactor.advance(0.5)
         cache["key2"] = 2
 
         self.assertEqual(cache.get("key"), 1)
         self.assertEqual(cache.get("key2"), 2)
 
-        clock.advance_time(0.9)
+        reactor.advance(0.9)
         self.assertEqual(cache.get("key"), None)
         self.assertEqual(cache.get("key2"), 2)
 
-        clock.advance_time(1)
+        reactor.advance(1)
         self.assertEqual(cache.get("key"), None)
         self.assertEqual(cache.get("key2"), None)