Revert "Federation outbound proxy" (#15910)

Revert "Federation outbound proxy (#15773)"

This reverts commit b07b14b494ae1dd564b4c44f844c9a9545b3d08a.

16 files changed, 37 insertions, 299 deletions

diff --git a/tests/app/test_openid_listener.py b/tests/app/test_openid_listener.py
index 21c5309740..5a965f233b 100644
--- a/tests/app/test_openid_listener.py
+++ b/tests/app/test_openid_listener.py
@@ -31,7 +31,9 @@ from tests.unittest import HomeserverTestCase
 
 class FederationReaderOpenIDListenerTests(HomeserverTestCase):
     def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer:
-        hs = self.setup_test_homeserver(homeserver_to_use=GenericWorkerServer)
+        hs = self.setup_test_homeserver(
+            federation_http_client=None, homeserver_to_use=GenericWorkerServer
+        )
         return hs
 
     def default_config(self) -> JsonDict:
@@ -89,7 +91,9 @@ class FederationReaderOpenIDListenerTests(HomeserverTestCase):
 @patch("synapse.app.homeserver.KeyResource", new=Mock())
 class SynapseHomeserverOpenIDListenerTests(HomeserverTestCase):
     def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer:
-        hs = self.setup_test_homeserver(homeserver_to_use=SynapseHomeServer)
+        hs = self.setup_test_homeserver(
+            federation_http_client=None, homeserver_to_use=SynapseHomeServer
+        )
         return hs
 
     @parameterized.expand(
diff --git a/tests/handlers/test_device.py b/tests/handlers/test_device.py
index 66215af2b8..ee48f9e546 100644
--- a/tests/handlers/test_device.py
+++ b/tests/handlers/test_device.py
@@ -41,6 +41,7 @@ class DeviceTestCase(unittest.HomeserverTestCase):
         self.appservice_api = mock.Mock()
         hs = self.setup_test_homeserver(
             "server",
+            federation_http_client=None,
             application_service_api=self.appservice_api,
         )
         handler = hs.get_device_handler()
@@ -400,7 +401,7 @@ class DeviceTestCase(unittest.HomeserverTestCase):
 
 class DehydrationTestCase(unittest.HomeserverTestCase):
     def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer:
-        hs = self.setup_test_homeserver("server")
+        hs = self.setup_test_homeserver("server", federation_http_client=None)
         handler = hs.get_device_handler()
         assert isinstance(handler, DeviceHandler)
         self.handler = handler
diff --git a/tests/handlers/test_federation.py b/tests/handlers/test_federation.py
index 5f11d5df11..bf0862ed54 100644
--- a/tests/handlers/test_federation.py
+++ b/tests/handlers/test_federation.py
@@ -57,7 +57,7 @@ class FederationTestCase(unittest.FederatingHomeserverTestCase):
     ]
 
     def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer:
-        hs = self.setup_test_homeserver()
+        hs = self.setup_test_homeserver(federation_http_client=None)
         self.handler = hs.get_federation_handler()
         self.store = hs.get_datastores().main
         return hs
diff --git a/tests/handlers/test_presence.py b/tests/handlers/test_presence.py
index fd66d573d2..19f5322317 100644
--- a/tests/handlers/test_presence.py
+++ b/tests/handlers/test_presence.py
@@ -993,6 +993,7 @@ class PresenceJoinTestCase(unittest.HomeserverTestCase):
     def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer:
         hs = self.setup_test_homeserver(
             "server",
+            federation_http_client=None,
             federation_sender=Mock(spec=FederationSender),
         )
         return hs
diff --git a/tests/handlers/test_typing.py b/tests/handlers/test_typing.py
index 5da1d95f0b..94518a7196 100644
--- a/tests/handlers/test_typing.py
+++ b/tests/handlers/test_typing.py
@@ -17,8 +17,6 @@ import json
 from typing import Dict, List, Set
 from unittest.mock import ANY, Mock, call
 
-from netaddr import IPSet
-
 from twisted.test.proto_helpers import MemoryReactor
 from twisted.web.resource import Resource
 
@@ -26,7 +24,6 @@ from synapse.api.constants import EduTypes
 from synapse.api.errors import AuthError
 from synapse.federation.transport.server import TransportLayerServer
 from synapse.handlers.typing import TypingWriterHandler
-from synapse.http.federation.matrix_federation_agent import MatrixFederationAgent
 from synapse.server import HomeServer
 from synapse.types import JsonDict, Requester, UserID, create_requester
 from synapse.util import Clock
@@ -79,13 +76,6 @@ class TypingNotificationsTestCase(unittest.HomeserverTestCase):
         # we mock out the federation client too
         self.mock_federation_client = Mock(spec=["put_json"])
         self.mock_federation_client.put_json.return_value = make_awaitable((200, "OK"))
-        self.mock_federation_client.agent = MatrixFederationAgent(
-            reactor,
-            tls_client_options_factory=None,
-            user_agent=b"SynapseInTrialTest/0.0.0",
-            ip_allowlist=None,
-            ip_blocklist=IPSet(),
-        )
 
         # the tests assume that we are starting at unix time 1000
         reactor.pump((1000,))
diff --git a/tests/http/test_matrixfederationclient.py b/tests/http/test_matrixfederationclient.py
index a8b9737d1f..b5f4a60fe5 100644
--- a/tests/http/test_matrixfederationclient.py
+++ b/tests/http/test_matrixfederationclient.py
@@ -11,8 +11,8 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from typing import Any, Dict, Generator
-from unittest.mock import ANY, Mock, create_autospec
+from typing import Generator
+from unittest.mock import Mock
 
 from netaddr import IPSet
 from parameterized import parameterized
@@ -21,11 +21,10 @@ from twisted.internet import defer
 from twisted.internet.defer import Deferred, TimeoutError
 from twisted.internet.error import ConnectingCancelledError, DNSLookupError
 from twisted.test.proto_helpers import MemoryReactor, StringTransport
-from twisted.web.client import Agent, ResponseNeverReceived
+from twisted.web.client import ResponseNeverReceived
 from twisted.web.http import HTTPChannel
-from twisted.web.http_headers import Headers
 
-from synapse.api.errors import HttpResponseException, RequestSendFailed
+from synapse.api.errors import RequestSendFailed
 from synapse.http.matrixfederationclient import (
     ByteParser,
     MatrixFederationHttpClient,
@@ -40,9 +39,7 @@ from synapse.logging.context import (
 from synapse.server import HomeServer
 from synapse.util import Clock
 
-from tests.replication._base import BaseMultiWorkerStreamTestCase
 from tests.server import FakeTransport
-from tests.test_utils import FakeResponse
 from tests.unittest import HomeserverTestCase, override_config
 
 
@@ -661,181 +658,3 @@ class FederationClientTests(HomeserverTestCase):
         self.assertEqual(self.cl.max_short_retry_delay_seconds, 7)
         self.assertEqual(self.cl.max_long_retries, 20)
         self.assertEqual(self.cl.max_short_retries, 5)
-
-
-class FederationClientProxyTests(BaseMultiWorkerStreamTestCase):
-    def default_config(self) -> Dict[str, Any]:
-        conf = super().default_config()
-        conf["instance_map"] = {
-            "main": {"host": "testserv", "port": 8765},
-            "federation_sender": {"host": "testserv", "port": 1001},
-        }
-        return conf
-
-    @override_config({"outbound_federation_restricted_to": ["federation_sender"]})
-    def test_proxy_requests_through_federation_sender_worker(self) -> None:
-        """
-        Test that all outbound federation requests go through the `federation_sender`
-        worker
-        """
-        # Mock out the `MatrixFederationHttpClient` of the `federation_sender` instance
-        # so we can act like some remote server responding to requests
-        mock_client_on_federation_sender = Mock()
-        mock_agent_on_federation_sender = create_autospec(Agent, spec_set=True)
-        mock_client_on_federation_sender.agent = mock_agent_on_federation_sender
-
-        # Create the `federation_sender` worker
-        self.federation_sender = self.make_worker_hs(
-            "synapse.app.generic_worker",
-            {"worker_name": "federation_sender"},
-            federation_http_client=mock_client_on_federation_sender,
-        )
-
-        # Fake `remoteserv:8008` responding to requests
-        mock_agent_on_federation_sender.request.side_effect = (
-            lambda *args, **kwargs: defer.succeed(
-                FakeResponse.json(
-                    payload={
-                        "foo": "bar",
-                    }
-                )
-            )
-        )
-
-        # This federation request from the main process should be proxied through the
-        # `federation_sender` worker off to the remote server
-        test_request_from_main_process_d = defer.ensureDeferred(
-            self.hs.get_federation_http_client().get_json("remoteserv:8008", "foo/bar")
-        )
-
-        # Pump the reactor so our deferred goes through the motions
-        self.pump()
-
-        # Make sure that the request was proxied through the `federation_sender` worker
-        mock_agent_on_federation_sender.request.assert_called_once_with(
-            b"GET",
-            b"matrix-federation://remoteserv:8008/foo/bar",
-            headers=ANY,
-            bodyProducer=ANY,
-        )
-
-        # Make sure the response is as expected back on the main worker
-        res = self.successResultOf(test_request_from_main_process_d)
-        self.assertEqual(res, {"foo": "bar"})
-
-    @override_config({"outbound_federation_restricted_to": ["federation_sender"]})
-    def test_proxy_request_with_network_error_through_federation_sender_worker(
-        self,
-    ) -> None:
-        """
-        Test that when the outbound federation request fails with a network related
-        error, a sensible error makes its way back to the main process.
-        """
-        # Mock out the `MatrixFederationHttpClient` of the `federation_sender` instance
-        # so we can act like some remote server responding to requests
-        mock_client_on_federation_sender = Mock()
-        mock_agent_on_federation_sender = create_autospec(Agent, spec_set=True)
-        mock_client_on_federation_sender.agent = mock_agent_on_federation_sender
-
-        # Create the `federation_sender` worker
-        self.federation_sender = self.make_worker_hs(
-            "synapse.app.generic_worker",
-            {"worker_name": "federation_sender"},
-            federation_http_client=mock_client_on_federation_sender,
-        )
-
-        # Fake `remoteserv:8008` responding to requests
-        mock_agent_on_federation_sender.request.side_effect = (
-            lambda *args, **kwargs: defer.fail(ResponseNeverReceived("fake error"))
-        )
-
-        # This federation request from the main process should be proxied through the
-        # `federation_sender` worker off to the remote server
-        test_request_from_main_process_d = defer.ensureDeferred(
-            self.hs.get_federation_http_client().get_json("remoteserv:8008", "foo/bar")
-        )
-
-        # Pump the reactor so our deferred goes through the motions. We pump with 10
-        # seconds (0.1 * 100) so the `MatrixFederationHttpClient` runs out of retries
-        # and finally passes along the error response.
-        self.pump(0.1)
-
-        # Make sure that the request was proxied through the `federation_sender` worker
-        mock_agent_on_federation_sender.request.assert_called_with(
-            b"GET",
-            b"matrix-federation://remoteserv:8008/foo/bar",
-            headers=ANY,
-            bodyProducer=ANY,
-        )
-
-        # Make sure we get some sort of error back on the main worker
-        failure_res = self.failureResultOf(test_request_from_main_process_d)
-        self.assertIsInstance(failure_res.value, RequestSendFailed)
-        self.assertIsInstance(failure_res.value.inner_exception, HttpResponseException)
-
-    @override_config({"outbound_federation_restricted_to": ["federation_sender"]})
-    def test_proxy_requests_and_discards_hop_by_hop_headers(self) -> None:
-        """
-        Test to make sure hop-by-hop headers and addional headers defined in the
-        `Connection` header are discarded when proxying requests
-        """
-        # Mock out the `MatrixFederationHttpClient` of the `federation_sender` instance
-        # so we can act like some remote server responding to requests
-        mock_client_on_federation_sender = Mock()
-        mock_agent_on_federation_sender = create_autospec(Agent, spec_set=True)
-        mock_client_on_federation_sender.agent = mock_agent_on_federation_sender
-
-        # Create the `federation_sender` worker
-        self.federation_sender = self.make_worker_hs(
-            "synapse.app.generic_worker",
-            {"worker_name": "federation_sender"},
-            federation_http_client=mock_client_on_federation_sender,
-        )
-
-        # Fake `remoteserv:8008` responding to requests
-        mock_agent_on_federation_sender.request.side_effect = lambda *args, **kwargs: defer.succeed(
-            FakeResponse(
-                code=200,
-                body=b'{"foo": "bar"}',
-                headers=Headers(
-                    {
-                        "Content-Type": ["application/json"],
-                        "Connection": ["close, X-Foo, X-Bar"],
-                        # Should be removed because it's defined in the `Connection` header
-                        "X-Foo": ["foo"],
-                        "X-Bar": ["bar"],
-                        # Should be removed because it's a hop-by-hop header
-                        "Proxy-Authorization": "abcdef",
-                    }
-                ),
-            )
-        )
-
-        # This federation request from the main process should be proxied through the
-        # `federation_sender` worker off to the remote server
-        test_request_from_main_process_d = defer.ensureDeferred(
-            self.hs.get_federation_http_client().get_json_with_headers(
-                "remoteserv:8008", "foo/bar"
-            )
-        )
-
-        # Pump the reactor so our deferred goes through the motions
-        self.pump()
-
-        # Make sure that the request was proxied through the `federation_sender` worker
-        mock_agent_on_federation_sender.request.assert_called_once_with(
-            b"GET",
-            b"matrix-federation://remoteserv:8008/foo/bar",
-            headers=ANY,
-            bodyProducer=ANY,
-        )
-
-        res, headers = self.successResultOf(test_request_from_main_process_d)
-        header_names = set(headers.keys())
-
-        # Make sure the response does not include the hop-by-hop headers
-        self.assertNotIn(b"X-Foo", header_names)
-        self.assertNotIn(b"X-Bar", header_names)
-        self.assertNotIn(b"Proxy-Authorization", header_names)
-        # Make sure the response is as expected back on the main worker
-        self.assertEqual(res, {"foo": "bar"})
diff --git a/tests/http/test_proxy.py b/tests/http/test_proxy.py
deleted file mode 100644
index 0dc9ba8e05..0000000000
--- a/tests/http/test_proxy.py
+++ /dev/null
@@ -1,53 +0,0 @@
-# Copyright 2023 The Matrix.org Foundation C.I.C.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-from typing import Set
-
-from parameterized import parameterized
-
-from synapse.http.proxy import parse_connection_header_value
-
-from tests.unittest import TestCase
-
-
-class ProxyTests(TestCase):
-    @parameterized.expand(
-        [
-            [b"close, X-Foo, X-Bar", {"Close", "X-Foo", "X-Bar"}],
-            # No whitespace
-            [b"close,X-Foo,X-Bar", {"Close", "X-Foo", "X-Bar"}],
-            # More whitespace
-            [b"close,    X-Foo,      X-Bar", {"Close", "X-Foo", "X-Bar"}],
-            # "close" directive in not the first position
-            [b"X-Foo, X-Bar, close", {"X-Foo", "X-Bar", "Close"}],
-            # Normalizes header capitalization
-            [b"keep-alive, x-fOo, x-bAr", {"Keep-Alive", "X-Foo", "X-Bar"}],
-            # Handles header names with whitespace
-            [
-                b"keep-alive, x  foo, x bar",
-                {"Keep-Alive", "X  foo", "X bar"},
-            ],
-        ]
-    )
-    def test_parse_connection_header_value(
-        self,
-        connection_header_value: bytes,
-        expected_extra_headers_to_remove: Set[str],
-    ) -> None:
-        """
-        Tests that the connection header value is parsed correctly
-        """
-        self.assertEqual(
-            expected_extra_headers_to_remove,
-            parse_connection_header_value(connection_header_value),
-        )
diff --git a/tests/replication/_base.py b/tests/replication/_base.py
index 96badc46b0..eb9b1f1cd9 100644
--- a/tests/replication/_base.py
+++ b/tests/replication/_base.py
@@ -69,10 +69,10 @@ class BaseStreamTestCase(unittest.HomeserverTestCase):
         # Make a new HomeServer object for the worker
         self.reactor.lookups["testserv"] = "1.2.3.4"
         self.worker_hs = self.setup_test_homeserver(
+            federation_http_client=None,
             homeserver_to_use=GenericWorkerServer,
             config=self._get_worker_hs_config(),
             reactor=self.reactor,
-            federation_http_client=None,
         )
 
         # Since we use sqlite in memory databases we need to make sure the
@@ -380,7 +380,6 @@ class BaseMultiWorkerStreamTestCase(unittest.HomeserverTestCase):
             server_version_string="1",
             max_request_body_size=8192,
             reactor=self.reactor,
-            federation_agent=worker_hs.get_federation_http_client().agent,
         )
 
         worker_hs.get_replication_command_handler().start_replication(worker_hs)
diff --git a/tests/replication/test_federation_sender_shard.py b/tests/replication/test_federation_sender_shard.py
index a324b4d31d..08703206a9 100644
--- a/tests/replication/test_federation_sender_shard.py
+++ b/tests/replication/test_federation_sender_shard.py
@@ -14,18 +14,14 @@
 import logging
 from unittest.mock import Mock
 
-from netaddr import IPSet
-
 from synapse.api.constants import EventTypes, Membership
 from synapse.events.builder import EventBuilderFactory
 from synapse.handlers.typing import TypingWriterHandler
-from synapse.http.federation.matrix_federation_agent import MatrixFederationAgent
 from synapse.rest.admin import register_servlets_for_client_rest_resource
 from synapse.rest.client import login, room
 from synapse.types import UserID, create_requester
 
 from tests.replication._base import BaseMultiWorkerStreamTestCase
-from tests.server import get_clock
 from tests.test_utils import make_awaitable
 
 logger = logging.getLogger(__name__)
@@ -45,25 +41,13 @@ class FederationSenderTestCase(BaseMultiWorkerStreamTestCase):
         room.register_servlets,
     ]
 
-    def setUp(self) -> None:
-        super().setUp()
-
-        reactor, _ = get_clock()
-        self.matrix_federation_agent = MatrixFederationAgent(
-            reactor,
-            tls_client_options_factory=None,
-            user_agent=b"SynapseInTrialTest/0.0.0",
-            ip_allowlist=None,
-            ip_blocklist=IPSet(),
-        )
-
     def test_send_event_single_sender(self) -> None:
         """Test that using a single federation sender worker correctly sends a
         new event.
         """
         mock_client = Mock(spec=["put_json"])
         mock_client.put_json.return_value = make_awaitable({})
-        mock_client.agent = self.matrix_federation_agent
+
         self.make_worker_hs(
             "synapse.app.generic_worker",
             {
@@ -94,7 +78,6 @@ class FederationSenderTestCase(BaseMultiWorkerStreamTestCase):
         """
         mock_client1 = Mock(spec=["put_json"])
         mock_client1.put_json.return_value = make_awaitable({})
-        mock_client1.agent = self.matrix_federation_agent
         self.make_worker_hs(
             "synapse.app.generic_worker",
             {
@@ -109,7 +92,6 @@ class FederationSenderTestCase(BaseMultiWorkerStreamTestCase):
 
         mock_client2 = Mock(spec=["put_json"])
         mock_client2.put_json.return_value = make_awaitable({})
-        mock_client2.agent = self.matrix_federation_agent
         self.make_worker_hs(
             "synapse.app.generic_worker",
             {
@@ -163,7 +145,6 @@ class FederationSenderTestCase(BaseMultiWorkerStreamTestCase):
         """
         mock_client1 = Mock(spec=["put_json"])
         mock_client1.put_json.return_value = make_awaitable({})
-        mock_client1.agent = self.matrix_federation_agent
         self.make_worker_hs(
             "synapse.app.generic_worker",
             {
@@ -178,7 +159,6 @@ class FederationSenderTestCase(BaseMultiWorkerStreamTestCase):
 
         mock_client2 = Mock(spec=["put_json"])
         mock_client2.put_json.return_value = make_awaitable({})
-        mock_client2.agent = self.matrix_federation_agent
         self.make_worker_hs(
             "synapse.app.generic_worker",
             {
diff --git a/tests/rest/client/test_presence.py b/tests/rest/client/test_presence.py
index e12098102b..dcbb125a3b 100644
--- a/tests/rest/client/test_presence.py
+++ b/tests/rest/client/test_presence.py
@@ -40,6 +40,7 @@ class PresenceTestCase(unittest.HomeserverTestCase):
 
         hs = self.setup_test_homeserver(
             "red",
+            federation_http_client=None,
             federation_client=Mock(),
             presence_handler=self.presence_handler,
         )
diff --git a/tests/rest/client/test_rooms.py b/tests/rest/client/test_rooms.py
index d013e75d55..f1b4e1ad2f 100644
--- a/tests/rest/client/test_rooms.py
+++ b/tests/rest/client/test_rooms.py
@@ -67,6 +67,8 @@ class RoomBase(unittest.HomeserverTestCase):
     def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer:
         self.hs = self.setup_test_homeserver(
             "red",
+            federation_http_client=None,
+            federation_client=Mock(),
         )
 
         self.hs.get_federation_handler = Mock()  # type: ignore[assignment]
diff --git a/tests/storage/test_e2e_room_keys.py b/tests/storage/test_e2e_room_keys.py
index f6df31aba4..9cb326d90a 100644
--- a/tests/storage/test_e2e_room_keys.py
+++ b/tests/storage/test_e2e_room_keys.py
@@ -31,7 +31,7 @@ room_key: RoomKey = {
 
 class E2eRoomKeysHandlerTestCase(unittest.HomeserverTestCase):
     def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer:
-        hs = self.setup_test_homeserver("server")
+        hs = self.setup_test_homeserver("server", federation_http_client=None)
         self.store = hs.get_datastores().main
         return hs
 
diff --git a/tests/storage/test_purge.py b/tests/storage/test_purge.py
index 0282673167..857e2caf2e 100644
--- a/tests/storage/test_purge.py
+++ b/tests/storage/test_purge.py
@@ -27,7 +27,7 @@ class PurgeTests(HomeserverTestCase):
     servlets = [room.register_servlets]
 
     def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer:
-        hs = self.setup_test_homeserver("server")
+        hs = self.setup_test_homeserver("server", federation_http_client=None)
         return hs
 
     def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None:
diff --git a/tests/storage/test_rollback_worker.py b/tests/storage/test_rollback_worker.py
index 809c9f175d..6861d3a6c9 100644
--- a/tests/storage/test_rollback_worker.py
+++ b/tests/storage/test_rollback_worker.py
@@ -45,7 +45,9 @@ def fake_listdir(filepath: str) -> List[str]:
 
 class WorkerSchemaTests(HomeserverTestCase):
     def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer:
-        hs = self.setup_test_homeserver(homeserver_to_use=GenericWorkerServer)
+        hs = self.setup_test_homeserver(
+            federation_http_client=None, homeserver_to_use=GenericWorkerServer
+        )
         return hs
 
     def default_config(self) -> JsonDict:
diff --git a/tests/test_server.py b/tests/test_server.py
index fe5afebdcd..e266c06a2c 100644
--- a/tests/test_server.py
+++ b/tests/test_server.py
@@ -38,7 +38,7 @@ from tests.http.server._base import test_disconnect
 from tests.server import (
     FakeChannel,
     FakeSite,
-    get_clock,
+    ThreadedMemoryReactorClock,
     make_request,
     setup_test_homeserver,
 )
@@ -46,11 +46,12 @@ from tests.server import (
 
 class JsonResourceTests(unittest.TestCase):
     def setUp(self) -> None:
-        reactor, clock = get_clock()
-        self.reactor = reactor
+        self.reactor = ThreadedMemoryReactorClock()
+        self.hs_clock = Clock(self.reactor)
         self.homeserver = setup_test_homeserver(
             self.addCleanup,
-            clock=clock,
+            federation_http_client=None,
+            clock=self.hs_clock,
             reactor=self.reactor,
         )
 
@@ -208,13 +209,7 @@ class JsonResourceTests(unittest.TestCase):
 
 class OptionsResourceTests(unittest.TestCase):
     def setUp(self) -> None:
-        reactor, clock = get_clock()
-        self.reactor = reactor
-        self.homeserver = setup_test_homeserver(
-            self.addCleanup,
-            clock=clock,
-            reactor=self.reactor,
-        )
+        self.reactor = ThreadedMemoryReactorClock()
 
         class DummyResource(Resource):
             isLeaf = True
@@ -247,7 +242,6 @@ class OptionsResourceTests(unittest.TestCase):
             "1.0",
             max_request_body_size=4096,
             reactor=self.reactor,
-            federation_agent=self.homeserver.get_federation_http_client().agent,
         )
 
         # render the request and return the channel
@@ -350,8 +344,7 @@ class WrapHtmlRequestHandlerTests(unittest.TestCase):
             await self.callback(request)
 
     def setUp(self) -> None:
-        reactor, _ = get_clock()
-        self.reactor = reactor
+        self.reactor = ThreadedMemoryReactorClock()
 
     def test_good_response(self) -> None:
         async def callback(request: SynapseRequest) -> None:
@@ -469,9 +462,9 @@ class DirectServeJsonResourceCancellationTests(unittest.TestCase):
     """Tests for `DirectServeJsonResource` cancellation."""
 
     def setUp(self) -> None:
-        reactor, clock = get_clock()
-        self.reactor = reactor
-        self.resource = CancellableDirectServeJsonResource(clock)
+        self.reactor = ThreadedMemoryReactorClock()
+        self.clock = Clock(self.reactor)
+        self.resource = CancellableDirectServeJsonResource(self.clock)
         self.site = FakeSite(self.resource, self.reactor)
 
     def test_cancellable_disconnect(self) -> None:
@@ -503,9 +496,9 @@ class DirectServeHtmlResourceCancellationTests(unittest.TestCase):
     """Tests for `DirectServeHtmlResource` cancellation."""
 
     def setUp(self) -> None:
-        reactor, clock = get_clock()
-        self.reactor = reactor
-        self.resource = CancellableDirectServeHtmlResource(clock)
+        self.reactor = ThreadedMemoryReactorClock()
+        self.clock = Clock(self.reactor)
+        self.resource = CancellableDirectServeHtmlResource(self.clock)
         self.site = FakeSite(self.resource, self.reactor)
 
     def test_cancellable_disconnect(self) -> None:
diff --git a/tests/unittest.py b/tests/unittest.py
index 334a95a917..c73195b32b 100644
--- a/tests/unittest.py
+++ b/tests/unittest.py
@@ -358,7 +358,6 @@ class HomeserverTestCase(TestCase):
             server_version_string="1",
             max_request_body_size=4096,
             reactor=self.reactor,
-            federation_agent=self.hs.get_federation_http_client().agent,
         )
 
         from tests.rest.client.utils import RestHelper