Run Black on the tests again (#5170)

changelog.d/5170.misc

@@ -0,0 +1 @@
+Run `black` on the tests directory.

tests/api/test_filtering.py

@@ -109,7 +109,6 @@ class FilteringTestCase(unittest.TestCase):
                 "event_format": "client",
                 "event_fields": ["type", "content", "sender"],
             },
-
             # a single backslash should be permitted (though it is debatable whether
             # it should be permitted before anything other than `.`, and what that
             # actually means)

tests/api/test_ratelimiting.py

@@ -10,19 +10,19 @@ class TestRatelimiter(unittest.TestCase):
             key="test_id", time_now_s=0, rate_hz=0.1, burst_count=1
         )
         self.assertTrue(allowed)
-        self.assertEquals(10., time_allowed)
+        self.assertEquals(10.0, time_allowed)
 
         allowed, time_allowed = limiter.can_do_action(
             key="test_id", time_now_s=5, rate_hz=0.1, burst_count=1
         )
         self.assertFalse(allowed)
-        self.assertEquals(10., time_allowed)
+        self.assertEquals(10.0, time_allowed)
 
         allowed, time_allowed = limiter.can_do_action(
             key="test_id", time_now_s=10, rate_hz=0.1, burst_count=1
         )
         self.assertTrue(allowed)
-        self.assertEquals(20., time_allowed)
+        self.assertEquals(20.0, time_allowed)
 
     def test_pruning(self):
         limiter = Ratelimiter()

tests/app/test_openid_listener.py

@@ -25,16 +25,18 @@ from tests.unittest import HomeserverTestCase
 class FederationReaderOpenIDListenerTests(HomeserverTestCase):
     def make_homeserver(self, reactor, clock):
         hs = self.setup_test_homeserver(
-            http_client=None, homeserverToUse=FederationReaderServer,
+            http_client=None, homeserverToUse=FederationReaderServer
         )
         return hs
 
-    @parameterized.expand([
+    @parameterized.expand(
-        (["federation"], "auth_fail"),
+        [
-        ([], "no_resource"),
+            (["federation"], "auth_fail"),
-        (["openid", "federation"], "auth_fail"),
+            ([], "no_resource"),
-        (["openid"], "auth_fail"),
+            (["openid", "federation"], "auth_fail"),
-    ])
+            (["openid"], "auth_fail"),
+        ]
+    )
     def test_openid_listener(self, names, expectation):
         """
         Test different openid listener configurations.
@@ -53,17 +55,14 @@ class FederationReaderOpenIDListenerTests(HomeserverTestCase):
         # Grab the resource from the site that was told to listen
         site = self.reactor.tcpServers[0][1]
         try:
-            self.resource = (
+            self.resource = site.resource.children[b"_matrix"].children[b"federation"]
-                site.resource.children[b"_matrix"].children[b"federation"]
-            )
         except KeyError:
             if expectation == "no_resource":
                 return
             raise
 
         request, channel = self.make_request(
-            "GET",
+            "GET", "/_matrix/federation/v1/openid/userinfo"
-            "/_matrix/federation/v1/openid/userinfo",
         )
         self.render(request)
 
@@ -74,16 +73,18 @@ class FederationReaderOpenIDListenerTests(HomeserverTestCase):
 class SynapseHomeserverOpenIDListenerTests(HomeserverTestCase):
     def make_homeserver(self, reactor, clock):
         hs = self.setup_test_homeserver(
-            http_client=None, homeserverToUse=SynapseHomeServer,
+            http_client=None, homeserverToUse=SynapseHomeServer
         )
         return hs
 
-    @parameterized.expand([
+    @parameterized.expand(
-        (["federation"], "auth_fail"),
+        [
-        ([], "no_resource"),
+            (["federation"], "auth_fail"),
-        (["openid", "federation"], "auth_fail"),
+            ([], "no_resource"),
-        (["openid"], "auth_fail"),
+            (["openid", "federation"], "auth_fail"),
-    ])
+            (["openid"], "auth_fail"),
+        ]
+    )
     def test_openid_listener(self, names, expectation):
         """
         Test different openid listener configurations.
@@ -102,17 +103,14 @@ class SynapseHomeserverOpenIDListenerTests(HomeserverTestCase):
         # Grab the resource from the site that was told to listen
         site = self.reactor.tcpServers[0][1]
         try:
-            self.resource = (
+            self.resource = site.resource.children[b"_matrix"].children[b"federation"]
-                site.resource.children[b"_matrix"].children[b"federation"]
-            )
         except KeyError:
             if expectation == "no_resource":
                 return
             raise
 
         request, channel = self.make_request(
-            "GET",
+            "GET", "/_matrix/federation/v1/openid/userinfo"
-            "/_matrix/federation/v1/openid/userinfo",
         )
         self.render(request)
 

tests/config/test_generate.py

@@ -45,13 +45,7 @@ class ConfigGenerationTestCase(unittest.TestCase):
         )
 
         self.assertSetEqual(
-            set(
+            set(["homeserver.yaml", "lemurs.win.log.config", "lemurs.win.signing.key"]),
-                [
-                    "homeserver.yaml",
-                    "lemurs.win.log.config",
-                    "lemurs.win.signing.key",
-                ]
-            ),
             set(os.listdir(self.dir)),
         )
 

tests/config/test_room_directory.py

@@ -22,7 +22,8 @@ from tests import unittest
 
 class RoomDirectoryConfigTestCase(unittest.TestCase):
     def test_alias_creation_acl(self):
-        config = yaml.safe_load("""
+        config = yaml.safe_load(
+            """
         alias_creation_rules:
             - user_id: "*bob*"
               alias: "*"
@@ -38,43 +39,49 @@ class RoomDirectoryConfigTestCase(unittest.TestCase):
               action: "allow"
 
         room_list_publication_rules: []
-        """)
+        """
+        )
 
         rd_config = RoomDirectoryConfig()
         rd_config.read_config(config)
 
-        self.assertFalse(rd_config.is_alias_creation_allowed(
+        self.assertFalse(
-            user_id="@bob:example.com",
+            rd_config.is_alias_creation_allowed(
-            room_id="!test",
+                user_id="@bob:example.com", room_id="!test", alias="#test:example.com"
-            alias="#test:example.com",
+            )
-        ))
+        )
 
-        self.assertTrue(rd_config.is_alias_creation_allowed(
+        self.assertTrue(
-            user_id="@test:example.com",
+            rd_config.is_alias_creation_allowed(
-            room_id="!test",
+                user_id="@test:example.com",
-            alias="#unofficial_st:example.com",
+                room_id="!test",
-        ))
+                alias="#unofficial_st:example.com",
+            )
+        )
 
-        self.assertTrue(rd_config.is_alias_creation_allowed(
+        self.assertTrue(
-            user_id="@foobar:example.com",
+            rd_config.is_alias_creation_allowed(
-            room_id="!test",
+                user_id="@foobar:example.com",
-            alias="#test:example.com",
+                room_id="!test",
-        ))
+                alias="#test:example.com",
+            )
+        )
 
-        self.assertTrue(rd_config.is_alias_creation_allowed(
+        self.assertTrue(
-            user_id="@gah:example.com",
+            rd_config.is_alias_creation_allowed(
-            room_id="!test",
+                user_id="@gah:example.com", room_id="!test", alias="#goo:example.com"
-            alias="#goo:example.com",
+            )
-        ))
+        )
 
-        self.assertFalse(rd_config.is_alias_creation_allowed(
+        self.assertFalse(
-            user_id="@test:example.com",
+            rd_config.is_alias_creation_allowed(
-            room_id="!test",
+                user_id="@test:example.com", room_id="!test", alias="#test:example.com"
-            alias="#test:example.com",
+            )
-        ))
+        )
 
     def test_room_publish_acl(self):
-        config = yaml.safe_load("""
+        config = yaml.safe_load(
+            """
         alias_creation_rules: []
 
         room_list_publication_rules:
@@ -92,55 +99,66 @@ class RoomDirectoryConfigTestCase(unittest.TestCase):
               action: "allow"
             - room_id: "!test-deny"
               action: "deny"
-        """)
+        """
+        )
 
         rd_config = RoomDirectoryConfig()
         rd_config.read_config(config)
 
-        self.assertFalse(rd_config.is_publishing_room_allowed(
+        self.assertFalse(
-            user_id="@bob:example.com",
+            rd_config.is_publishing_room_allowed(
-            room_id="!test",
+                user_id="@bob:example.com",
-            aliases=["#test:example.com"],
+                room_id="!test",
-        ))
+                aliases=["#test:example.com"],
+            )
+        )
 
-        self.assertTrue(rd_config.is_publishing_room_allowed(
+        self.assertTrue(
-            user_id="@test:example.com",
+            rd_config.is_publishing_room_allowed(
-            room_id="!test",
+                user_id="@test:example.com",
-            aliases=["#unofficial_st:example.com"],
+                room_id="!test",
-        ))
+                aliases=["#unofficial_st:example.com"],
+            )
+        )
 
-        self.assertTrue(rd_config.is_publishing_room_allowed(
+        self.assertTrue(
-            user_id="@foobar:example.com",
+            rd_config.is_publishing_room_allowed(
-            room_id="!test",
+                user_id="@foobar:example.com", room_id="!test", aliases=[]
-            aliases=[],
+            )
-        ))
+        )
 
-        self.assertTrue(rd_config.is_publishing_room_allowed(
+        self.assertTrue(
-            user_id="@gah:example.com",
+            rd_config.is_publishing_room_allowed(
-            room_id="!test",
+                user_id="@gah:example.com",
-            aliases=["#goo:example.com"],
+                room_id="!test",
-        ))
+                aliases=["#goo:example.com"],
+            )
+        )
 
-        self.assertFalse(rd_config.is_publishing_room_allowed(
+        self.assertFalse(
-            user_id="@test:example.com",
+            rd_config.is_publishing_room_allowed(
-            room_id="!test",
+                user_id="@test:example.com",
-            aliases=["#test:example.com"],
+                room_id="!test",
-        ))
+                aliases=["#test:example.com"],
+            )
+        )
 
-        self.assertTrue(rd_config.is_publishing_room_allowed(
+        self.assertTrue(
-            user_id="@foobar:example.com",
+            rd_config.is_publishing_room_allowed(
-            room_id="!test-deny",
+                user_id="@foobar:example.com", room_id="!test-deny", aliases=[]
-            aliases=[],
+            )
-        ))
+        )
 
-        self.assertFalse(rd_config.is_publishing_room_allowed(
+        self.assertFalse(
-            user_id="@gah:example.com",
+            rd_config.is_publishing_room_allowed(
-            room_id="!test-deny",
+                user_id="@gah:example.com", room_id="!test-deny", aliases=[]
-            aliases=[],
+            )
-        ))
+        )
 
-        self.assertTrue(rd_config.is_publishing_room_allowed(
+        self.assertTrue(
-            user_id="@test:example.com",
+            rd_config.is_publishing_room_allowed(
-            room_id="!test",
+                user_id="@test:example.com",
-            aliases=["#unofficial_st:example.com", "#blah:example.com"],
+                room_id="!test",
-        ))
+                aliases=["#unofficial_st:example.com", "#blah:example.com"],
+            )
+        )

tests/config/test_server.py

@@ -19,7 +19,6 @@ from tests import unittest
 
 
 class ServerConfigTestCase(unittest.TestCase):
-
     def test_is_threepid_reserved(self):
         user1 = {'medium': 'email', 'address': 'user1@example.com'}
         user2 = {'medium': 'email', 'address': 'user2@example.com'}

tests/config/test_tls.py

@@ -26,7 +26,6 @@ class TestConfig(TlsConfig):
 
 
 class TLSConfigTests(TestCase):
-
     def test_warn_self_signed(self):
         """
         Synapse will give a warning when it loads a self-signed certificate.
@@ -34,7 +33,8 @@ class TLSConfigTests(TestCase):
         config_dir = self.mktemp()
         os.mkdir(config_dir)
         with open(os.path.join(config_dir, "cert.pem"), 'w') as f:
-            f.write("""-----BEGIN CERTIFICATE-----
+            f.write(
+                """-----BEGIN CERTIFICATE-----
 MIID6DCCAtACAws9CjANBgkqhkiG9w0BAQUFADCBtzELMAkGA1UEBhMCVFIxDzAN
 BgNVBAgMBsOHb3J1bTEUMBIGA1UEBwwLQmHFn21ha8OnxLExEjAQBgNVBAMMCWxv
 Y2FsaG9zdDEcMBoGA1UECgwTVHdpc3RlZCBNYXRyaXggTGFiczEkMCIGA1UECwwb
@@ -56,11 +56,12 @@ I8OtG1xGwcok53lyDuuUUDexnK4O5BkjKiVlNPg4HPim5Kuj2hRNFfNt/F2BVIlj
 iZupikC5MT1LQaRwidkSNxCku1TfAyueiBwhLnFwTmIGNnhuDCutEVAD9kFmcJN2
 SznugAcPk4doX2+rL+ila+ThqgPzIkwTUHtnmjI0TI6xsDUlXz5S3UyudrE2Qsfz
 s4niecZKPBizL6aucT59CsunNmmb5Glq8rlAcU+1ZTZZzGYqVYhF6axB9Qg=
------END CERTIFICATE-----""")
+-----END CERTIFICATE-----"""
+            )
 
         config = {
             "tls_certificate_path": os.path.join(config_dir, "cert.pem"),
-            "tls_fingerprints": []
+            "tls_fingerprints": [],
         }
 
         t = TestConfig()
@@ -75,5 +76,5 @@ s4niecZKPBizL6aucT59CsunNmmb5Glq8rlAcU+1ZTZZzGYqVYhF6axB9Qg=
                 "Self-signed TLS certificates will not be accepted by "
                 "Synapse 1.0. Please either provide a valid certificate, "
                 "or use Synapse's ACME support to provision one."
-            )
+            ),
         )

tests/crypto/test_keyring.py

@@ -169,7 +169,7 @@ class KeyringTestCase(unittest.HomeserverTestCase):
                 self.http_client.post_json.return_value = defer.Deferred()
 
                 res_deferreds_2 = kr.verify_json_objects_for_server(
-                    [("server10", json1, )]
+                    [("server10", json1)]
                 )
                 res_deferreds_2[0].addBoth(self.check_context, None)
                 yield logcontext.make_deferred_yieldable(res_deferreds_2[0])
@@ -345,6 +345,7 @@ def _verify_json_for_server(keyring, server_name, json_object):
     """thin wrapper around verify_json_for_server which makes sure it is wrapped
     with the patched defer.inlineCallbacks.
     """
+
     @defer.inlineCallbacks
     def v():
         rv1 = yield keyring.verify_json_for_server(server_name, json_object)

tests/federation/test_federation_sender.py

@@ -33,11 +33,15 @@ class FederationSenderTestCases(HomeserverTestCase):
         mock_state_handler = self.hs.get_state_handler()
         mock_state_handler.get_current_hosts_in_room.return_value = ["test", "host2"]
 
-        mock_send_transaction = self.hs.get_federation_transport_client().send_transaction
+        mock_send_transaction = (
+            self.hs.get_federation_transport_client().send_transaction
+        )
         mock_send_transaction.return_value = defer.succeed({})
 
         sender = self.hs.get_federation_sender()
-        receipt = ReadReceipt("room_id", "m.read", "user_id", ["event_id"], {"ts": 1234})
+        receipt = ReadReceipt(
+            "room_id", "m.read", "user_id", ["event_id"], {"ts": 1234}
+        )
         self.successResultOf(sender.send_read_receipt(receipt))
 
         self.pump()
@@ -46,21 +50,24 @@ class FederationSenderTestCases(HomeserverTestCase):
         mock_send_transaction.assert_called_once()
         json_cb = mock_send_transaction.call_args[0][1]
         data = json_cb()
-        self.assertEqual(data['edus'], [
+        self.assertEqual(
-            {
+            data['edus'],
-                'edu_type': 'm.receipt',
+            [
-                'content': {
+                {
-                    'room_id': {
+                    'edu_type': 'm.receipt',
-                        'm.read': {
+                    'content': {
-                            'user_id': {
+                        'room_id': {
-                                'event_ids': ['event_id'],
+                            'm.read': {
-                                'data': {'ts': 1234},
+                                'user_id': {
-                            },
+                                    'event_ids': ['event_id'],
-                        },
+                                    'data': {'ts': 1234},
+                                }
+                            }
+                        }
                     },
-                },
+                }
-            },
+            ],
-        ])
+        )
 
     def test_send_receipts_with_backoff(self):
         """Send two receipts in quick succession; the second should be flushed, but
@@ -68,11 +75,15 @@ class FederationSenderTestCases(HomeserverTestCase):
         mock_state_handler = self.hs.get_state_handler()
         mock_state_handler.get_current_hosts_in_room.return_value = ["test", "host2"]
 
-        mock_send_transaction = self.hs.get_federation_transport_client().send_transaction
+        mock_send_transaction = (
+            self.hs.get_federation_transport_client().send_transaction
+        )
         mock_send_transaction.return_value = defer.succeed({})
 
         sender = self.hs.get_federation_sender()
-        receipt = ReadReceipt("room_id", "m.read", "user_id", ["event_id"], {"ts": 1234})
+        receipt = ReadReceipt(
+            "room_id", "m.read", "user_id", ["event_id"], {"ts": 1234}
+        )
         self.successResultOf(sender.send_read_receipt(receipt))
 
         self.pump()
@@ -81,25 +92,30 @@ class FederationSenderTestCases(HomeserverTestCase):
         mock_send_transaction.assert_called_once()
         json_cb = mock_send_transaction.call_args[0][1]
         data = json_cb()
-        self.assertEqual(data['edus'], [
+        self.assertEqual(
-            {
+            data['edus'],
-                'edu_type': 'm.receipt',
+            [
-                'content': {
+                {
-                    'room_id': {
+                    'edu_type': 'm.receipt',
-                        'm.read': {
+                    'content': {
-                            'user_id': {
+                        'room_id': {
-                                'event_ids': ['event_id'],
+                            'm.read': {
-                                'data': {'ts': 1234},
+                                'user_id': {
-                            },
+                                    'event_ids': ['event_id'],
-                        },
+                                    'data': {'ts': 1234},
+                                }
+                            }
+                        }
                     },
-                },
+                }
-            },
+            ],
-        ])
+        )
         mock_send_transaction.reset_mock()
 
         # send the second RR
-        receipt = ReadReceipt("room_id", "m.read", "user_id", ["other_id"], {"ts": 1234})
+        receipt = ReadReceipt(
+            "room_id", "m.read", "user_id", ["other_id"], {"ts": 1234}
+        )
         self.successResultOf(sender.send_read_receipt(receipt))
         self.pump()
         mock_send_transaction.assert_not_called()
@@ -111,18 +127,21 @@ class FederationSenderTestCases(HomeserverTestCase):
         mock_send_transaction.assert_called_once()
         json_cb = mock_send_transaction.call_args[0][1]
         data = json_cb()
-        self.assertEqual(data['edus'], [
+        self.assertEqual(
-            {
+            data['edus'],
-                'edu_type': 'm.receipt',
+            [
-                'content': {
+                {
-                    'room_id': {
+                    'edu_type': 'm.receipt',
-                        'm.read': {
+                    'content': {
-                            'user_id': {
+                        'room_id': {
-                                'event_ids': ['other_id'],
+                            'm.read': {
-                                'data': {'ts': 1234},
+                                'user_id': {
-                            },
+                                    'event_ids': ['other_id'],
-                        },
+                                    'data': {'ts': 1234},
+                                }
+                            }
+                        }
                     },
-                },
+                }
-            },
+            ],
-        ])
+        )

tests/handlers/test_directory.py

@@ -115,11 +115,7 @@ class TestCreateAliasACL(unittest.HomeserverTestCase):
         # We cheekily override the config to add custom alias creation rules
         config = {}
         config["alias_creation_rules"] = [
-            {
+            {"user_id": "*", "alias": "#unofficial_*", "action": "allow"}
-                "user_id": "*",
-                "alias": "#unofficial_*",
-                "action": "allow",
-            }
         ]
         config["room_list_publication_rules"] = []
 
@@ -162,9 +158,7 @@ class TestRoomListSearchDisabled(unittest.HomeserverTestCase):
         room_id = self.helper.create_room_as(self.user_id)
 
         request, channel = self.make_request(
-            "PUT",
+            "PUT", b"directory/list/room/%s" % (room_id.encode('ascii'),), b'{}'
-            b"directory/list/room/%s" % (room_id.encode('ascii'),),
-            b'{}',
         )
         self.render(request)
         self.assertEquals(200, channel.code, channel.result)
@@ -179,10 +173,7 @@ class TestRoomListSearchDisabled(unittest.HomeserverTestCase):
         self.directory_handler.enable_room_list_search = True
 
         # Room list is enabled so we should get some results
-        request, channel = self.make_request(
+        request, channel = self.make_request("GET", b"publicRooms")
-            "GET",
-            b"publicRooms",
-        )
         self.render(request)
         self.assertEquals(200, channel.code, channel.result)
         self.assertTrue(len(channel.json_body["chunk"]) > 0)
@@ -191,10 +182,7 @@ class TestRoomListSearchDisabled(unittest.HomeserverTestCase):
         self.directory_handler.enable_room_list_search = False
 
         # Room list disabled so we should get no results
-        request, channel = self.make_request(
+        request, channel = self.make_request("GET", b"publicRooms")
-            "GET",
-            b"publicRooms",
-        )
         self.render(request)
         self.assertEquals(200, channel.code, channel.result)
         self.assertTrue(len(channel.json_body["chunk"]) == 0)
@@ -202,9 +190,7 @@ class TestRoomListSearchDisabled(unittest.HomeserverTestCase):
         # Room list disabled so we shouldn't be allowed to publish rooms
         room_id = self.helper.create_room_as(self.user_id)
         request, channel = self.make_request(
-            "PUT",
+            "PUT", b"directory/list/room/%s" % (room_id.encode('ascii'),), b'{}'
-            b"directory/list/room/%s" % (room_id.encode('ascii'),),
-            b'{}',
         )
         self.render(request)
         self.assertEquals(403, channel.code, channel.result)

tests/handlers/test_e2e_room_keys.py

@@ -36,7 +36,7 @@ room_keys = {
                     "first_message_index": 1,
                     "forwarded_count": 1,
                     "is_verified": False,
-                    "session_data": "SSBBTSBBIEZJU0gK"
+                    "session_data": "SSBBTSBBIEZJU0gK",
                 }
             }
         }
@@ -47,15 +47,13 @@ room_keys = {
 class E2eRoomKeysHandlerTestCase(unittest.TestCase):
     def __init__(self, *args, **kwargs):
         super(E2eRoomKeysHandlerTestCase, self).__init__(*args, **kwargs)
-        self.hs = None       # type: synapse.server.HomeServer
+        self.hs = None  # type: synapse.server.HomeServer
         self.handler = None  # type: synapse.handlers.e2e_keys.E2eRoomKeysHandler
 
     @defer.inlineCallbacks
     def setUp(self):
         self.hs = yield utils.setup_test_homeserver(
-            self.addCleanup,
+            self.addCleanup, handlers=None, replication_layer=mock.Mock()
-            handlers=None,
-            replication_layer=mock.Mock(),
         )
         self.handler = synapse.handlers.e2e_room_keys.E2eRoomKeysHandler(self.hs)
         self.local_user = "@boris:" + self.hs.hostname
@@ -88,67 +86,86 @@ class E2eRoomKeysHandlerTestCase(unittest.TestCase):
     def test_create_version(self):
         """Check that we can create and then retrieve versions.
         """
-        res = yield self.handler.create_version(self.local_user, {
+        res = yield self.handler.create_version(
-            "algorithm": "m.megolm_backup.v1",
+            self.local_user,
-            "auth_data": "first_version_auth_data",
+            {"algorithm": "m.megolm_backup.v1", "auth_data": "first_version_auth_data"},
-        })
+        )
         self.assertEqual(res, "1")
 
         # check we can retrieve it as the current version
         res = yield self.handler.get_version_info(self.local_user)
-        self.assertDictEqual(res, {
+        self.assertDictEqual(
-            "version": "1",
+            res,
-            "algorithm": "m.megolm_backup.v1",
+            {
-            "auth_data": "first_version_auth_data",
+                "version": "1",
-        })
+                "algorithm": "m.megolm_backup.v1",
+                "auth_data": "first_version_auth_data",
+            },
+        )
 
         # check we can retrieve it as a specific version
         res = yield self.handler.get_version_info(self.local_user, "1")
-        self.assertDictEqual(res, {
+        self.assertDictEqual(
-            "version": "1",
+            res,
-            "algorithm": "m.megolm_backup.v1",
+            {
-            "auth_data": "first_version_auth_data",
+                "version": "1",
-        })
+                "algorithm": "m.megolm_backup.v1",
+                "auth_data": "first_version_auth_data",
+            },
+        )
 
         # upload a new one...
-        res = yield self.handler.create_version(self.local_user, {
+        res = yield self.handler.create_version(
-            "algorithm": "m.megolm_backup.v1",
+            self.local_user,
-            "auth_data": "second_version_auth_data",
+            {
-        })
+                "algorithm": "m.megolm_backup.v1",
+                "auth_data": "second_version_auth_data",
+            },
+        )
         self.assertEqual(res, "2")
 
         # check we can retrieve it as the current version
         res = yield self.handler.get_version_info(self.local_user)
-        self.assertDictEqual(res, {
+        self.assertDictEqual(
-            "version": "2",
+            res,
-            "algorithm": "m.megolm_backup.v1",
+            {
-            "auth_data": "second_version_auth_data",
+                "version": "2",
-        })
+                "algorithm": "m.megolm_backup.v1",
+                "auth_data": "second_version_auth_data",
+            },
+        )
 
     @defer.inlineCallbacks
     def test_update_version(self):
         """Check that we can update versions.
         """
-        version = yield self.handler.create_version(self.local_user, {
+        version = yield self.handler.create_version(
-            "algorithm": "m.megolm_backup.v1",
+            self.local_user,
-            "auth_data": "first_version_auth_data",
+            {"algorithm": "m.megolm_backup.v1", "auth_data": "first_version_auth_data"},
-        })
+        )
         self.assertEqual(version, "1")
 
-        res = yield self.handler.update_version(self.local_user, version, {
+        res = yield self.handler.update_version(
-            "algorithm": "m.megolm_backup.v1",
+            self.local_user,
-            "auth_data": "revised_first_version_auth_data",
+            version,
-            "version": version
+            {
-        })
+                "algorithm": "m.megolm_backup.v1",
+                "auth_data": "revised_first_version_auth_data",
+                "version": version,
+            },
+        )
         self.assertDictEqual(res, {})
 
         # check we can retrieve it as the current version
         res = yield self.handler.get_version_info(self.local_user)
-        self.assertDictEqual(res, {
+        self.assertDictEqual(
-            "algorithm": "m.megolm_backup.v1",
+            res,
-            "auth_data": "revised_first_version_auth_data",
+            {
-            "version": version
+                "algorithm": "m.megolm_backup.v1",
-        })
+                "auth_data": "revised_first_version_auth_data",
+                "version": version,
+            },
+        )
 
     @defer.inlineCallbacks
     def test_update_missing_version(self):
@@ -156,11 +173,15 @@ class E2eRoomKeysHandlerTestCase(unittest.TestCase):
         """
         res = None
         try:
-            yield self.handler.update_version(self.local_user, "1", {
+            yield self.handler.update_version(
-                "algorithm": "m.megolm_backup.v1",
+                self.local_user,
-                "auth_data": "revised_first_version_auth_data",
+                "1",
-                "version": "1"
+                {
-            })
+                    "algorithm": "m.megolm_backup.v1",
+                    "auth_data": "revised_first_version_auth_data",
+                    "version": "1",
+                },
+            )
         except errors.SynapseError as e:
             res = e.code
         self.assertEqual(res, 404)
@@ -170,29 +191,37 @@ class E2eRoomKeysHandlerTestCase(unittest.TestCase):
         """Check that we get a 400 if the version in the body is missing or
         doesn't match
         """
-        version = yield self.handler.create_version(self.local_user, {
+        version = yield self.handler.create_version(
-            "algorithm": "m.megolm_backup.v1",
+            self.local_user,
-            "auth_data": "first_version_auth_data",
+            {"algorithm": "m.megolm_backup.v1", "auth_data": "first_version_auth_data"},
-        })
+        )
         self.assertEqual(version, "1")
 
         res = None
         try:
-            yield self.handler.update_version(self.local_user, version, {
+            yield self.handler.update_version(
-                "algorithm": "m.megolm_backup.v1",
+                self.local_user,
-                "auth_data": "revised_first_version_auth_data"
+                version,
-            })
+                {
+                    "algorithm": "m.megolm_backup.v1",
+                    "auth_data": "revised_first_version_auth_data",
+                },
+            )
         except errors.SynapseError as e:
             res = e.code
         self.assertEqual(res, 400)
 
         res = None
         try:
-            yield self.handler.update_version(self.local_user, version, {
+            yield self.handler.update_version(
-                "algorithm": "m.megolm_backup.v1",
+                self.local_user,
-                "auth_data": "revised_first_version_auth_data",
+                version,
-                "version": "incorrect"
+                {
-            })
+                    "algorithm": "m.megolm_backup.v1",
+                    "auth_data": "revised_first_version_auth_data",
+                    "version": "incorrect",
+                },
+            )
         except errors.SynapseError as e:
             res = e.code
         self.assertEqual(res, 400)
@@ -223,10 +252,10 @@ class E2eRoomKeysHandlerTestCase(unittest.TestCase):
     def test_delete_version(self):
         """Check that we can create and then delete versions.
         """
-        res = yield self.handler.create_version(self.local_user, {
+        res = yield self.handler.create_version(
-            "algorithm": "m.megolm_backup.v1",
+            self.local_user,
-            "auth_data": "first_version_auth_data",
+            {"algorithm": "m.megolm_backup.v1", "auth_data": "first_version_auth_data"},
-        })
+        )
         self.assertEqual(res, "1")
 
         # check we can delete it
@@ -255,16 +284,14 @@ class E2eRoomKeysHandlerTestCase(unittest.TestCase):
     def test_get_missing_room_keys(self):
         """Check we get an empty response from an empty backup
         """
-        version = yield self.handler.create_version(self.local_user, {
+        version = yield self.handler.create_version(
-            "algorithm": "m.megolm_backup.v1",
+            self.local_user,
-            "auth_data": "first_version_auth_data",
+            {"algorithm": "m.megolm_backup.v1", "auth_data": "first_version_auth_data"},
-        })
+        )
         self.assertEqual(version, "1")
 
         res = yield self.handler.get_room_keys(self.local_user, version)
-        self.assertDictEqual(res, {
+        self.assertDictEqual(res, {"rooms": {}})
-            "rooms": {}
-        })
 
     # TODO: test the locking semantics when uploading room_keys,
     # although this is probably best done in sytest
@@ -275,7 +302,9 @@ class E2eRoomKeysHandlerTestCase(unittest.TestCase):
         """
         res = None
         try:
-            yield self.handler.upload_room_keys(self.local_user, "no_version", room_keys)
+            yield self.handler.upload_room_keys(
+                self.local_user, "no_version", room_keys
+            )
         except errors.SynapseError as e:
             res = e.code
         self.assertEqual(res, 404)
@@ -285,10 +314,10 @@ class E2eRoomKeysHandlerTestCase(unittest.TestCase):
         """Check that we get a 404 on uploading keys when an nonexistent version
         is specified
         """
-        version = yield self.handler.create_version(self.local_user, {
+        version = yield self.handler.create_version(
-            "algorithm": "m.megolm_backup.v1",
+            self.local_user,
-            "auth_data": "first_version_auth_data",
+            {"algorithm": "m.megolm_backup.v1", "auth_data": "first_version_auth_data"},
-        })
+        )
         self.assertEqual(version, "1")
 
         res = None
@@ -304,16 +333,19 @@ class E2eRoomKeysHandlerTestCase(unittest.TestCase):
     def test_upload_room_keys_wrong_version(self):
         """Check that we get a 403 on uploading keys for an old version
         """
-        version = yield self.handler.create_version(self.local_user, {
+        version = yield self.handler.create_version(
-            "algorithm": "m.megolm_backup.v1",
+            self.local_user,
-            "auth_data": "first_version_auth_data",
+            {"algorithm": "m.megolm_backup.v1", "auth_data": "first_version_auth_data"},
-        })
+        )
         self.assertEqual(version, "1")
 
-        version = yield self.handler.create_version(self.local_user, {
+        version = yield self.handler.create_version(
-            "algorithm": "m.megolm_backup.v1",
+            self.local_user,
-            "auth_data": "second_version_auth_data",
+            {
-        })
+                "algorithm": "m.megolm_backup.v1",
+                "auth_data": "second_version_auth_data",
+            },
+        )
         self.assertEqual(version, "2")
 
         res = None
@@ -327,10 +359,10 @@ class E2eRoomKeysHandlerTestCase(unittest.TestCase):
     def test_upload_room_keys_insert(self):
         """Check that we can insert and retrieve keys for a session
         """
-        version = yield self.handler.create_version(self.local_user, {
+        version = yield self.handler.create_version(
-            "algorithm": "m.megolm_backup.v1",
+            self.local_user,
-            "auth_data": "first_version_auth_data",
+            {"algorithm": "m.megolm_backup.v1", "auth_data": "first_version_auth_data"},
-        })
+        )
         self.assertEqual(version, "1")
 
         yield self.handler.upload_room_keys(self.local_user, version, room_keys)
@@ -340,18 +372,13 @@ class E2eRoomKeysHandlerTestCase(unittest.TestCase):
 
         # check getting room_keys for a given room
         res = yield self.handler.get_room_keys(
-            self.local_user,
+            self.local_user, version, room_id="!abc:matrix.org"
-            version,
-            room_id="!abc:matrix.org"
         )
         self.assertDictEqual(res, room_keys)
 
         # check getting room_keys for a given session_id
         res = yield self.handler.get_room_keys(
-            self.local_user,
+            self.local_user, version, room_id="!abc:matrix.org", session_id="c0ff33"
-            version,
-            room_id="!abc:matrix.org",
-            session_id="c0ff33",
         )
         self.assertDictEqual(res, room_keys)
 
@@ -359,10 +386,10 @@ class E2eRoomKeysHandlerTestCase(unittest.TestCase):
     def test_upload_room_keys_merge(self):
         """Check that we can upload a new room_key for an existing session and
         have it correctly merged"""
-        version = yield self.handler.create_version(self.local_user, {
+        version = yield self.handler.create_version(
-            "algorithm": "m.megolm_backup.v1",
+            self.local_user,
-            "auth_data": "first_version_auth_data",
+            {"algorithm": "m.megolm_backup.v1", "auth_data": "first_version_auth_data"},
-        })
+        )
         self.assertEqual(version, "1")
 
         yield self.handler.upload_room_keys(self.local_user, version, room_keys)
@@ -378,7 +405,7 @@ class E2eRoomKeysHandlerTestCase(unittest.TestCase):
         res = yield self.handler.get_room_keys(self.local_user, version)
         self.assertEqual(
             res['rooms']['!abc:matrix.org']['sessions']['c0ff33']['session_data'],
-            "SSBBTSBBIEZJU0gK"
+            "SSBBTSBBIEZJU0gK",
         )
 
         # test that marking the session as verified however /does/ replace it
@@ -387,8 +414,7 @@ class E2eRoomKeysHandlerTestCase(unittest.TestCase):
 
         res = yield self.handler.get_room_keys(self.local_user, version)
         self.assertEqual(
-            res['rooms']['!abc:matrix.org']['sessions']['c0ff33']['session_data'],
+            res['rooms']['!abc:matrix.org']['sessions']['c0ff33']['session_data'], "new"
-            "new"
         )
 
         # test that a session with a higher forwarded_count doesn't replace one
@@ -399,8 +425,7 @@ class E2eRoomKeysHandlerTestCase(unittest.TestCase):
 
         res = yield self.handler.get_room_keys(self.local_user, version)
         self.assertEqual(
-            res['rooms']['!abc:matrix.org']['sessions']['c0ff33']['session_data'],
+            res['rooms']['!abc:matrix.org']['sessions']['c0ff33']['session_data'], "new"
-            "new"
         )
 
         # TODO: check edge cases as well as the common variations here
@@ -409,56 +434,36 @@ class E2eRoomKeysHandlerTestCase(unittest.TestCase):
     def test_delete_room_keys(self):
         """Check that we can insert and delete keys for a session
         """
-        version = yield self.handler.create_version(self.local_user, {
+        version = yield self.handler.create_version(
-            "algorithm": "m.megolm_backup.v1",
+            self.local_user,
-            "auth_data": "first_version_auth_data",
+            {"algorithm": "m.megolm_backup.v1", "auth_data": "first_version_auth_data"},
-        })
+        )
         self.assertEqual(version, "1")
 
         # check for bulk-delete
         yield self.handler.upload_room_keys(self.local_user, version, room_keys)
         yield self.handler.delete_room_keys(self.local_user, version)
         res = yield self.handler.get_room_keys(
-            self.local_user,
+            self.local_user, version, room_id="!abc:matrix.org", session_id="c0ff33"
-            version,
-            room_id="!abc:matrix.org",
-            session_id="c0ff33",
         )
-        self.assertDictEqual(res, {
+        self.assertDictEqual(res, {"rooms": {}})
-            "rooms": {}
-        })
 
         # check for bulk-delete per room
         yield self.handler.upload_room_keys(self.local_user, version, room_keys)
         yield self.handler.delete_room_keys(
-            self.local_user,
+            self.local_user, version, room_id="!abc:matrix.org"
-            version,
-            room_id="!abc:matrix.org",
         )
         res = yield self.handler.get_room_keys(
-            self.local_user,
+            self.local_user, version, room_id="!abc:matrix.org", session_id="c0ff33"
-            version,
-            room_id="!abc:matrix.org",
-            session_id="c0ff33",
         )
-        self.assertDictEqual(res, {
+        self.assertDictEqual(res, {"rooms": {}})
-            "rooms": {}
-        })
 
         # check for bulk-delete per session
         yield self.handler.upload_room_keys(self.local_user, version, room_keys)
         yield self.handler.delete_room_keys(
-            self.local_user,
+            self.local_user, version, room_id="!abc:matrix.org", session_id="c0ff33"
-            version,
-            room_id="!abc:matrix.org",
-            session_id="c0ff33",
         )
         res = yield self.handler.get_room_keys(
-            self.local_user,
+            self.local_user, version, room_id="!abc:matrix.org", session_id="c0ff33"
-            version,
-            room_id="!abc:matrix.org",
-            session_id="c0ff33",
         )
-        self.assertDictEqual(res, {
+        self.assertDictEqual(res, {"rooms": {}})
-            "rooms": {}
-        })

tests/handlers/test_presence.py

@@ -424,8 +424,7 @@ class PresenceJoinTestCase(unittest.HomeserverTestCase):
 
     def make_homeserver(self, reactor, clock):
         hs = self.setup_test_homeserver(
-            "server", http_client=None,
+            "server", http_client=None, federation_sender=Mock()
-            federation_sender=Mock(),
         )
         return hs
 
@@ -457,7 +456,7 @@ class PresenceJoinTestCase(unittest.HomeserverTestCase):
 
         # Mark test2 as online, test will be offline with a last_active of 0
         self.presence_handler.set_state(
-            UserID.from_string("@test2:server"), {"presence": PresenceState.ONLINE},
+            UserID.from_string("@test2:server"), {"presence": PresenceState.ONLINE}
         )
         self.reactor.pump([0])  # Wait for presence updates to be handled
 
@@ -506,13 +505,13 @@ class PresenceJoinTestCase(unittest.HomeserverTestCase):
 
         # Mark test as online
         self.presence_handler.set_state(
-            UserID.from_string("@test:server"), {"presence": PresenceState.ONLINE},
+            UserID.from_string("@test:server"), {"presence": PresenceState.ONLINE}
         )
 
         # Mark test2 as online, test will be offline with a last_active of 0.
         # Note we don't join them to the room yet
         self.presence_handler.set_state(
-            UserID.from_string("@test2:server"), {"presence": PresenceState.ONLINE},
+            UserID.from_string("@test2:server"), {"presence": PresenceState.ONLINE}
         )
 
         # Add servers to the room
@@ -541,8 +540,7 @@ class PresenceJoinTestCase(unittest.HomeserverTestCase):
         )
         self.assertEqual(expected_state.state, PresenceState.ONLINE)
         self.federation_sender.send_presence_to_destinations.assert_called_once_with(
-            destinations=set(("server2", "server3")),
+            destinations=set(("server2", "server3")), states=[expected_state]
-            states=[expected_state]
         )
 
     def _add_new_user(self, room_id, user_id):
@@ -565,7 +563,7 @@ class PresenceJoinTestCase(unittest.HomeserverTestCase):
             type=EventTypes.Member,
             sender=user_id,
             state_key=user_id,
-            content={"membership": Membership.JOIN}
+            content={"membership": Membership.JOIN},
         )
 
         prev_event_ids = self.get_success(

tests/handlers/test_typing.py

@@ -64,20 +64,22 @@ class TypingNotificationsTestCase(unittest.HomeserverTestCase):
         mock_federation_client.put_json.return_value = defer.succeed((200, "OK"))
 
         hs = self.setup_test_homeserver(
-            datastore=(Mock(
+            datastore=(
-                spec=[
+                Mock(
-                    # Bits that Federation needs
+                    spec=[
-                    "prep_send_transaction",
+                        # Bits that Federation needs
-                    "delivered_txn",
+                        "prep_send_transaction",
-                    "get_received_txn_response",
+                        "delivered_txn",
-                    "set_received_txn_response",
+                        "get_received_txn_response",
-                    "get_destination_retry_timings",
+                        "set_received_txn_response",
-                    "get_devices_by_remote",
+                        "get_destination_retry_timings",
-                    # Bits that user_directory needs
+                        "get_devices_by_remote",
-                    "get_user_directory_stream_pos",
+                        # Bits that user_directory needs
-                    "get_current_state_deltas",
+                        "get_user_directory_stream_pos",
-                ]
+                        "get_current_state_deltas",
-            )),
+                    ]
+                )
+            ),
             notifier=Mock(),
             http_client=mock_federation_client,
             keyring=mock_keyring,
@@ -87,7 +89,7 @@ class TypingNotificationsTestCase(unittest.HomeserverTestCase):
 
     def prepare(self, reactor, clock, hs):
         # the tests assume that we are starting at unix time 1000
-        reactor.pump((1000, ))
+        reactor.pump((1000,))
 
         mock_notifier = hs.get_notifier()
         self.on_new_event = mock_notifier.on_new_event
@@ -114,6 +116,7 @@ class TypingNotificationsTestCase(unittest.HomeserverTestCase):
         def check_joined_room(room_id, user_id):
             if user_id not in [u.to_string() for u in self.room_members]:
                 raise AuthError(401, "User is not in the room")
+
         hs.get_auth().check_joined_room = check_joined_room
 
         def get_joined_hosts_for_room(room_id):
@@ -123,6 +126,7 @@ class TypingNotificationsTestCase(unittest.HomeserverTestCase):
 
         def get_current_users_in_room(room_id):
             return set(str(u) for u in self.room_members)
+
         hs.get_state_handler().get_current_users_in_room = get_current_users_in_room
 
         self.datastore.get_user_directory_stream_pos.return_value = (
@@ -141,21 +145,16 @@ class TypingNotificationsTestCase(unittest.HomeserverTestCase):
 
         self.assertEquals(self.event_source.get_current_key(), 0)
 
-        self.successResultOf(self.handler.started_typing(
+        self.successResultOf(
-            target_user=U_APPLE,
+            self.handler.started_typing(
-            auth_user=U_APPLE,
+                target_user=U_APPLE, auth_user=U_APPLE, room_id=ROOM_ID, timeout=20000
-            room_id=ROOM_ID,
+            )
-            timeout=20000,
-        ))
-
-        self.on_new_event.assert_has_calls(
-            [call('typing_key', 1, rooms=[ROOM_ID])]
         )
 
+        self.on_new_event.assert_has_calls([call('typing_key', 1, rooms=[ROOM_ID])])
+
         self.assertEquals(self.event_source.get_current_key(), 1)
-        events = self.event_source.get_new_events(
+        events = self.event_source.get_new_events(room_ids=[ROOM_ID], from_key=0)
-            room_ids=[ROOM_ID], from_key=0
-        )
         self.assertEquals(
             events[0],
             [
@@ -170,12 +169,11 @@ class TypingNotificationsTestCase(unittest.HomeserverTestCase):
     def test_started_typing_remote_send(self):
         self.room_members = [U_APPLE, U_ONION]
 
-        self.successResultOf(self.handler.started_typing(
+        self.successResultOf(
-            target_user=U_APPLE,
+            self.handler.started_typing(
-            auth_user=U_APPLE,
+                target_user=U_APPLE, auth_user=U_APPLE, room_id=ROOM_ID, timeout=20000
-            room_id=ROOM_ID,
+            )
-            timeout=20000,
+        )
-        ))
 
         put_json = self.hs.get_http_client().put_json
         put_json.assert_called_once_with(
@@ -216,14 +214,10 @@ class TypingNotificationsTestCase(unittest.HomeserverTestCase):
         self.render(request)
         self.assertEqual(channel.code, 200)
 
-        self.on_new_event.assert_has_calls(
+        self.on_new_event.assert_has_calls([call('typing_key', 1, rooms=[ROOM_ID])])
-            [call('typing_key', 1, rooms=[ROOM_ID])]
-        )
 
         self.assertEquals(self.event_source.get_current_key(), 1)
-        events = self.event_source.get_new_events(
+        events = self.event_source.get_new_events(room_ids=[ROOM_ID], from_key=0)
-            room_ids=[ROOM_ID], from_key=0
-        )
         self.assertEquals(
             events[0],
             [
@@ -247,14 +241,14 @@ class TypingNotificationsTestCase(unittest.HomeserverTestCase):
 
         self.assertEquals(self.event_source.get_current_key(), 0)
 
-        self.successResultOf(self.handler.stopped_typing(
+        self.successResultOf(
-            target_user=U_APPLE, auth_user=U_APPLE, room_id=ROOM_ID
+            self.handler.stopped_typing(
-        ))
+                target_user=U_APPLE, auth_user=U_APPLE, room_id=ROOM_ID
-
+            )
-        self.on_new_event.assert_has_calls(
-            [call('typing_key', 1, rooms=[ROOM_ID])]
         )
 
+        self.on_new_event.assert_has_calls([call('typing_key', 1, rooms=[ROOM_ID])])
+
         put_json = self.hs.get_http_client().put_json
         put_json.assert_called_once_with(
             "farm",
@@ -274,18 +268,10 @@ class TypingNotificationsTestCase(unittest.HomeserverTestCase):
         )
 
         self.assertEquals(self.event_source.get_current_key(), 1)
-        events = self.event_source.get_new_events(
+        events = self.event_source.get_new_events(room_ids=[ROOM_ID], from_key=0)
-            room_ids=[ROOM_ID], from_key=0
-        )
         self.assertEquals(
             events[0],
-            [
+            [{"type": "m.typing", "room_id": ROOM_ID, "content": {"user_ids": []}}],
-                {
-                    "type": "m.typing",
-                    "room_id": ROOM_ID,
-                    "content": {"user_ids": []},
-                }
-            ],
         )
 
     def test_typing_timeout(self):
@@ -293,22 +279,17 @@ class TypingNotificationsTestCase(unittest.HomeserverTestCase):
 
         self.assertEquals(self.event_source.get_current_key(), 0)
 
-        self.successResultOf(self.handler.started_typing(
+        self.successResultOf(
-            target_user=U_APPLE,
+            self.handler.started_typing(
-            auth_user=U_APPLE,
+                target_user=U_APPLE, auth_user=U_APPLE, room_id=ROOM_ID, timeout=10000
-            room_id=ROOM_ID,
+            )
-            timeout=10000,
-        ))
-
-        self.on_new_event.assert_has_calls(
-            [call('typing_key', 1, rooms=[ROOM_ID])]
         )
+
+        self.on_new_event.assert_has_calls([call('typing_key', 1, rooms=[ROOM_ID])])
         self.on_new_event.reset_mock()
 
         self.assertEquals(self.event_source.get_current_key(), 1)
-        events = self.event_source.get_new_events(
+        events = self.event_source.get_new_events(room_ids=[ROOM_ID], from_key=0)
-            room_ids=[ROOM_ID], from_key=0
-        )
         self.assertEquals(
             events[0],
             [
@@ -320,45 +301,30 @@ class TypingNotificationsTestCase(unittest.HomeserverTestCase):
             ],
         )
 
-        self.reactor.pump([16, ])
+        self.reactor.pump([16])
 
-        self.on_new_event.assert_has_calls(
+        self.on_new_event.assert_has_calls([call('typing_key', 2, rooms=[ROOM_ID])])
-            [call('typing_key', 2, rooms=[ROOM_ID])]
-        )
 
         self.assertEquals(self.event_source.get_current_key(), 2)
-        events = self.event_source.get_new_events(
+        events = self.event_source.get_new_events(room_ids=[ROOM_ID], from_key=1)
-            room_ids=[ROOM_ID], from_key=1
-        )
         self.assertEquals(
             events[0],
-            [
+            [{"type": "m.typing", "room_id": ROOM_ID, "content": {"user_ids": []}}],
-                {
-                    "type": "m.typing",
-                    "room_id": ROOM_ID,
-                    "content": {"user_ids": []},
-                }
-            ],
         )
 
         # SYN-230 - see if we can still set after timeout
 
-        self.successResultOf(self.handler.started_typing(
+        self.successResultOf(
-            target_user=U_APPLE,
+            self.handler.started_typing(
-            auth_user=U_APPLE,
+                target_user=U_APPLE, auth_user=U_APPLE, room_id=ROOM_ID, timeout=10000
-            room_id=ROOM_ID,
+            )
-            timeout=10000,
-        ))
-
-        self.on_new_event.assert_has_calls(
-            [call('typing_key', 3, rooms=[ROOM_ID])]
         )
+
+        self.on_new_event.assert_has_calls([call('typing_key', 3, rooms=[ROOM_ID])])
         self.on_new_event.reset_mock()
 
         self.assertEquals(self.event_source.get_current_key(), 3)
-        events = self.event_source.get_new_events(
+        events = self.event_source.get_new_events(room_ids=[ROOM_ID], from_key=0)
-            room_ids=[ROOM_ID], from_key=0
-        )
         self.assertEquals(
             events[0],
             [

tests/handlers/test_user_directory.py

@@ -352,9 +352,7 @@ class TestUserDirSearchDisabled(unittest.HomeserverTestCase):
 
         # Assert user directory is not empty
         request, channel = self.make_request(
-            "POST",
+            "POST", b"user_directory/search", b'{"search_term":"user2"}'
-            b"user_directory/search",
-            b'{"search_term":"user2"}',
         )
         self.render(request)
         self.assertEquals(200, channel.code, channel.result)
@@ -363,9 +361,7 @@ class TestUserDirSearchDisabled(unittest.HomeserverTestCase):
         # Disable user directory and check search returns nothing
         self.config.user_directory_search_enabled = False
         request, channel = self.make_request(
-            "POST",
+            "POST", b"user_directory/search", b'{"search_term":"user2"}'
-            b"user_directory/search",
-            b'{"search_term":"user2"}',
         )
         self.render(request)
         self.assertEquals(200, channel.code, channel.result)

tests/http/__init__.py

@@ -24,14 +24,12 @@ def get_test_cert_file():
     #
     # openssl req -x509 -newkey rsa:4096 -keyout server.pem  -out server.pem -days 36500 \
     #     -nodes -subj '/CN=testserv'
-    return os.path.join(
+    return os.path.join(os.path.dirname(__file__), 'server.pem')
-        os.path.dirname(__file__),
-        'server.pem',
-    )
 
 
 class ServerTLSContext(object):
     """A TLS Context which presents our test cert."""
+
     def __init__(self):
         self.filename = get_test_cert_file()
 

tests/http/federation/test_matrix_federation_agent.py

@@ -79,12 +79,12 @@ class MatrixFederationAgentTests(TestCase):
         # stubbing that out here.
         client_protocol = client_factory.buildProtocol(None)
         client_protocol.makeConnection(
-            FakeTransport(server_tls_protocol, self.reactor, client_protocol),
+            FakeTransport(server_tls_protocol, self.reactor, client_protocol)
         )
 
         # tell the server tls protocol to send its stuff back to the client, too
         server_tls_protocol.makeConnection(
-            FakeTransport(client_protocol, self.reactor, server_tls_protocol),
+            FakeTransport(client_protocol, self.reactor, server_tls_protocol)
         )
 
         # give the reactor a pump to get the TLS juices flowing.
@@ -125,7 +125,7 @@ class MatrixFederationAgentTests(TestCase):
                 _check_logcontext(context)
 
     def _handle_well_known_connection(
-        self, client_factory, expected_sni, content, response_headers={},
+        self, client_factory, expected_sni, content, response_headers={}
     ):
         """Handle an outgoing HTTPs connection: wire it up to a server, check that the
         request is for a .well-known, and send the response.
@@ -139,8 +139,7 @@ class MatrixFederationAgentTests(TestCase):
         """
         # make the connection for .well-known
         well_known_server = self._make_connection(
-            client_factory,
+            client_factory, expected_sni=expected_sni
-            expected_sni=expected_sni,
         )
         # check the .well-known request and send a response
         self.assertEqual(len(well_known_server.requests), 1)
@@ -154,17 +153,14 @@ class MatrixFederationAgentTests(TestCase):
         """
         self.assertEqual(request.method, b'GET')
         self.assertEqual(request.path, b'/.well-known/matrix/server')
-        self.assertEqual(
+        self.assertEqual(request.requestHeaders.getRawHeaders(b'host'), [b'testserv'])
-            request.requestHeaders.getRawHeaders(b'host'),
-            [b'testserv'],
-        )
         # send back a response
         for k, v in headers.items():
             request.setHeader(k, v)
         request.write(content)
         request.finish()
 
-        self.reactor.pump((0.1, ))
+        self.reactor.pump((0.1,))
 
     def test_get(self):
         """
@@ -184,18 +180,14 @@ class MatrixFederationAgentTests(TestCase):
         self.assertEqual(port, 8448)
 
         # make a test server, and wire up the client
-        http_server = self._make_connection(
+        http_server = self._make_connection(client_factory, expected_sni=b"testserv")
-            client_factory,
-            expected_sni=b"testserv",
-        )
 
         self.assertEqual(len(http_server.requests), 1)
         request = http_server.requests[0]
         self.assertEqual(request.method, b'GET')
         self.assertEqual(request.path, b'/foo/bar')
         self.assertEqual(
-            request.requestHeaders.getRawHeaders(b'host'),
+            request.requestHeaders.getRawHeaders(b'host'), [b'testserv:8448']
-            [b'testserv:8448']
         )
         content = request.content.read()
         self.assertEqual(content, b'')
@@ -244,19 +236,13 @@ class MatrixFederationAgentTests(TestCase):
         self.assertEqual(port, 8448)
 
         # make a test server, and wire up the client
-        http_server = self._make_connection(
+        http_server = self._make_connection(client_factory, expected_sni=None)
-            client_factory,
-            expected_sni=None,
-        )
 
         self.assertEqual(len(http_server.requests), 1)
         request = http_server.requests[0]
         self.assertEqual(request.method, b'GET')
         self.assertEqual(request.path, b'/foo/bar')
-        self.assertEqual(
+        self.assertEqual(request.requestHeaders.getRawHeaders(b'host'), [b'1.2.3.4'])
-            request.requestHeaders.getRawHeaders(b'host'),
-            [b'1.2.3.4'],
-        )
 
         # finish the request
         request.finish()
@@ -285,19 +271,13 @@ class MatrixFederationAgentTests(TestCase):
         self.assertEqual(port, 8448)
 
         # make a test server, and wire up the client
-        http_server = self._make_connection(
+        http_server = self._make_connection(client_factory, expected_sni=None)
-            client_factory,
-            expected_sni=None,
-        )
 
         self.assertEqual(len(http_server.requests), 1)
         request = http_server.requests[0]
         self.assertEqual(request.method, b'GET')
         self.assertEqual(request.path, b'/foo/bar')
-        self.assertEqual(
+        self.assertEqual(request.requestHeaders.getRawHeaders(b'host'), [b'[::1]'])
-            request.requestHeaders.getRawHeaders(b'host'),
-            [b'[::1]'],
-        )
 
         # finish the request
         request.finish()
@@ -326,19 +306,13 @@ class MatrixFederationAgentTests(TestCase):
         self.assertEqual(port, 80)
 
         # make a test server, and wire up the client
-        http_server = self._make_connection(
+        http_server = self._make_connection(client_factory, expected_sni=None)
-            client_factory,
-            expected_sni=None,
-        )
 
         self.assertEqual(len(http_server.requests), 1)
         request = http_server.requests[0]
         self.assertEqual(request.method, b'GET')
         self.assertEqual(request.path, b'/foo/bar')
-        self.assertEqual(
+        self.assertEqual(request.requestHeaders.getRawHeaders(b'host'), [b'[::1]:80'])
-            request.requestHeaders.getRawHeaders(b'host'),
-            [b'[::1]:80'],
-        )
 
         # finish the request
         request.finish()
@@ -377,7 +351,7 @@ class MatrixFederationAgentTests(TestCase):
 
         # now there should be a SRV lookup
         self.mock_resolver.resolve_service.assert_called_once_with(
-            b"_matrix._tcp.testserv",
+            b"_matrix._tcp.testserv"
         )
 
         # we should fall back to a direct connection
@@ -387,19 +361,13 @@ class MatrixFederationAgentTests(TestCase):
         self.assertEqual(port, 8448)
 
         # make a test server, and wire up the client
-        http_server = self._make_connection(
+        http_server = self._make_connection(client_factory, expected_sni=b'testserv')
-            client_factory,
-            expected_sni=b'testserv',
-        )
 
         self.assertEqual(len(http_server.requests), 1)
         request = http_server.requests[0]
         self.assertEqual(request.method, b'GET')
         self.assertEqual(request.path, b'/foo/bar')
-        self.assertEqual(
+        self.assertEqual(request.requestHeaders.getRawHeaders(b'host'), [b'testserv'])
-            request.requestHeaders.getRawHeaders(b'host'),
-            [b'testserv'],
-        )
 
         # finish the request
         request.finish()
@@ -427,13 +395,14 @@ class MatrixFederationAgentTests(TestCase):
         self.assertEqual(port, 443)
 
         self._handle_well_known_connection(
-            client_factory, expected_sni=b"testserv",
+            client_factory,
+            expected_sni=b"testserv",
             content=b'{ "m.server": "target-server" }',
         )
 
         # there should be a SRV lookup
         self.mock_resolver.resolve_service.assert_called_once_with(
-            b"_matrix._tcp.target-server",
+            b"_matrix._tcp.target-server"
         )
 
         # now we should get a connection to the target server
@@ -444,8 +413,7 @@ class MatrixFederationAgentTests(TestCase):
 
         # make a test server, and wire up the client
         http_server = self._make_connection(
-            client_factory,
+            client_factory, expected_sni=b'target-server'
-            expected_sni=b'target-server',
         )
 
         self.assertEqual(len(http_server.requests), 1)
@@ -453,8 +421,7 @@ class MatrixFederationAgentTests(TestCase):
         self.assertEqual(request.method, b'GET')
         self.assertEqual(request.path, b'/foo/bar')
         self.assertEqual(
-            request.requestHeaders.getRawHeaders(b'host'),
+            request.requestHeaders.getRawHeaders(b'host'), [b'target-server']
-            [b'target-server'],
         )
 
         # finish the request
@@ -490,8 +457,7 @@ class MatrixFederationAgentTests(TestCase):
         self.assertEqual(port, 443)
 
         redirect_server = self._make_connection(
-            client_factory,
+            client_factory, expected_sni=b"testserv"
-            expected_sni=b"testserv",
         )
 
         # send a 302 redirect
@@ -500,7 +466,7 @@ class MatrixFederationAgentTests(TestCase):
         request.redirect(b'https://testserv/even_better_known')
         request.finish()
 
-        self.reactor.pump((0.1, ))
+        self.reactor.pump((0.1,))
 
         # now there should be another connection
         clients = self.reactor.tcpClients
@@ -510,8 +476,7 @@ class MatrixFederationAgentTests(TestCase):
         self.assertEqual(port, 443)
 
         well_known_server = self._make_connection(
-            client_factory,
+            client_factory, expected_sni=b"testserv"
-            expected_sni=b"testserv",
         )
 
         self.assertEqual(len(well_known_server.requests), 1, "No request after 302")
@@ -521,11 +486,11 @@ class MatrixFederationAgentTests(TestCase):
         request.write(b'{ "m.server": "target-server" }')
         request.finish()
 
-        self.reactor.pump((0.1, ))
+        self.reactor.pump((0.1,))
 
         # there should be a SRV lookup
         self.mock_resolver.resolve_service.assert_called_once_with(
-            b"_matrix._tcp.target-server",
+            b"_matrix._tcp.target-server"
         )
 
         # now we should get a connection to the target server
@@ -536,8 +501,7 @@ class MatrixFederationAgentTests(TestCase):
 
         # make a test server, and wire up the client
         http_server = self._make_connection(
-            client_factory,
+            client_factory, expected_sni=b'target-server'
-            expected_sni=b'target-server',
         )
 
         self.assertEqual(len(http_server.requests), 1)
@@ -545,8 +509,7 @@ class MatrixFederationAgentTests(TestCase):
         self.assertEqual(request.method, b'GET')
         self.assertEqual(request.path, b'/foo/bar')
         self.assertEqual(
-            request.requestHeaders.getRawHeaders(b'host'),
+            request.requestHeaders.getRawHeaders(b'host'), [b'target-server']
-            [b'target-server'],
         )
 
         # finish the request
@@ -585,12 +548,12 @@ class MatrixFederationAgentTests(TestCase):
         self.assertEqual(port, 443)
 
         self._handle_well_known_connection(
-            client_factory, expected_sni=b"testserv", content=b'NOT JSON',
+            client_factory, expected_sni=b"testserv", content=b'NOT JSON'
         )
 
         # now there should be a SRV lookup
         self.mock_resolver.resolve_service.assert_called_once_with(
-            b"_matrix._tcp.testserv",
+            b"_matrix._tcp.testserv"
         )
 
         # we should fall back to a direct connection
@@ -600,19 +563,13 @@ class MatrixFederationAgentTests(TestCase):
         self.assertEqual(port, 8448)
 
         # make a test server, and wire up the client
-        http_server = self._make_connection(
+        http_server = self._make_connection(client_factory, expected_sni=b'testserv')
-            client_factory,
-            expected_sni=b'testserv',
-        )
 
         self.assertEqual(len(http_server.requests), 1)
         request = http_server.requests[0]
         self.assertEqual(request.method, b'GET')
         self.assertEqual(request.path, b'/foo/bar')
-        self.assertEqual(
+        self.assertEqual(request.requestHeaders.getRawHeaders(b'host'), [b'testserv'])
-            request.requestHeaders.getRawHeaders(b'host'),
-            [b'testserv'],
-        )
 
         # finish the request
         request.finish()
@@ -635,7 +592,7 @@ class MatrixFederationAgentTests(TestCase):
 
         # the request for a .well-known will have failed with a DNS lookup error.
         self.mock_resolver.resolve_service.assert_called_once_with(
-            b"_matrix._tcp.testserv",
+            b"_matrix._tcp.testserv"
         )
 
         # Make sure treq is trying to connect
@@ -646,19 +603,13 @@ class MatrixFederationAgentTests(TestCase):
         self.assertEqual(port, 8443)
 
         # make a test server, and wire up the client
-        http_server = self._make_connection(
+        http_server = self._make_connection(client_factory, expected_sni=b'testserv')
-            client_factory,
-            expected_sni=b'testserv',
-        )
 
         self.assertEqual(len(http_server.requests), 1)
         request = http_server.requests[0]
         self.assertEqual(request.method, b'GET')
         self.assertEqual(request.path, b'/foo/bar')
-        self.assertEqual(
+        self.assertEqual(request.requestHeaders.getRawHeaders(b'host'), [b'testserv'])
-            request.requestHeaders.getRawHeaders(b'host'),
-            [b'testserv'],
-        )
 
         # finish the request
         request.finish()
@@ -685,17 +636,18 @@ class MatrixFederationAgentTests(TestCase):
         self.assertEqual(port, 443)
 
         self.mock_resolver.resolve_service.side_effect = lambda _: [
-            Server(host=b"srvtarget", port=8443),
+            Server(host=b"srvtarget", port=8443)
         ]
 
         self._handle_well_known_connection(
-            client_factory, expected_sni=b"testserv",
+            client_factory,
+            expected_sni=b"testserv",
             content=b'{ "m.server": "target-server" }',
         )
 
         # there should be a SRV lookup
         self.mock_resolver.resolve_service.assert_called_once_with(
-            b"_matrix._tcp.target-server",
+            b"_matrix._tcp.target-server"
         )
 
         # now we should get a connection to the target of the SRV record
@@ -706,8 +658,7 @@ class MatrixFederationAgentTests(TestCase):
 
         # make a test server, and wire up the client
         http_server = self._make_connection(
-            client_factory,
+            client_factory, expected_sni=b'target-server'
-            expected_sni=b'target-server',
         )
 
         self.assertEqual(len(http_server.requests), 1)
@@ -715,8 +666,7 @@ class MatrixFederationAgentTests(TestCase):
         self.assertEqual(request.method, b'GET')
         self.assertEqual(request.path, b'/foo/bar')
         self.assertEqual(
-            request.requestHeaders.getRawHeaders(b'host'),
+            request.requestHeaders.getRawHeaders(b'host'), [b'target-server']
-            [b'target-server'],
         )
 
         # finish the request
@@ -757,7 +707,7 @@ class MatrixFederationAgentTests(TestCase):
 
         # now there should have been a SRV lookup
         self.mock_resolver.resolve_service.assert_called_once_with(
-            b"_matrix._tcp.xn--bcher-kva.com",
+            b"_matrix._tcp.xn--bcher-kva.com"
         )
 
         # We should fall back to port 8448
@@ -769,8 +719,7 @@ class MatrixFederationAgentTests(TestCase):
 
         # make a test server, and wire up the client
         http_server = self._make_connection(
-            client_factory,
+            client_factory, expected_sni=b'xn--bcher-kva.com'
-            expected_sni=b'xn--bcher-kva.com',
         )
 
         self.assertEqual(len(http_server.requests), 1)
@@ -778,8 +727,7 @@ class MatrixFederationAgentTests(TestCase):
         self.assertEqual(request.method, b'GET')
         self.assertEqual(request.path, b'/foo/bar')
         self.assertEqual(
-            request.requestHeaders.getRawHeaders(b'host'),
+            request.requestHeaders.getRawHeaders(b'host'), [b'xn--bcher-kva.com']
-            [b'xn--bcher-kva.com'],
         )
 
         # finish the request
@@ -801,7 +749,7 @@ class MatrixFederationAgentTests(TestCase):
         self.assertNoResult(test_d)
 
         self.mock_resolver.resolve_service.assert_called_once_with(
-            b"_matrix._tcp.xn--bcher-kva.com",
+            b"_matrix._tcp.xn--bcher-kva.com"
         )
 
         # Make sure treq is trying to connect
@@ -813,8 +761,7 @@ class MatrixFederationAgentTests(TestCase):
 
         # make a test server, and wire up the client
         http_server = self._make_connection(
-            client_factory,
+            client_factory, expected_sni=b'xn--bcher-kva.com'
-            expected_sni=b'xn--bcher-kva.com',
         )
 
         self.assertEqual(len(http_server.requests), 1)
@@ -822,8 +769,7 @@ class MatrixFederationAgentTests(TestCase):
         self.assertEqual(request.method, b'GET')
         self.assertEqual(request.path, b'/foo/bar')
         self.assertEqual(
-            request.requestHeaders.getRawHeaders(b'host'),
+            request.requestHeaders.getRawHeaders(b'host'), [b'xn--bcher-kva.com']
-            [b'xn--bcher-kva.com'],
         )
 
         # finish the request
@@ -897,67 +843,70 @@ class TestCachePeriodFromHeaders(TestCase):
         # uppercase
         self.assertEqual(
             _cache_period_from_headers(
-                Headers({b'Cache-Control': [b'foo, Max-Age = 100, bar']}),
+                Headers({b'Cache-Control': [b'foo, Max-Age = 100, bar']})
-            ), 100,
+            ),
+            100,
         )
 
         # missing value
-        self.assertIsNone(_cache_period_from_headers(
+        self.assertIsNone(
-            Headers({b'Cache-Control': [b'max-age=, bar']}),
+            _cache_period_from_headers(Headers({b'Cache-Control': [b'max-age=, bar']}))
-        ))
+        )
 
         # hackernews: bogus due to semicolon
-        self.assertIsNone(_cache_period_from_headers(
+        self.assertIsNone(
-            Headers({b'Cache-Control': [b'private; max-age=0']}),
+            _cache_period_from_headers(
-        ))
+                Headers({b'Cache-Control': [b'private; max-age=0']})
+            )
+        )
 
         # github
         self.assertEqual(
             _cache_period_from_headers(
-                Headers({b'Cache-Control': [b'max-age=0, private, must-revalidate']}),
+                Headers({b'Cache-Control': [b'max-age=0, private, must-revalidate']})
-            ), 0,
+            ),
+            0,
         )
 
         # google
         self.assertEqual(
             _cache_period_from_headers(
-                Headers({b'cache-control': [b'private, max-age=0']}),
+                Headers({b'cache-control': [b'private, max-age=0']})
-            ), 0,
+            ),
+            0,
         )
 
     def test_expires(self):
         self.assertEqual(
             _cache_period_from_headers(
                 Headers({b'Expires': [b'Wed, 30 Jan 2019 07:35:33 GMT']}),
-                time_now=lambda: 1548833700
+                time_now=lambda: 1548833700,
-            ), 33,
+            ),
+            33,
         )
 
         # cache-control overrides expires
         self.assertEqual(
             _cache_period_from_headers(
-                Headers({
+                Headers(
-                    b'cache-control': [b'max-age=10'],
+                    {
-                    b'Expires': [b'Wed, 30 Jan 2019 07:35:33 GMT']
+                        b'cache-control': [b'max-age=10'],
-                }),
+                        b'Expires': [b'Wed, 30 Jan 2019 07:35:33 GMT'],
-                time_now=lambda: 1548833700
+                    }
-            ), 10,
+                ),
+                time_now=lambda: 1548833700,
+            ),
+            10,
         )
 
         # invalid expires means immediate expiry
-        self.assertEqual(
+        self.assertEqual(_cache_period_from_headers(Headers({b'Expires': [b'0']})), 0)
-            _cache_period_from_headers(
-                Headers({b'Expires': [b'0']}),
-            ), 0,
-        )
 
 
 def _check_logcontext(context):
     current = LoggingContext.current_context()
     if current is not context:
-        raise AssertionError(
+        raise AssertionError("Expected logcontext %s but was %s" % (context, current))
-            "Expected logcontext %s but was %s" % (context, current),
-        )
 
 
 def _build_test_server():
@@ -973,7 +922,7 @@ def _build_test_server():
     server_factory.log = _log_request
 
     server_tls_factory = TLSMemoryBIOFactory(
-        ServerTLSContext(), isClient=False, wrappedFactory=server_factory,
+        ServerTLSContext(), isClient=False, wrappedFactory=server_factory
     )
 
     return server_tls_factory.buildProtocol(None)
@@ -987,6 +936,7 @@ def _log_request(request):
 @implementer(IPolicyForHTTPS)
 class TrustingTLSPolicyForHTTPS(object):
     """An IPolicyForHTTPS which doesn't do any certificate verification"""
+
     def creatorForNetloc(self, hostname, port):
         certificateOptions = OpenSSLCertificateOptions()
         return ClientTLSOptions(hostname, certificateOptions.getContext())

tests/http/federation/test_srv_resolver.py

@@ -68,9 +68,7 @@ class SrvResolverTestCase(unittest.TestCase):
 
         dns_client_mock.lookupService.assert_called_once_with(service_name)
 
-        result_deferred.callback(
+        result_deferred.callback(([answer_srv], None, None))
-            ([answer_srv], None, None)
-        )
 
         servers = self.successResultOf(test_d)
 
@@ -112,7 +110,7 @@ class SrvResolverTestCase(unittest.TestCase):
 
         cache = {service_name: [entry]}
         resolver = SrvResolver(
-            dns_client=dns_client_mock, cache=cache, get_time=clock.time,
+            dns_client=dns_client_mock, cache=cache, get_time=clock.time
         )
 
         servers = yield resolver.resolve_service(service_name)
@@ -168,11 +166,13 @@ class SrvResolverTestCase(unittest.TestCase):
         self.assertNoResult(resolve_d)
 
         # returning a single "." should make the lookup fail with a ConenctError
-        lookup_deferred.callback((
+        lookup_deferred.callback(
-            [dns.RRHeader(type=dns.SRV, payload=dns.Record_SRV(target=b"."))],
+            (
-            None,
+                [dns.RRHeader(type=dns.SRV, payload=dns.Record_SRV(target=b"."))],
-            None,
+                None,
-        ))
+                None,
+            )
+        )
 
         self.failureResultOf(resolve_d, ConnectError)
 
@@ -191,14 +191,16 @@ class SrvResolverTestCase(unittest.TestCase):
         resolve_d = resolver.resolve_service(service_name)
         self.assertNoResult(resolve_d)
 
-        lookup_deferred.callback((
+        lookup_deferred.callback(
-            [
+            (
-                dns.RRHeader(type=dns.A, payload=dns.Record_A()),
+                [
-                dns.RRHeader(type=dns.SRV, payload=dns.Record_SRV(target=b"host")),
+                    dns.RRHeader(type=dns.A, payload=dns.Record_A()),
-            ],
+                    dns.RRHeader(type=dns.SRV, payload=dns.Record_SRV(target=b"host")),
-            None,
+                ],
-            None,
+                None,
-        ))
+                None,
+            )
+        )
 
         servers = self.successResultOf(resolve_d)
 

tests/http/test_fedclient.py

@@ -36,9 +36,7 @@ from tests.unittest import HomeserverTestCase
 def check_logcontext(context):
     current = LoggingContext.current_context()
     if current is not context:
-        raise AssertionError(
+        raise AssertionError("Expected logcontext %s but was %s" % (context, current))
-            "Expected logcontext %s but was %s" % (context, current),
-        )
 
 
 class FederationClientTests(HomeserverTestCase):
@@ -54,6 +52,7 @@ class FederationClientTests(HomeserverTestCase):
         """
         happy-path test of a GET request
         """
+
         @defer.inlineCallbacks
         def do_request():
             with LoggingContext("one") as context:
@@ -175,8 +174,7 @@ class FederationClientTests(HomeserverTestCase):
 
         self.assertIsInstance(f.value, RequestSendFailed)
         self.assertIsInstance(
-            f.value.inner_exception,
+            f.value.inner_exception, (ConnectingCancelledError, TimeoutError)
-            (ConnectingCancelledError, TimeoutError),
         )
 
     def test_client_connect_no_response(self):
@@ -216,9 +214,7 @@ class FederationClientTests(HomeserverTestCase):
         Once the client gets the headers, _request returns successfully.
         """
         request = MatrixFederationRequest(
-            method="GET",
+            method="GET", destination="testserv:8008", path="foo/bar"
-            destination="testserv:8008",
-            path="foo/bar",
         )
         d = self.cl._send_request(request, timeout=10000)
 
@@ -258,8 +254,10 @@ class FederationClientTests(HomeserverTestCase):
 
         # Send it the HTTP response
         client.dataReceived(
-            (b"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n"
+            (
-             b"Server: Fake\r\n\r\n")
+                b"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n"
+                b"Server: Fake\r\n\r\n"
+            )
         )
 
         # Push by enough to time it out
@@ -274,9 +272,7 @@ class FederationClientTests(HomeserverTestCase):
         requiring a trailing slash. We need to retry the request with a
         trailing slash. Workaround for Synapse <= v0.99.3, explained in #3622.
         """
-        d = self.cl.get_json(
+        d = self.cl.get_json("testserv:8008", "foo/bar", try_trailing_slash_on_400=True)
-            "testserv:8008", "foo/bar", try_trailing_slash_on_400=True,
-        )
 
         # Send the request
         self.pump()
@@ -329,9 +325,7 @@ class FederationClientTests(HomeserverTestCase):
 
         See test_client_requires_trailing_slashes() for context.
         """
-        d = self.cl.get_json(
+        d = self.cl.get_json("testserv:8008", "foo/bar", try_trailing_slash_on_400=True)
-            "testserv:8008", "foo/bar", try_trailing_slash_on_400=True,
-        )
 
         # Send the request
         self.pump()
@@ -368,10 +362,7 @@ class FederationClientTests(HomeserverTestCase):
         self.failureResultOf(d)
 
     def test_client_sends_body(self):
-        self.cl.post_json(
+        self.cl.post_json("testserv:8008", "foo/bar", timeout=10000, data={"a": "b"})
-            "testserv:8008", "foo/bar", timeout=10000,
-            data={"a": "b"}
-        )
 
         self.pump()
 

tests/patch_inline_callbacks.py

@@ -45,7 +45,9 @@ def do_patch():
             except Exception:
                 if LoggingContext.current_context() != start_context:
                     err = "%s changed context from %s to %s on exception" % (
-                        f, start_context, LoggingContext.current_context()
+                        f,
+                        start_context,
+                        LoggingContext.current_context(),
                     )
                     print(err, file=sys.stderr)
                     raise Exception(err)
@@ -54,7 +56,9 @@ def do_patch():
             if not isinstance(res, Deferred) or res.called:
                 if LoggingContext.current_context() != start_context:
                     err = "%s changed context from %s to %s" % (
-                        f, start_context, LoggingContext.current_context()
+                        f,
+                        start_context,
+                        LoggingContext.current_context(),
                     )
                     # print the error to stderr because otherwise all we
                     # see in travis-ci is the 500 error
@@ -66,9 +70,7 @@ def do_patch():
                 err = (
                     "%s returned incomplete deferred in non-sentinel context "
                     "%s (start was %s)"
-                ) % (
+                ) % (f, LoggingContext.current_context(), start_context)
-                    f, LoggingContext.current_context(), start_context,
-                )
                 print(err, file=sys.stderr)
                 raise Exception(err)
 
@@ -76,7 +78,9 @@ def do_patch():
                 if LoggingContext.current_context() != start_context:
                     err = "%s completion of %s changed context from %s to %s" % (
                         "Failure" if isinstance(r, Failure) else "Success",
-                        f, start_context, LoggingContext.current_context(),
+                        f,
+                        start_context,
+                        LoggingContext.current_context(),
                     )
                     print(err, file=sys.stderr)
                     raise Exception(err)

tests/replication/slave/storage/_base.py

@@ -74,21 +74,18 @@ class BaseSlavedStoreTestCase(unittest.HomeserverTestCase):
             self.assertEqual(
                 master_result,
                 expected_result,
-                "Expected master result to be %r but was %r" % (
+                "Expected master result to be %r but was %r"
-                    expected_result, master_result
+                % (expected_result, master_result),
-                ),
             )
             self.assertEqual(
                 slaved_result,
                 expected_result,
-                "Expected slave result to be %r but was %r" % (
+                "Expected slave result to be %r but was %r"
-                    expected_result, slaved_result
+                % (expected_result, slaved_result),
-                ),
             )
         self.assertEqual(
             master_result,
             slaved_result,
-            "Slave result %r does not match master result %r" % (
+            "Slave result %r does not match master result %r"
-                slaved_result, master_result
+            % (slaved_result, master_result),
-            ),
         )

tests/replication/slave/storage/test_events.py

@@ -234,10 +234,7 @@ class SlavedEventStoreTestCase(BaseSlavedStoreTestCase):
             type="m.room.member", sender=USER_ID_2, key=USER_ID_2, membership="join"
         )
         msg, msgctx = self.build_event()
-        self.get_success(self.master_store.persist_events([
+        self.get_success(self.master_store.persist_events([(j2, j2ctx), (msg, msgctx)]))
-            (j2, j2ctx),
-            (msg, msgctx),
-        ]))
         self.replicate()
 
         event_source = RoomEventSource(self.hs)
@@ -257,15 +254,13 @@ class SlavedEventStoreTestCase(BaseSlavedStoreTestCase):
             #
             # First, we get a list of the rooms we are joined to
             joined_rooms = self.get_success(
-                self.slaved_store.get_rooms_for_user_with_stream_ordering(
+                self.slaved_store.get_rooms_for_user_with_stream_ordering(USER_ID_2)
-                    USER_ID_2,
-                ),
             )
 
             # Then, we get a list of the events since the last sync
             membership_changes = self.get_success(
                 self.slaved_store.get_membership_changes_for_user(
-                    USER_ID_2, prev_token, current_token,
+                    USER_ID_2, prev_token, current_token
                 )
             )
 
@@ -298,9 +293,7 @@ class SlavedEventStoreTestCase(BaseSlavedStoreTestCase):
                 self.master_store.persist_events([(event, context)], backfilled=True)
             )
         else:
-            self.get_success(
+            self.get_success(self.master_store.persist_event(event, context))
-                self.master_store.persist_event(event, context)
-            )
 
         return event
 
@@ -359,9 +352,7 @@ class SlavedEventStoreTestCase(BaseSlavedStoreTestCase):
             )
         else:
             state_handler = self.hs.get_state_handler()
-            context = self.get_success(state_handler.compute_event_context(
+            context = self.get_success(state_handler.compute_event_context(event))
-                event
-            ))
 
         self.master_store.add_push_actions_to_staging(
             event.event_id, {user_id: actions for user_id, actions in push_actions}

tests/replication/tcp/streams/_base.py

@@ -22,6 +22,7 @@ from tests.server import FakeTransport
 
 class BaseStreamTestCase(unittest.HomeserverTestCase):
     """Base class for tests of the replication streams"""
+
     def prepare(self, reactor, clock, hs):
         # build a replication server
         server_factory = ReplicationStreamProtocolFactory(self.hs)
@@ -52,6 +53,7 @@ class BaseStreamTestCase(unittest.HomeserverTestCase):
 
 class TestReplicationClientHandler(object):
     """Drop-in for ReplicationClientHandler which just collects RDATA rows"""
+
     def __init__(self):
         self.received_rdata_rows = []
 
@@ -69,6 +71,4 @@ class TestReplicationClientHandler(object):
 
     def on_rdata(self, stream_name, token, rows):
         for r in rows:
-            self.received_rdata_rows.append(
+            self.received_rdata_rows.append((stream_name, token, r))
-                (stream_name, token, r)
-            )

tests/rest/admin/test_admin.py

@@ -41,10 +41,10 @@ class VersionTestCase(unittest.HomeserverTestCase):
         request, channel = self.make_request("GET", self.url, shorthand=False)
         self.render(request)
 
-        self.assertEqual(200, int(channel.result["code"]),
+        self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
-                         msg=channel.result["body"])
+        self.assertEqual(
-        self.assertEqual({'server_version', 'python_version'},
+            {'server_version', 'python_version'}, set(channel.json_body.keys())
-                         set(channel.json_body.keys()))
+        )
 
 
 class UserRegisterTestCase(unittest.HomeserverTestCase):
@@ -200,9 +200,7 @@ class UserRegisterTestCase(unittest.HomeserverTestCase):
         nonce = channel.json_body["nonce"]
 
         want_mac = hmac.new(key=b"shared", digestmod=hashlib.sha1)
-        want_mac.update(
+        want_mac.update(nonce.encode('ascii') + b"\x00bob\x00abc123\x00admin")
-            nonce.encode('ascii') + b"\x00bob\x00abc123\x00admin"
-        )
         want_mac = want_mac.hexdigest()
 
         body = json.dumps(
@@ -330,11 +328,13 @@ class UserRegisterTestCase(unittest.HomeserverTestCase):
         #
 
         # Invalid user_type
-        body = json.dumps({
+        body = json.dumps(
-            "nonce": nonce(),
+            {
-            "username": "a",
+                "nonce": nonce(),
-            "password": "1234",
+                "username": "a",
-            "user_type": "invalid"}
+                "password": "1234",
+                "user_type": "invalid",
+            }
         )
         request, channel = self.make_request("POST", self.url, body.encode('utf8'))
         self.render(request)
@@ -357,9 +357,7 @@ class ShutdownRoomTestCase(unittest.HomeserverTestCase):
         hs.config.user_consent_version = "1"
 
         consent_uri_builder = Mock()
-        consent_uri_builder.build_user_consent_uri.return_value = (
+        consent_uri_builder.build_user_consent_uri.return_value = "http://example.com"
-            "http://example.com"
-        )
         self.event_creation_handler._consent_uri_builder = consent_uri_builder
 
         self.store = hs.get_datastore()
@@ -371,9 +369,7 @@ class ShutdownRoomTestCase(unittest.HomeserverTestCase):
         self.other_user_token = self.login("user", "pass")
 
         # Mark the admin user as having consented
-        self.get_success(
+        self.get_success(self.store.user_set_consent_version(self.admin_user, "1"))
-            self.store.user_set_consent_version(self.admin_user, "1"),
-        )
 
     def test_shutdown_room_consent(self):
         """Test that we can shutdown rooms with local users who have not
@@ -385,9 +381,7 @@ class ShutdownRoomTestCase(unittest.HomeserverTestCase):
         room_id = self.helper.create_room_as(self.other_user, tok=self.other_user_token)
 
         # Assert one user in room
-        users_in_room = self.get_success(
+        users_in_room = self.get_success(self.store.get_users_in_room(room_id))
-            self.store.get_users_in_room(room_id),
-        )
         self.assertEqual([self.other_user], users_in_room)
 
         # Enable require consent to send events
@@ -395,8 +389,7 @@ class ShutdownRoomTestCase(unittest.HomeserverTestCase):
 
         # Assert that the user is getting consent error
         self.helper.send(
-            room_id,
+            room_id, body="foo", tok=self.other_user_token, expect_code=403
-            body="foo", tok=self.other_user_token, expect_code=403,
         )
 
         # Test that the admin can still send shutdown
@@ -412,9 +405,7 @@ class ShutdownRoomTestCase(unittest.HomeserverTestCase):
         self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
 
         # Assert there is now no longer anyone in the room
-        users_in_room = self.get_success(
+        users_in_room = self.get_success(self.store.get_users_in_room(room_id))
-            self.store.get_users_in_room(room_id),
-        )
         self.assertEqual([], users_in_room)
 
     @unittest.DEBUG
@@ -459,24 +450,20 @@ class ShutdownRoomTestCase(unittest.HomeserverTestCase):
 
         url = "rooms/%s/initialSync" % (room_id,)
         request, channel = self.make_request(
-            "GET",
+            "GET", url.encode('ascii'), access_token=self.admin_user_tok
-            url.encode('ascii'),
-            access_token=self.admin_user_tok,
         )
         self.render(request)
         self.assertEqual(
-            expect_code, int(channel.result["code"]), msg=channel.result["body"],
+            expect_code, int(channel.result["code"]), msg=channel.result["body"]
         )
 
         url = "events?timeout=0&room_id=" + room_id
         request, channel = self.make_request(
-            "GET",
+            "GET", url.encode('ascii'), access_token=self.admin_user_tok
-            url.encode('ascii'),
-            access_token=self.admin_user_tok,
         )
         self.render(request)
         self.assertEqual(
-            expect_code, int(channel.result["code"]), msg=channel.result["body"],
+            expect_code, int(channel.result["code"]), msg=channel.result["body"]
         )
 
 
@@ -502,15 +489,11 @@ class DeleteGroupTestCase(unittest.HomeserverTestCase):
             "POST",
             "/create_group".encode('ascii'),
             access_token=self.admin_user_tok,
-            content={
+            content={"localpart": "test"},
-                "localpart": "test",
-            }
         )
 
         self.render(request)
-        self.assertEqual(
+        self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
-            200, int(channel.result["code"]), msg=channel.result["body"],
-        )
 
         group_id = channel.json_body["group_id"]
 
@@ -520,27 +503,17 @@ class DeleteGroupTestCase(unittest.HomeserverTestCase):
 
         url = "/groups/%s/admin/users/invite/%s" % (group_id, self.other_user)
         request, channel = self.make_request(
-            "PUT",
+            "PUT", url.encode('ascii'), access_token=self.admin_user_tok, content={}
-            url.encode('ascii'),
-            access_token=self.admin_user_tok,
-            content={}
         )
         self.render(request)
-        self.assertEqual(
+        self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
-            200, int(channel.result["code"]), msg=channel.result["body"],
-        )
 
         url = "/groups/%s/self/accept_invite" % (group_id,)
         request, channel = self.make_request(
-            "PUT",
+            "PUT", url.encode('ascii'), access_token=self.other_user_token, content={}
-            url.encode('ascii'),
-            access_token=self.other_user_token,
-            content={}
         )
         self.render(request)
-        self.assertEqual(
+        self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
-            200, int(channel.result["code"]), msg=channel.result["body"],
-        )
 
         # Check other user knows they're in the group
         self.assertIn(group_id, self._get_groups_user_is_in(self.admin_user_tok))
@@ -552,15 +525,11 @@ class DeleteGroupTestCase(unittest.HomeserverTestCase):
             "POST",
             url.encode('ascii'),
             access_token=self.admin_user_tok,
-            content={
+            content={"localpart": "test"},
-                "localpart": "test",
-            }
         )
 
         self.render(request)
-        self.assertEqual(
+        self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
-            200, int(channel.result["code"]), msg=channel.result["body"],
-        )
 
         # Check group returns 404
         self._check_group(group_id, expect_code=404)
@@ -576,28 +545,22 @@ class DeleteGroupTestCase(unittest.HomeserverTestCase):
 
         url = "/groups/%s/profile" % (group_id,)
         request, channel = self.make_request(
-            "GET",
+            "GET", url.encode('ascii'), access_token=self.admin_user_tok
-            url.encode('ascii'),
-            access_token=self.admin_user_tok,
         )
 
         self.render(request)
         self.assertEqual(
-            expect_code, int(channel.result["code"]), msg=channel.result["body"],
+            expect_code, int(channel.result["code"]), msg=channel.result["body"]
         )
 
     def _get_groups_user_is_in(self, access_token):
         """Returns the list of groups the user is in (given their access token)
         """
         request, channel = self.make_request(
-            "GET",
+            "GET", "/joined_groups".encode('ascii'), access_token=access_token
-            "/joined_groups".encode('ascii'),
-            access_token=access_token,
         )
 
         self.render(request)
-        self.assertEqual(
+        self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
-            200, int(channel.result["code"]), msg=channel.result["body"],
-        )
 
         return channel.json_body["groups"]

tests/rest/client/test_identity.py

@@ -44,7 +44,7 @@ class IdentityTestCase(unittest.HomeserverTestCase):
         tok = self.login("kermit", "monkey")
 
         request, channel = self.make_request(
-            b"POST", "/createRoom", b"{}", access_token=tok,
+            b"POST", "/createRoom", b"{}", access_token=tok
         )
         self.render(request)
         self.assertEquals(channel.result["code"], b"200", channel.result)
@@ -56,11 +56,9 @@ class IdentityTestCase(unittest.HomeserverTestCase):
             "address": "test@example.com",
         }
         request_data = json.dumps(params)
-        request_url = (
+        request_url = ("/rooms/%s/invite" % (room_id)).encode('ascii')
-            "/rooms/%s/invite" % (room_id)
-        ).encode('ascii')
         request, channel = self.make_request(
-            b"POST", request_url, request_data, access_token=tok,
+            b"POST", request_url, request_data, access_token=tok
         )
         self.render(request)
         self.assertEquals(channel.result["code"], b"403", channel.result)

tests/rest/client/v1/test_directory.py

@@ -45,7 +45,7 @@ class DirectoryTestCase(unittest.HomeserverTestCase):
         self.room_owner_tok = self.login("room_owner", "test")
 
         self.room_id = self.helper.create_room_as(
-            self.room_owner, tok=self.room_owner_tok,
+            self.room_owner, tok=self.room_owner_tok
         )
 
         self.user = self.register_user("user", "test")
@@ -80,12 +80,10 @@ class DirectoryTestCase(unittest.HomeserverTestCase):
 
         # We use deliberately a localpart under the length threshold so
         # that we can make sure that the check is done on the whole alias.
-        data = {
+        data = {"room_alias_name": random_string(256 - len(self.hs.hostname))}
-            "room_alias_name": random_string(256 - len(self.hs.hostname)),
-        }
         request_data = json.dumps(data)
         request, channel = self.make_request(
-            "POST", url, request_data, access_token=self.user_tok,
+            "POST", url, request_data, access_token=self.user_tok
         )
         self.render(request)
         self.assertEqual(channel.code, 400, channel.result)
@@ -96,51 +94,42 @@ class DirectoryTestCase(unittest.HomeserverTestCase):
         # Check with an alias of allowed length. There should already be
         # a test that ensures it works in test_register.py, but let's be
         # as cautious as possible here.
-        data = {
+        data = {"room_alias_name": random_string(5)}
-            "room_alias_name": random_string(5),
-        }
         request_data = json.dumps(data)
         request, channel = self.make_request(
-            "POST", url, request_data, access_token=self.user_tok,
+            "POST", url, request_data, access_token=self.user_tok
         )
         self.render(request)
         self.assertEqual(channel.code, 200, channel.result)
 
     def set_alias_via_state_event(self, expected_code, alias_length=5):
-        url = ("/_matrix/client/r0/rooms/%s/state/m.room.aliases/%s"
+        url = "/_matrix/client/r0/rooms/%s/state/m.room.aliases/%s" % (
-               % (self.room_id, self.hs.hostname))
+            self.room_id,
+            self.hs.hostname,
+        )
 
-        data = {
+        data = {"aliases": [self.random_alias(alias_length)]}
-            "aliases": [
-                self.random_alias(alias_length),
-            ],
-        }
         request_data = json.dumps(data)
 
         request, channel = self.make_request(
-            "PUT", url, request_data, access_token=self.user_tok,
+            "PUT", url, request_data, access_token=self.user_tok
         )
         self.render(request)
         self.assertEqual(channel.code, expected_code, channel.result)
 
     def set_alias_via_directory(self, expected_code, alias_length=5):
         url = "/_matrix/client/r0/directory/room/%s" % self.random_alias(alias_length)
-        data = {
+        data = {"room_id": self.room_id}
-            "room_id": self.room_id,
-        }
         request_data = json.dumps(data)
 
         request, channel = self.make_request(
-            "PUT", url, request_data, access_token=self.user_tok,
+            "PUT", url, request_data, access_token=self.user_tok
         )
         self.render(request)
         self.assertEqual(channel.code, expected_code, channel.result)
 
     def random_alias(self, length):
-        return RoomAlias(
+        return RoomAlias(random_string(length), self.hs.hostname).to_string()
-            random_string(length),
-            self.hs.hostname,
-        ).to_string()
 
     def ensure_user_left_room(self):
         self.ensure_membership("leave")
@@ -151,17 +140,9 @@ class DirectoryTestCase(unittest.HomeserverTestCase):
     def ensure_membership(self, membership):
         try:
             if membership == "leave":
-                self.helper.leave(
+                self.helper.leave(room=self.room_id, user=self.user, tok=self.user_tok)
-                    room=self.room_id,
-                    user=self.user,
-                    tok=self.user_tok,
-                )
             if membership == "join":
-                self.helper.join(
+                self.helper.join(room=self.room_id, user=self.user, tok=self.user_tok)
-                    room=self.room_id,
-                    user=self.user,
-                    tok=self.user_tok,
-                )
         except AssertionError:
             # We don't care whether the leave request didn't return a 200 (e.g.
             # if the user isn't already in the room), because we only want to

tests/rest/client/v1/test_login.py

@@ -37,10 +37,7 @@ class LoginRestServletTestCase(unittest.HomeserverTestCase):
         for i in range(0, 6):
             params = {
                 "type": "m.login.password",
-                "identifier": {
+                "identifier": {"type": "m.id.user", "user": "kermit" + str(i)},
-                    "type": "m.id.user",
-                    "user": "kermit" + str(i),
-                },
                 "password": "monkey",
             }
             request_data = json.dumps(params)
@@ -57,14 +54,11 @@ class LoginRestServletTestCase(unittest.HomeserverTestCase):
         # than 1min.
         self.assertTrue(retry_after_ms < 6000)
 
-        self.reactor.advance(retry_after_ms / 1000.)
+        self.reactor.advance(retry_after_ms / 1000.0)
 
         params = {
             "type": "m.login.password",
-            "identifier": {
+            "identifier": {"type": "m.id.user", "user": "kermit" + str(i)},
-                "type": "m.id.user",
-                "user": "kermit" + str(i),
-            },
             "password": "monkey",
         }
         request_data = json.dumps(params)
@@ -82,10 +76,7 @@ class LoginRestServletTestCase(unittest.HomeserverTestCase):
         for i in range(0, 6):
             params = {
                 "type": "m.login.password",
-                "identifier": {
+                "identifier": {"type": "m.id.user", "user": "kermit"},
-                    "type": "m.id.user",
-                    "user": "kermit",
-                },
                 "password": "monkey",
             }
             request_data = json.dumps(params)
@@ -102,14 +93,11 @@ class LoginRestServletTestCase(unittest.HomeserverTestCase):
         # than 1min.
         self.assertTrue(retry_after_ms < 6000)
 
-        self.reactor.advance(retry_after_ms / 1000.)
+        self.reactor.advance(retry_after_ms / 1000.0)
 
         params = {
             "type": "m.login.password",
-            "identifier": {
+            "identifier": {"type": "m.id.user", "user": "kermit"},
-                "type": "m.id.user",
-                "user": "kermit",
-            },
             "password": "monkey",
         }
         request_data = json.dumps(params)
@@ -127,10 +115,7 @@ class LoginRestServletTestCase(unittest.HomeserverTestCase):
         for i in range(0, 6):
             params = {
                 "type": "m.login.password",
-                "identifier": {
+                "identifier": {"type": "m.id.user", "user": "kermit"},
-                    "type": "m.id.user",
-                    "user": "kermit",
-                },
                 "password": "notamonkey",
             }
             request_data = json.dumps(params)
@@ -147,14 +132,11 @@ class LoginRestServletTestCase(unittest.HomeserverTestCase):
         # than 1min.
         self.assertTrue(retry_after_ms < 6000)
 
-        self.reactor.advance(retry_after_ms / 1000.)
+        self.reactor.advance(retry_after_ms / 1000.0)
 
         params = {
             "type": "m.login.password",
-            "identifier": {
+            "identifier": {"type": "m.id.user", "user": "kermit"},
-                "type": "m.id.user",
-                "user": "kermit",
-            },
             "password": "notamonkey",
         }
         request_data = json.dumps(params)

tests/rest/client/v1/test_profile.py

@@ -199,37 +199,24 @@ class ProfilesRestrictedTestCase(unittest.HomeserverTestCase):
     def test_in_shared_room(self):
         self.ensure_requester_left_room()
 
-        self.helper.join(
+        self.helper.join(room=self.room_id, user=self.requester, tok=self.requester_tok)
-            room=self.room_id,
-            user=self.requester,
-            tok=self.requester_tok,
-        )
 
         self.try_fetch_profile(200, self.requester_tok)
 
     def try_fetch_profile(self, expected_code, access_token=None):
+        self.request_profile(expected_code, access_token=access_token)
+
         self.request_profile(
-            expected_code,
+            expected_code, url_suffix="/displayname", access_token=access_token
-            access_token=access_token
         )
 
         self.request_profile(
-            expected_code,
+            expected_code, url_suffix="/avatar_url", access_token=access_token
-            url_suffix="/displayname",
-            access_token=access_token,
-        )
-
-        self.request_profile(
-            expected_code,
-            url_suffix="/avatar_url",
-            access_token=access_token,
         )
 
     def request_profile(self, expected_code, url_suffix="", access_token=None):
         request, channel = self.make_request(
-            "GET",
+            "GET", self.profile_url + url_suffix, access_token=access_token
-            self.profile_url + url_suffix,
-            access_token=access_token,
         )
         self.render(request)
         self.assertEqual(channel.code, expected_code, channel.result)
@@ -237,9 +224,7 @@ class ProfilesRestrictedTestCase(unittest.HomeserverTestCase):
     def ensure_requester_left_room(self):
         try:
             self.helper.leave(
-                room=self.room_id,
+                room=self.room_id, user=self.requester, tok=self.requester_tok
-                user=self.requester,
-                tok=self.requester_tok,
             )
         except AssertionError:
             # We don't care whether the leave request didn't return a 200 (e.g.

tests/rest/client/v2_alpha/test_register.py

@@ -41,11 +41,10 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
         as_token = "i_am_an_app_service"
 
         appservice = ApplicationService(
-            as_token, self.hs.config.server_name,
+            as_token,
+            self.hs.config.server_name,
             id="1234",
-            namespaces={
+            namespaces={"users": [{"regex": r"@as_user.*", "exclusive": True}]},
-                "users": [{"regex": r"@as_user.*", "exclusive": True}],
-            },
         )
 
         self.hs.get_datastore().services_cache.append(appservice)
@@ -57,10 +56,7 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
         self.render(request)
 
         self.assertEquals(channel.result["code"], b"200", channel.result)
-        det_data = {
+        det_data = {"user_id": user_id, "home_server": self.hs.hostname}
-            "user_id": user_id,
-            "home_server": self.hs.hostname,
-        }
         self.assertDictContainsSubset(det_data, channel.json_body)
 
     def test_POST_appservice_registration_invalid(self):
@@ -128,10 +124,7 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
         request, channel = self.make_request(b"POST", self.url + b"?kind=guest", b"{}")
         self.render(request)
 
-        det_data = {
+        det_data = {"home_server": self.hs.hostname, "device_id": "guest_device"}
-            "home_server": self.hs.hostname,
-            "device_id": "guest_device",
-        }
         self.assertEquals(channel.result["code"], b"200", channel.result)
         self.assertDictContainsSubset(det_data, channel.json_body)
 
@@ -159,7 +152,7 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
             else:
                 self.assertEquals(channel.result["code"], b"200", channel.result)
 
-        self.reactor.advance(retry_after_ms / 1000.)
+        self.reactor.advance(retry_after_ms / 1000.0)
 
         request, channel = self.make_request(b"POST", self.url + b"?kind=guest", b"{}")
         self.render(request)
@@ -187,7 +180,7 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
             else:
                 self.assertEquals(channel.result["code"], b"200", channel.result)
 
-        self.reactor.advance(retry_after_ms / 1000.)
+        self.reactor.advance(retry_after_ms / 1000.0)
 
         request, channel = self.make_request(b"POST", self.url + b"?kind=guest", b"{}")
         self.render(request)
@@ -221,23 +214,19 @@ class AccountValidityTestCase(unittest.HomeserverTestCase):
 
         # The specific endpoint doesn't matter, all we need is an authenticated
         # endpoint.
-        request, channel = self.make_request(
+        request, channel = self.make_request(b"GET", "/sync", access_token=tok)
-            b"GET", "/sync", access_token=tok,
-        )
         self.render(request)
 
         self.assertEquals(channel.result["code"], b"200", channel.result)
 
         self.reactor.advance(datetime.timedelta(weeks=1).total_seconds())
 
-        request, channel = self.make_request(
+        request, channel = self.make_request(b"GET", "/sync", access_token=tok)
-            b"GET", "/sync", access_token=tok,
-        )
         self.render(request)
 
         self.assertEquals(channel.result["code"], b"403", channel.result)
         self.assertEquals(
-            channel.json_body["errcode"], Codes.EXPIRED_ACCOUNT, channel.result,
+            channel.json_body["errcode"], Codes.EXPIRED_ACCOUNT, channel.result
         )
 
     def test_manual_renewal(self):
@@ -253,21 +242,17 @@ class AccountValidityTestCase(unittest.HomeserverTestCase):
         admin_tok = self.login("admin", "adminpassword")
 
         url = "/_matrix/client/unstable/admin/account_validity/validity"
-        params = {
+        params = {"user_id": user_id}
-            "user_id": user_id,
-        }
         request_data = json.dumps(params)
         request, channel = self.make_request(
-            b"POST", url, request_data, access_token=admin_tok,
+            b"POST", url, request_data, access_token=admin_tok
         )
         self.render(request)
         self.assertEquals(channel.result["code"], b"200", channel.result)
 
         # The specific endpoint doesn't matter, all we need is an authenticated
         # endpoint.
-        request, channel = self.make_request(
+        request, channel = self.make_request(b"GET", "/sync", access_token=tok)
-            b"GET", "/sync", access_token=tok,
-        )
         self.render(request)
         self.assertEquals(channel.result["code"], b"200", channel.result)
 
@@ -286,20 +271,18 @@ class AccountValidityTestCase(unittest.HomeserverTestCase):
         }
         request_data = json.dumps(params)
         request, channel = self.make_request(
-            b"POST", url, request_data, access_token=admin_tok,
+            b"POST", url, request_data, access_token=admin_tok
         )
         self.render(request)
         self.assertEquals(channel.result["code"], b"200", channel.result)
 
         # The specific endpoint doesn't matter, all we need is an authenticated
         # endpoint.
-        request, channel = self.make_request(
+        request, channel = self.make_request(b"GET", "/sync", access_token=tok)
-            b"GET", "/sync", access_token=tok,
-        )
         self.render(request)
         self.assertEquals(channel.result["code"], b"403", channel.result)
         self.assertEquals(
-            channel.json_body["errcode"], Codes.EXPIRED_ACCOUNT, channel.result,
+            channel.json_body["errcode"], Codes.EXPIRED_ACCOUNT, channel.result
         )
 
 
@@ -358,10 +341,15 @@ class AccountValidityRenewalByEmailTestCase(unittest.HomeserverTestCase):
         # We need to manually add an email address otherwise the handler will do
         # nothing.
         now = self.hs.clock.time_msec()
-        self.get_success(self.store.user_add_threepid(
+        self.get_success(
-            user_id=user_id, medium="email", address="kermit@example.com",
+            self.store.user_add_threepid(
-            validated_at=now, added_at=now,
+                user_id=user_id,
-        ))
+                medium="email",
+                address="kermit@example.com",
+                validated_at=now,
+                added_at=now,
+            )
+        )
 
         # Move 6 days forward. This should trigger a renewal email to be sent.
         self.reactor.advance(datetime.timedelta(days=6).total_seconds())
@@ -379,9 +367,7 @@ class AccountValidityRenewalByEmailTestCase(unittest.HomeserverTestCase):
         # our access token should be denied from now, otherwise they should
         # succeed.
         self.reactor.advance(datetime.timedelta(days=3).total_seconds())
-        request, channel = self.make_request(
+        request, channel = self.make_request(b"GET", "/sync", access_token=tok)
-            b"GET", "/sync", access_token=tok,
-        )
         self.render(request)
         self.assertEquals(channel.result["code"], b"200", channel.result)
 
@@ -393,13 +379,19 @@ class AccountValidityRenewalByEmailTestCase(unittest.HomeserverTestCase):
         # We need to manually add an email address otherwise the handler will do
         # nothing.
         now = self.hs.clock.time_msec()
-        self.get_success(self.store.user_add_threepid(
+        self.get_success(
-            user_id=user_id, medium="email", address="kermit@example.com",
+            self.store.user_add_threepid(
-            validated_at=now, added_at=now,
+                user_id=user_id,
-        ))
+                medium="email",
+                address="kermit@example.com",
+                validated_at=now,
+                added_at=now,
+            )
+        )
 
         request, channel = self.make_request(
-            b"POST", "/_matrix/client/unstable/account_validity/send_mail",
+            b"POST",
+            "/_matrix/client/unstable/account_validity/send_mail",
             access_token=tok,
         )
         self.render(request)

tests/rest/media/v1/test_base.py

@@ -26,20 +26,14 @@ class GetFileNameFromHeadersTests(unittest.TestCase):
         b'inline; filename="aze%20rty"': u"aze%20rty",
         b'inline; filename="aze\"rty"': u'aze"rty',
         b'inline; filename="azer;ty"': u"azer;ty",
-
         b"inline; filename*=utf-8''foo%C2%A3bar": u"foo£bar",
     }
 
     def tests(self):
         for hdr, expected in self.TEST_CASES.items():
-            res = get_filename_from_headers(
+            res = get_filename_from_headers({b'Content-Disposition': [hdr]})
-                {
-                    b'Content-Disposition': [hdr],
-                },
-            )
             self.assertEqual(
-                res, expected,
+                res,
-                "expected output for %s to be %s but was %s" % (
+                expected,
-                    hdr, expected, res,
+                "expected output for %s to be %s but was %s" % (hdr, expected, res),
-                )
             )

tests/rest/test_well_known.py

@@ -31,27 +31,24 @@ class WellKnownTests(unittest.HomeserverTestCase):
         self.hs.config.default_identity_server = "https://testis"
 
         request, channel = self.make_request(
-            "GET",
+            "GET", "/.well-known/matrix/client", shorthand=False
-            "/.well-known/matrix/client",
-            shorthand=False,
         )
         self.render(request)
 
         self.assertEqual(request.code, 200)
         self.assertEqual(
-            channel.json_body, {
+            channel.json_body,
+            {
                 "m.homeserver": {"base_url": "https://tesths"},
                 "m.identity_server": {"base_url": "https://testis"},
-            }
+            },
         )
 
     def test_well_known_no_public_baseurl(self):
         self.hs.config.public_baseurl = None
 
         request, channel = self.make_request(
-            "GET",
+            "GET", "/.well-known/matrix/client", shorthand=False
-            "/.well-known/matrix/client",
-            shorthand=False,
         )
         self.render(request)
 

tests/server.py

@@ -182,7 +182,8 @@ def make_request(
 
     if federation_auth_origin is not None:
         req.requestHeaders.addRawHeader(
-            b"Authorization", b"X-Matrix origin=%s,key=,sig=" % (federation_auth_origin,)
+            b"Authorization",
+            b"X-Matrix origin=%s,key=,sig=" % (federation_auth_origin,),
         )
 
     if content:
@@ -233,7 +234,7 @@ class ThreadedMemoryReactorClock(MemoryReactorClock):
         class FakeResolver(object):
             def getHostByName(self, name, timeout=None):
                 if name not in lookups:
-                    return fail(DNSLookupError("OH NO: unknown %s" % (name, )))
+                    return fail(DNSLookupError("OH NO: unknown %s" % (name,)))
                 return succeed(lookups[name])
 
         self.nameResolver = SimpleResolverComplexifier(FakeResolver())
@@ -454,6 +455,6 @@ class FakeTransport(object):
             logger.warning("Exception writing to protocol: %s", e)
             return
 
-        self.buffer = self.buffer[len(to_write):]
+        self.buffer = self.buffer[len(to_write) :]
         if self.buffer and self.autoflush:
             self._reactor.callLater(0.0, self.flush)

tests/server_notices/test_resource_limits_server_notices.py

@@ -27,7 +27,6 @@ from tests import unittest
 
 
 class TestResourceLimitsServerNotices(unittest.HomeserverTestCase):
-
     def make_homeserver(self, reactor, clock):
         hs_config = self.default_config("test")
         hs_config.server_notices_mxid = "@server:test"

tests/state/test_v2.py

@@ -50,6 +50,7 @@ class FakeEvent(object):
     refer to events. The event_id has node_id as localpart and example.com
     as domain.
     """
+
     def __init__(self, id, sender, type, state_key, content):
         self.node_id = id
         self.event_id = EventID(id, "example.com").to_string()
@@ -142,24 +143,14 @@ INITIAL_EVENTS = [
         content=MEMBERSHIP_CONTENT_JOIN,
     ),
     FakeEvent(
-        id="START",
+        id="START", sender=ZARA, type=EventTypes.Message, state_key=None, content={}
-        sender=ZARA,
-        type=EventTypes.Message,
-        state_key=None,
-        content={},
     ),
     FakeEvent(
-        id="END",
+        id="END", sender=ZARA, type=EventTypes.Message, state_key=None, content={}
-        sender=ZARA,
-        type=EventTypes.Message,
-        state_key=None,
-        content={},
     ),
 ]
 
-INITIAL_EDGES = [
+INITIAL_EDGES = ["START", "IMZ", "IMC", "IMB", "IJR", "IPOWER", "IMA", "CREATE"]
-    "START", "IMZ", "IMC", "IMB", "IJR", "IPOWER", "IMA", "CREATE",
-]
 
 
 class StateTestCase(unittest.TestCase):
@@ -170,12 +161,7 @@ class StateTestCase(unittest.TestCase):
                 sender=ALICE,
                 type=EventTypes.PowerLevels,
                 state_key="",
-                content={
+                content={"users": {ALICE: 100, BOB: 50}},
-                    "users": {
-                        ALICE: 100,
-                        BOB: 50,
-                    }
-                },
             ),
             FakeEvent(
                 id="MA",
@@ -196,19 +182,11 @@ class StateTestCase(unittest.TestCase):
                 sender=BOB,
                 type=EventTypes.PowerLevels,
                 state_key='',
-                content={
+                content={"users": {ALICE: 100, BOB: 50}},
-                    "users": {
-                        ALICE: 100,
-                        BOB: 50,
-                    },
-                },
             ),
         ]
 
-        edges = [
+        edges = [["END", "MB", "MA", "PA", "START"], ["END", "PB", "PA"]]
-            ["END", "MB", "MA", "PA", "START"],
-            ["END", "PB", "PA"],
-        ]
 
         expected_state_ids = ["PA", "MA", "MB"]
 
@@ -232,10 +210,7 @@ class StateTestCase(unittest.TestCase):
             ),
         ]
 
-        edges = [
+        edges = [["END", "JR", "START"], ["END", "ME", "START"]]
-            ["END", "JR", "START"],
-            ["END", "ME", "START"],
-        ]
 
         expected_state_ids = ["JR"]
 
@@ -248,45 +223,25 @@ class StateTestCase(unittest.TestCase):
                 sender=ALICE,
                 type=EventTypes.PowerLevels,
                 state_key="",
-                content={
+                content={"users": {ALICE: 100, BOB: 50}},
-                    "users": {
-                        ALICE: 100,
-                        BOB: 50,
-                    }
-                },
             ),
             FakeEvent(
                 id="PB",
                 sender=BOB,
                 type=EventTypes.PowerLevels,
                 state_key='',
-                content={
+                content={"users": {ALICE: 100, BOB: 50, CHARLIE: 50}},
-                    "users": {
-                        ALICE: 100,
-                        BOB: 50,
-                        CHARLIE: 50,
-                    },
-                },
             ),
             FakeEvent(
                 id="PC",
                 sender=CHARLIE,
                 type=EventTypes.PowerLevels,
                 state_key='',
-                content={
+                content={"users": {ALICE: 100, BOB: 50, CHARLIE: 0}},
-                    "users": {
-                        ALICE: 100,
-                        BOB: 50,
-                        CHARLIE: 0,
-                    },
-                },
             ),
         ]
 
-        edges = [
+        edges = [["END", "PC", "PB", "PA", "START"], ["END", "PA"]]
-            ["END", "PC", "PB", "PA", "START"],
-            ["END", "PA"],
-        ]
 
         expected_state_ids = ["PC"]
 
@@ -295,68 +250,38 @@ class StateTestCase(unittest.TestCase):
     def test_topic_basic(self):
         events = [
             FakeEvent(
-                id="T1",
+                id="T1", sender=ALICE, type=EventTypes.Topic, state_key="", content={}
-                sender=ALICE,
-                type=EventTypes.Topic,
-                state_key="",
-                content={},
             ),
             FakeEvent(
                 id="PA1",
                 sender=ALICE,
                 type=EventTypes.PowerLevels,
                 state_key='',
-                content={
+                content={"users": {ALICE: 100, BOB: 50}},
-                    "users": {
-                        ALICE: 100,
-                        BOB: 50,
-                    },
-                },
             ),
             FakeEvent(
-                id="T2",
+                id="T2", sender=ALICE, type=EventTypes.Topic, state_key="", content={}
-                sender=ALICE,
-                type=EventTypes.Topic,
-                state_key="",
-                content={},
             ),
             FakeEvent(
                 id="PA2",
                 sender=ALICE,
                 type=EventTypes.PowerLevels,
                 state_key='',
-                content={
+                content={"users": {ALICE: 100, BOB: 0}},
-                    "users": {
-                        ALICE: 100,
-                        BOB: 0,
-                    },
-                },
             ),
             FakeEvent(
                 id="PB",
                 sender=BOB,
                 type=EventTypes.PowerLevels,
                 state_key='',
-                content={
+                content={"users": {ALICE: 100, BOB: 50}},
-                    "users": {
-                        ALICE: 100,
-                        BOB: 50,
-                    },
-                },
             ),
             FakeEvent(
-                id="T3",
+                id="T3", sender=BOB, type=EventTypes.Topic, state_key="", content={}
-                sender=BOB,
-                type=EventTypes.Topic,
-                state_key="",
-                content={},
             ),
         ]
 
-        edges = [
+        edges = [["END", "PA2", "T2", "PA1", "T1", "START"], ["END", "T3", "PB", "PA1"]]
-            ["END", "PA2", "T2", "PA1", "T1", "START"],
-            ["END", "T3", "PB", "PA1"],
-        ]
 
         expected_state_ids = ["PA2", "T2"]
 
@@ -365,30 +290,17 @@ class StateTestCase(unittest.TestCase):
     def test_topic_reset(self):
         events = [
             FakeEvent(
-                id="T1",
+                id="T1", sender=ALICE, type=EventTypes.Topic, state_key="", content={}
-                sender=ALICE,
-                type=EventTypes.Topic,
-                state_key="",
-                content={},
             ),
             FakeEvent(
                 id="PA",
                 sender=ALICE,
                 type=EventTypes.PowerLevels,
                 state_key='',
-                content={
+                content={"users": {ALICE: 100, BOB: 50}},
-                    "users": {
-                        ALICE: 100,
-                        BOB: 50,
-                    },
-                },
             ),
             FakeEvent(
-                id="T2",
+                id="T2", sender=BOB, type=EventTypes.Topic, state_key="", content={}
-                sender=BOB,
-                type=EventTypes.Topic,
-                state_key="",
-                content={},
             ),
             FakeEvent(
                 id="MB",
@@ -399,10 +311,7 @@ class StateTestCase(unittest.TestCase):
             ),
         ]
 
-        edges = [
+        edges = [["END", "MB", "T2", "PA", "T1", "START"], ["END", "T1"]]
-            ["END", "MB", "T2", "PA", "T1", "START"],
-            ["END", "T1"],
-        ]
 
         expected_state_ids = ["T1", "MB", "PA"]
 
@@ -411,61 +320,34 @@ class StateTestCase(unittest.TestCase):
     def test_topic(self):
         events = [
             FakeEvent(
-                id="T1",
+                id="T1", sender=ALICE, type=EventTypes.Topic, state_key="", content={}
-                sender=ALICE,
-                type=EventTypes.Topic,
-                state_key="",
-                content={},
             ),
             FakeEvent(
                 id="PA1",
                 sender=ALICE,
                 type=EventTypes.PowerLevels,
                 state_key='',
-                content={
+                content={"users": {ALICE: 100, BOB: 50}},
-                    "users": {
-                        ALICE: 100,
-                        BOB: 50,
-                    },
-                },
             ),
             FakeEvent(
-                id="T2",
+                id="T2", sender=ALICE, type=EventTypes.Topic, state_key="", content={}
-                sender=ALICE,
-                type=EventTypes.Topic,
-                state_key="",
-                content={},
             ),
             FakeEvent(
                 id="PA2",
                 sender=ALICE,
                 type=EventTypes.PowerLevels,
                 state_key='',
-                content={
+                content={"users": {ALICE: 100, BOB: 0}},
-                    "users": {
-                        ALICE: 100,
-                        BOB: 0,
-                    },
-                },
             ),
             FakeEvent(
                 id="PB",
                 sender=BOB,
                 type=EventTypes.PowerLevels,
                 state_key='',
-                content={
+                content={"users": {ALICE: 100, BOB: 50}},
-                    "users": {
-                        ALICE: 100,
-                        BOB: 50,
-                    },
-                },
             ),
             FakeEvent(
-                id="T3",
+                id="T3", sender=BOB, type=EventTypes.Topic, state_key="", content={}
-                sender=BOB,
-                type=EventTypes.Topic,
-                state_key="",
-                content={},
             ),
             FakeEvent(
                 id="MZ1",
@@ -475,11 +357,7 @@ class StateTestCase(unittest.TestCase):
                 content={},
             ),
             FakeEvent(
-                id="T4",
+                id="T4", sender=ALICE, type=EventTypes.Topic, state_key="", content={}
-                sender=ALICE,
-                type=EventTypes.Topic,
-                state_key="",
-                content={},
             ),
         ]
 
@@ -587,13 +465,7 @@ class StateTestCase(unittest.TestCase):
 
 class LexicographicalTestCase(unittest.TestCase):
     def test_simple(self):
-        graph = {
+        graph = {"l": {"o"}, "m": {"n", "o"}, "n": {"o"}, "o": set(), "p": {"o"}}
-            "l": {"o"},
-            "m": {"n", "o"},
-            "n": {"o"},
-            "o": set(),
-            "p": {"o"},
-        }
 
         res = list(lexicographical_topological_sort(graph, key=lambda x: x))
 
@@ -680,7 +552,13 @@ class SimpleParamStateTestCase(unittest.TestCase):
 
         self.expected_combined_state = {
             (e.type, e.state_key): e.event_id
-            for e in [create_event, alice_member, join_rules, bob_member, charlie_member]
+            for e in [
+                create_event,
+                alice_member,
+                join_rules,
+                bob_member,
+                charlie_member,
+            ]
         }
 
     def test_event_map_none(self):
@@ -720,11 +598,7 @@ class TestStateResolutionStore(object):
             Deferred[dict[str, FrozenEvent]]: Dict from event_id to event.
         """
 
-        return {
+        return {eid: self.event_map[eid] for eid in event_ids if eid in self.event_map}
-            eid: self.event_map[eid]
-            for eid in event_ids
-            if eid in self.event_map
-        }
 
     def get_auth_chain(self, event_ids):
         """Gets the full auth chain for a set of events (including rejected

tests/storage/test_background_update.py

@@ -9,9 +9,7 @@ from tests.utils import setup_test_homeserver
 class BackgroundUpdateTestCase(unittest.TestCase):
     @defer.inlineCallbacks
     def setUp(self):
-        hs = yield setup_test_homeserver(
+        hs = yield setup_test_homeserver(self.addCleanup)
-            self.addCleanup
-        )
         self.store = hs.get_datastore()
         self.clock = hs.get_clock()
 

tests/storage/test_base.py

@@ -56,10 +56,7 @@ class SQLBaseStoreTestCase(unittest.TestCase):
         fake_engine = Mock(wraps=engine)
         fake_engine.can_native_upsert = False
         hs = TestHomeServer(
-            "test",
+            "test", db_pool=self.db_pool, config=config, database_engine=fake_engine
-            db_pool=self.db_pool,
-            config=config,
-            database_engine=fake_engine,
         )
 
         self.datastore = SQLBaseStore(None, hs)

tests/storage/test_end_to_end_keys.py

@@ -20,7 +20,6 @@ import tests.utils
 
 
 class EndToEndKeyStoreTestCase(tests.unittest.TestCase):
-
     @defer.inlineCallbacks
     def setUp(self):
         hs = yield tests.utils.setup_test_homeserver(self.addCleanup)

tests/storage/test_monthly_active_users.py

@@ -56,8 +56,7 @@ class MonthlyActiveUsersTestCase(unittest.HomeserverTestCase):
         self.store.register(user_id=user1, token="123", password_hash=None)
         self.store.register(user_id=user2, token="456", password_hash=None)
         self.store.register(
-            user_id=user3, token="789",
+            user_id=user3, token="789", password_hash=None, user_type=UserTypes.SUPPORT
-            password_hash=None, user_type=UserTypes.SUPPORT
         )
         self.pump()
 
@@ -173,9 +172,7 @@ class MonthlyActiveUsersTestCase(unittest.HomeserverTestCase):
     def test_populate_monthly_users_should_update(self):
         self.store.upsert_monthly_active_user = Mock()
 
-        self.store.is_trial_user = Mock(
+        self.store.is_trial_user = Mock(return_value=defer.succeed(False))
-            return_value=defer.succeed(False)
-        )
 
         self.store.user_last_seen_monthly_active = Mock(
             return_value=defer.succeed(None)
@@ -187,13 +184,9 @@ class MonthlyActiveUsersTestCase(unittest.HomeserverTestCase):
     def test_populate_monthly_users_should_not_update(self):
         self.store.upsert_monthly_active_user = Mock()
 
-        self.store.is_trial_user = Mock(
+        self.store.is_trial_user = Mock(return_value=defer.succeed(False))
-            return_value=defer.succeed(False)
-        )
         self.store.user_last_seen_monthly_active = Mock(
-            return_value=defer.succeed(
+            return_value=defer.succeed(self.hs.get_clock().time_msec())
-                self.hs.get_clock().time_msec()
-            )
         )
         self.store.populate_monthly_active_users('user_id')
         self.pump()
@@ -243,7 +236,7 @@ class MonthlyActiveUsersTestCase(unittest.HomeserverTestCase):
             user_id=support_user_id,
             token="123",
             password_hash=None,
-            user_type=UserTypes.SUPPORT
+            user_type=UserTypes.SUPPORT,
         )
 
         self.store.upsert_monthly_active_user(support_user_id)

tests/storage/test_redaction.py

@@ -60,7 +60,7 @@ class RedactionTestCase(unittest.TestCase):
                 "state_key": user.to_string(),
                 "room_id": room.to_string(),
                 "content": content,
-            }
+            },
         )
 
         event, context = yield self.event_creation_handler.create_new_client_event(
@@ -83,7 +83,7 @@ class RedactionTestCase(unittest.TestCase):
                 "state_key": user.to_string(),
                 "room_id": room.to_string(),
                 "content": {"body": body, "msgtype": u"message"},
-            }
+            },
         )
 
         event, context = yield self.event_creation_handler.create_new_client_event(
@@ -105,7 +105,7 @@ class RedactionTestCase(unittest.TestCase):
                 "room_id": room.to_string(),
                 "content": {"reason": reason},
                 "redacts": event_id,
-            }
+            },
         )
 
         event, context = yield self.event_creation_handler.create_new_client_event(

tests/storage/test_registration.py

@@ -116,7 +116,7 @@ class RegistrationStoreTestCase(unittest.TestCase):
             user_id=SUPPORT_USER,
             token="456",
             password_hash=None,
-            user_type=UserTypes.SUPPORT
+            user_type=UserTypes.SUPPORT,
         )
         res = yield self.store.is_support_user(SUPPORT_USER)
         self.assertTrue(res)

tests/storage/test_roommember.py

@@ -58,7 +58,7 @@ class RoomMemberStoreTestCase(unittest.TestCase):
                 "state_key": user.to_string(),
                 "room_id": room.to_string(),
                 "content": {"membership": membership},
-            }
+            },
         )
 
         event, context = yield self.event_creation_handler.create_new_client_event(

tests/storage/test_state.py

@@ -29,7 +29,6 @@ logger = logging.getLogger(__name__)
 
 
 class StateStoreTestCase(tests.unittest.TestCase):
-
     @defer.inlineCallbacks
     def setUp(self):
         hs = yield tests.utils.setup_test_homeserver(self.addCleanup)
@@ -57,7 +56,7 @@ class StateStoreTestCase(tests.unittest.TestCase):
                 "state_key": state_key,
                 "room_id": room.to_string(),
                 "content": content,
-            }
+            },
         )
 
         event, context = yield self.event_creation_handler.create_new_client_event(
@@ -83,15 +82,14 @@ class StateStoreTestCase(tests.unittest.TestCase):
             self.room, self.u_alice, EventTypes.Name, '', {"name": "test room"}
         )
 
-        state_group_map = yield self.store.get_state_groups_ids(self.room, [e2.event_id])
+        state_group_map = yield self.store.get_state_groups_ids(
+            self.room, [e2.event_id]
+        )
         self.assertEqual(len(state_group_map), 1)
         state_map = list(state_group_map.values())[0]
         self.assertDictEqual(
             state_map,
-            {
+            {(EventTypes.Create, ''): e1.event_id, (EventTypes.Name, ''): e2.event_id},
-                (EventTypes.Create, ''): e1.event_id,
-                (EventTypes.Name, ''): e2.event_id,
-            },
         )
 
     @defer.inlineCallbacks
@@ -103,15 +101,11 @@ class StateStoreTestCase(tests.unittest.TestCase):
             self.room, self.u_alice, EventTypes.Name, '', {"name": "test room"}
         )
 
-        state_group_map = yield self.store.get_state_groups(
+        state_group_map = yield self.store.get_state_groups(self.room, [e2.event_id])
-            self.room, [e2.event_id])
         self.assertEqual(len(state_group_map), 1)
         state_list = list(state_group_map.values())[0]
 
-        self.assertEqual(
+        self.assertEqual({ev.event_id for ev in state_list}, {e1.event_id, e2.event_id})
-            {ev.event_id for ev in state_list},
-            {e1.event_id, e2.event_id},
-        )
 
     @defer.inlineCallbacks
     def test_get_state_for_event(self):
@@ -147,9 +141,7 @@ class StateStoreTestCase(tests.unittest.TestCase):
         )
 
         # check we get the full state as of the final event
-        state = yield self.store.get_state_for_event(
+        state = yield self.store.get_state_for_event(e5.event_id)
-            e5.event_id,
-        )
 
         self.assertIsNotNone(e4)
 
@@ -194,7 +186,7 @@ class StateStoreTestCase(tests.unittest.TestCase):
             state_filter=StateFilter(
                 types={EventTypes.Member: {self.u_alice.to_string()}},
                 include_others=True,
-            )
+            ),
         )
 
         self.assertStateMapEqual(
@@ -208,9 +200,9 @@ class StateStoreTestCase(tests.unittest.TestCase):
 
         # check that we can grab everything except members
         state = yield self.store.get_state_for_event(
-            e5.event_id, state_filter=StateFilter(
+            e5.event_id,
-                types={EventTypes.Member: set()},
+            state_filter=StateFilter(
-                include_others=True,
+                types={EventTypes.Member: set()}, include_others=True
             ),
         )
 
@@ -229,10 +221,10 @@ class StateStoreTestCase(tests.unittest.TestCase):
         # test _get_state_for_group_using_cache correctly filters out members
         # with types=[]
         (state_dict, is_all) = yield self.store._get_state_for_group_using_cache(
-            self.store._state_group_cache, group,
+            self.store._state_group_cache,
+            group,
             state_filter=StateFilter(
-                types={EventTypes.Member: set()},
+                types={EventTypes.Member: set()}, include_others=True
-                include_others=True,
             ),
         )
 
@@ -249,8 +241,7 @@ class StateStoreTestCase(tests.unittest.TestCase):
             self.store._state_group_members_cache,
             group,
             state_filter=StateFilter(
-                types={EventTypes.Member: set()},
+                types={EventTypes.Member: set()}, include_others=True
-                include_others=True,
             ),
         )
 
@@ -263,8 +254,7 @@ class StateStoreTestCase(tests.unittest.TestCase):
             self.store._state_group_cache,
             group,
             state_filter=StateFilter(
-                types={EventTypes.Member: None},
+                types={EventTypes.Member: None}, include_others=True
-                include_others=True,
             ),
         )
 
@@ -281,8 +271,7 @@ class StateStoreTestCase(tests.unittest.TestCase):
             self.store._state_group_members_cache,
             group,
             state_filter=StateFilter(
-                types={EventTypes.Member: None},
+                types={EventTypes.Member: None}, include_others=True
-                include_others=True,
             ),
         )
 
@@ -302,8 +291,7 @@ class StateStoreTestCase(tests.unittest.TestCase):
             self.store._state_group_cache,
             group,
             state_filter=StateFilter(
-                types={EventTypes.Member: {e5.state_key}},
+                types={EventTypes.Member: {e5.state_key}}, include_others=True
-                include_others=True,
             ),
         )
 
@@ -320,8 +308,7 @@ class StateStoreTestCase(tests.unittest.TestCase):
             self.store._state_group_members_cache,
             group,
             state_filter=StateFilter(
-                types={EventTypes.Member: {e5.state_key}},
+                types={EventTypes.Member: {e5.state_key}}, include_others=True
-                include_others=True,
             ),
         )
 
@@ -334,8 +321,7 @@ class StateStoreTestCase(tests.unittest.TestCase):
             self.store._state_group_members_cache,
             group,
             state_filter=StateFilter(
-                types={EventTypes.Member: {e5.state_key}},
+                types={EventTypes.Member: {e5.state_key}}, include_others=False
-                include_others=False,
             ),
         )
 
@@ -384,10 +370,10 @@ class StateStoreTestCase(tests.unittest.TestCase):
         # with types=[]
         room_id = self.room.to_string()
         (state_dict, is_all) = yield self.store._get_state_for_group_using_cache(
-            self.store._state_group_cache, group,
+            self.store._state_group_cache,
+            group,
             state_filter=StateFilter(
-                types={EventTypes.Member: set()},
+                types={EventTypes.Member: set()}, include_others=True
-                include_others=True,
             ),
         )
 
@@ -399,8 +385,7 @@ class StateStoreTestCase(tests.unittest.TestCase):
             self.store._state_group_members_cache,
             group,
             state_filter=StateFilter(
-                types={EventTypes.Member: set()},
+                types={EventTypes.Member: set()}, include_others=True
-                include_others=True,
             ),
         )
 
@@ -413,8 +398,7 @@ class StateStoreTestCase(tests.unittest.TestCase):
             self.store._state_group_cache,
             group,
             state_filter=StateFilter(
-                types={EventTypes.Member: None},
+                types={EventTypes.Member: None}, include_others=True
-                include_others=True,
             ),
         )
 
@@ -425,8 +409,7 @@ class StateStoreTestCase(tests.unittest.TestCase):
             self.store._state_group_members_cache,
             group,
             state_filter=StateFilter(
-                types={EventTypes.Member: None},
+                types={EventTypes.Member: None}, include_others=True
-                include_others=True,
             ),
         )
 
@@ -445,8 +428,7 @@ class StateStoreTestCase(tests.unittest.TestCase):
             self.store._state_group_cache,
             group,
             state_filter=StateFilter(
-                types={EventTypes.Member: {e5.state_key}},
+                types={EventTypes.Member: {e5.state_key}}, include_others=True
-                include_others=True,
             ),
         )
 
@@ -457,8 +439,7 @@ class StateStoreTestCase(tests.unittest.TestCase):
             self.store._state_group_members_cache,
             group,
             state_filter=StateFilter(
-                types={EventTypes.Member: {e5.state_key}},
+                types={EventTypes.Member: {e5.state_key}}, include_others=True
-                include_others=True,
             ),
         )
 
@@ -471,8 +452,7 @@ class StateStoreTestCase(tests.unittest.TestCase):
             self.store._state_group_cache,
             group,
             state_filter=StateFilter(
-                types={EventTypes.Member: {e5.state_key}},
+                types={EventTypes.Member: {e5.state_key}}, include_others=False
-                include_others=False,
             ),
         )
 
@@ -483,8 +463,7 @@ class StateStoreTestCase(tests.unittest.TestCase):
             self.store._state_group_members_cache,
             group,
             state_filter=StateFilter(
-                types={EventTypes.Member: {e5.state_key}},
+                types={EventTypes.Member: {e5.state_key}}, include_others=False
-                include_others=False,
             ),
         )
 

tests/storage/test_user_directory.py

@@ -36,9 +36,7 @@ class UserDirectoryStoreTestCase(unittest.TestCase):
         yield self.store.update_profile_in_user_dir(ALICE, "alice", None)
         yield self.store.update_profile_in_user_dir(BOB, "bob", None)
         yield self.store.update_profile_in_user_dir(BOBBY, "bobby", None)
-        yield self.store.add_users_in_public_rooms(
+        yield self.store.add_users_in_public_rooms("!room:id", (ALICE, BOB))
-            "!room:id", (ALICE, BOB)
-        )
 
     @defer.inlineCallbacks
     def test_search_user_dir(self):

tests/test_event_auth.py

@@ -37,7 +37,9 @@ class EventAuthTestCase(unittest.TestCase):
 
         # creator should be able to send state
         event_auth.check(
-            RoomVersions.V1.identifier, _random_state_event(creator), auth_events,
+            RoomVersions.V1.identifier,
+            _random_state_event(creator),
+            auth_events,
             do_sig_check=False,
         )
 
@@ -82,7 +84,9 @@ class EventAuthTestCase(unittest.TestCase):
 
         # king should be able to send state
         event_auth.check(
-            RoomVersions.V1.identifier, _random_state_event(king), auth_events,
+            RoomVersions.V1.identifier,
+            _random_state_event(king),
+            auth_events,
             do_sig_check=False,
         )
 

tests/test_federation.py

@@ -1,4 +1,3 @@
-
 from mock import Mock
 
 from twisted.internet.defer import maybeDeferred, succeed

tests/test_mau.py

@@ -33,9 +33,7 @@ class TestMauLimit(unittest.HomeserverTestCase):
     def make_homeserver(self, reactor, clock):
 
         self.hs = self.setup_test_homeserver(
-            "red",
+            "red", http_client=None, federation_client=Mock()
-            http_client=None,
-            federation_client=Mock(),
         )
 
         self.store = self.hs.get_datastore()
@@ -210,9 +208,7 @@ class TestMauLimit(unittest.HomeserverTestCase):
         return access_token
 
     def do_sync_for_user(self, token):
-        request, channel = self.make_request(
+        request, channel = self.make_request("GET", "/sync", access_token=token)
-            "GET", "/sync", access_token=token
-        )
         self.render(request)
 
         if channel.code != 200:

tests/test_metrics.py

@@ -44,9 +44,7 @@ def get_sample_labels_value(sample):
 class TestMauLimit(unittest.TestCase):
     def test_basic(self):
         gauge = InFlightGauge(
-            "test1", "",
+            "test1", "", labels=["test_label"], sub_metrics=["foo", "bar"]
-            labels=["test_label"],
-            sub_metrics=["foo", "bar"],
         )
 
         def handle1(metrics):
@@ -59,37 +57,49 @@ class TestMauLimit(unittest.TestCase):
 
         gauge.register(("key1",), handle1)
 
-        self.assert_dict({
+        self.assert_dict(
-            "test1_total": {("key1",): 1},
+            {
-            "test1_foo": {("key1",): 2},
+                "test1_total": {("key1",): 1},
-            "test1_bar": {("key1",): 5},
+                "test1_foo": {("key1",): 2},
-        }, self.get_metrics_from_gauge(gauge))
+                "test1_bar": {("key1",): 5},
+            },
+            self.get_metrics_from_gauge(gauge),
+        )
 
         gauge.unregister(("key1",), handle1)
 
-        self.assert_dict({
+        self.assert_dict(
-            "test1_total": {("key1",): 0},
+            {
-            "test1_foo": {("key1",): 0},
+                "test1_total": {("key1",): 0},
-            "test1_bar": {("key1",): 0},
+                "test1_foo": {("key1",): 0},
-        }, self.get_metrics_from_gauge(gauge))
+                "test1_bar": {("key1",): 0},
+            },
+            self.get_metrics_from_gauge(gauge),
+        )
 
         gauge.register(("key1",), handle1)
         gauge.register(("key2",), handle2)
 
-        self.assert_dict({
+        self.assert_dict(
-            "test1_total": {("key1",): 1, ("key2",): 1},
+            {
-            "test1_foo": {("key1",): 2, ("key2",): 3},
+                "test1_total": {("key1",): 1, ("key2",): 1},
-            "test1_bar": {("key1",): 5, ("key2",): 7},
+                "test1_foo": {("key1",): 2, ("key2",): 3},
-        }, self.get_metrics_from_gauge(gauge))
+                "test1_bar": {("key1",): 5, ("key2",): 7},
+            },
+            self.get_metrics_from_gauge(gauge),
+        )
 
         gauge.unregister(("key2",), handle2)
         gauge.register(("key1",), handle2)
 
-        self.assert_dict({
+        self.assert_dict(
-            "test1_total": {("key1",): 2, ("key2",): 0},
+            {
-            "test1_foo": {("key1",): 5, ("key2",): 0},
+                "test1_total": {("key1",): 2, ("key2",): 0},
-            "test1_bar": {("key1",): 7, ("key2",): 0},
+                "test1_foo": {("key1",): 5, ("key2",): 0},
-        }, self.get_metrics_from_gauge(gauge))
+                "test1_bar": {("key1",): 7, ("key2",): 0},
+            },
+            self.get_metrics_from_gauge(gauge),
+        )
 
     def get_metrics_from_gauge(self, gauge):
         results = {}

tests/test_terms_auth.py

@@ -69,10 +69,10 @@ class TermsTestCase(unittest.HomeserverTestCase):
                             "name": "My Cool Privacy Policy",
                             "url": "https://example.org/_matrix/consent?v=1.0",
                         },
-                        "version": "1.0"
+                        "version": "1.0",
-                    },
+                    }
-                },
+                }
-            },
+            }
         }
         self.assertIsInstance(channel.json_body["params"], dict)
         self.assertDictContainsSubset(channel.json_body["params"], expected_params)

tests/test_types.py

@@ -94,8 +94,7 @@ class MapUsernameTestCase(unittest.TestCase):
 
     def testSymbols(self):
         self.assertEqual(
-            map_username_to_mxid_localpart("test=$?_1234"),
+            map_username_to_mxid_localpart("test=$?_1234"), "test=3d=24=3f_1234"
-            "test=3d=24=3f_1234",
         )
 
     def testLeadingUnderscore(self):
@@ -105,6 +104,5 @@ class MapUsernameTestCase(unittest.TestCase):
         # this should work with either a unicode or a bytes
         self.assertEqual(map_username_to_mxid_localpart(u'têst'), "t=c3=aast")
         self.assertEqual(
-            map_username_to_mxid_localpart(u'têst'.encode('utf-8')),
+            map_username_to_mxid_localpart(u'têst'.encode('utf-8')), "t=c3=aast"
-            "t=c3=aast",
         )

tests/test_utils/logging_setup.py

@@ -22,6 +22,7 @@ from synapse.util.logcontext import LoggingContextFilter
 
 class ToTwistedHandler(logging.Handler):
     """logging handler which sends the logs to the twisted log"""
+
     tx_log = twisted.logger.Logger()
 
     def emit(self, record):
@@ -41,7 +42,8 @@ def setup_logging():
     root_logger = logging.getLogger()
 
     log_format = (
-        "%(asctime)s - %(name)s - %(lineno)d - %(levelname)s - %(request)s - %(message)s"
+        "%(asctime)s - %(name)s - %(lineno)d - "
+        "%(levelname)s - %(request)s - %(message)s"
     )
 
     handler = ToTwistedHandler()

tests/test_visibility.py

@@ -132,7 +132,7 @@ class FilterEventsForServerTestCase(tests.unittest.TestCase):
                 "state_key": "",
                 "room_id": TEST_ROOM_ID,
                 "content": content,
-            }
+            },
         )
 
         event, context = yield self.event_creation_handler.create_new_client_event(
@@ -153,7 +153,7 @@ class FilterEventsForServerTestCase(tests.unittest.TestCase):
                 "state_key": user_id,
                 "room_id": TEST_ROOM_ID,
                 "content": content,
-            }
+            },
         )
 
         event, context = yield self.event_creation_handler.create_new_client_event(
@@ -174,7 +174,7 @@ class FilterEventsForServerTestCase(tests.unittest.TestCase):
                 "sender": user_id,
                 "room_id": TEST_ROOM_ID,
                 "content": content,
-            }
+            },
         )
 
         event, context = yield self.event_creation_handler.create_new_client_event(

tests/unittest.py

@@ -84,9 +84,8 @@ class TestCase(unittest.TestCase):
             # all future bets are off.
             if LoggingContext.current_context() is not LoggingContext.sentinel:
                 self.fail(
-                    "Test starting with non-sentinel logging context %s" % (
+                    "Test starting with non-sentinel logging context %s"
-                        LoggingContext.current_context(),
+                    % (LoggingContext.current_context(),)
-                    )
                 )
 
             old_level = logging.getLogger().level
@@ -300,7 +299,13 @@ class HomeserverTestCase(TestCase):
             content = json.dumps(content).encode('utf8')
 
         return make_request(
-            self.reactor, method, path, content, access_token, request, shorthand,
+            self.reactor,
+            method,
+            path,
+            content,
+            access_token,
+            request,
+            shorthand,
             federation_auth_origin,
         )
 

tests/util/test_async_utils.py

@@ -42,10 +42,10 @@ class TimeoutDeferredTest(TestCase):
         self.assertNoResult(timing_out_d)
         self.assertFalse(cancelled[0], "deferred was cancelled prematurely")
 
-        self.clock.pump((1.0, ))
+        self.clock.pump((1.0,))
 
         self.assertTrue(cancelled[0], "deferred was not cancelled by timeout")
-        self.failureResultOf(timing_out_d, defer.TimeoutError, )
+        self.failureResultOf(timing_out_d, defer.TimeoutError)
 
     def test_times_out_when_canceller_throws(self):
         """Test that we have successfully worked around
@@ -59,9 +59,9 @@ class TimeoutDeferredTest(TestCase):
 
         self.assertNoResult(timing_out_d)
 
-        self.clock.pump((1.0, ))
+        self.clock.pump((1.0,))
 
-        self.failureResultOf(timing_out_d, defer.TimeoutError, )
+        self.failureResultOf(timing_out_d, defer.TimeoutError)
 
     def test_logcontext_is_preserved_on_cancellation(self):
         blocking_was_cancelled = [False]
@@ -80,10 +80,10 @@ class TimeoutDeferredTest(TestCase):
             # the errbacks should be run in the test logcontext
             def errback(res, deferred_name):
                 self.assertIs(
-                    LoggingContext.current_context(), context_one,
+                    LoggingContext.current_context(),
-                    "errback %s run in unexpected logcontext %s" % (
+                    context_one,
-                        deferred_name, LoggingContext.current_context(),
+                    "errback %s run in unexpected logcontext %s"
-                    )
+                    % (deferred_name, LoggingContext.current_context()),
                 )
                 return res
 
@@ -94,11 +94,10 @@ class TimeoutDeferredTest(TestCase):
             self.assertIs(LoggingContext.current_context(), LoggingContext.sentinel)
             timing_out_d.addErrback(errback, "timingout")
 
-            self.clock.pump((1.0, ))
+            self.clock.pump((1.0,))
 
             self.assertTrue(
-                blocking_was_cancelled[0],
+                blocking_was_cancelled[0], "non-completing deferred was not cancelled"
-                "non-completing deferred was not cancelled",
             )
-            self.failureResultOf(timing_out_d, defer.TimeoutError, )
+            self.failureResultOf(timing_out_d, defer.TimeoutError)
             self.assertIs(LoggingContext.current_context(), context_one)

tests/utils.py

@@ -68,7 +68,9 @@ def setupdb():
 
         # connect to postgres to create the base database.
         db_conn = db_engine.module.connect(
-            user=POSTGRES_USER, host=POSTGRES_HOST, password=POSTGRES_PASSWORD,
+            user=POSTGRES_USER,
+            host=POSTGRES_HOST,
+            password=POSTGRES_PASSWORD,
             dbname=POSTGRES_DBNAME_FOR_INITIAL_CREATE,
         )
         db_conn.autocommit = True
@@ -94,7 +96,9 @@ def setupdb():
 
         def _cleanup():
             db_conn = db_engine.module.connect(
-                user=POSTGRES_USER, host=POSTGRES_HOST, password=POSTGRES_PASSWORD,
+                user=POSTGRES_USER,
+                host=POSTGRES_HOST,
+                password=POSTGRES_PASSWORD,
                 dbname=POSTGRES_DBNAME_FOR_INITIAL_CREATE,
             )
             db_conn.autocommit = True
@@ -114,7 +118,6 @@ def default_config(name):
         "server_name": name,
         "media_store_path": "media",
         "uploads_path": "uploads",
-
         # the test signing key is just an arbitrary ed25519 key to keep the config
         # parser happy
         "signing_key": "ed25519 a_lPym qvioDNmfExFBRPgdTU+wtFYKq4JfwFRv7sYVgWvmgJg",