diff --git a/tests/api/test_auth.py b/tests/api/test_auth.py
index d0d36f96fa..d4e75b5b2e 100644
--- a/tests/api/test_auth.py
+++ b/tests/api/test_auth.py
@@ -172,7 +172,7 @@ class AuthTestCase(unittest.TestCase):
request.requestHeaders.getRawHeaders = mock_getRawHeaders()
requester = yield self.auth.get_user_by_req(request)
self.assertEquals(
- requester.user.to_string(), masquerading_user_id.decode('utf8')
+ requester.user.to_string(), masquerading_user_id.decode("utf8")
)
def test_get_user_by_req_appservice_valid_token_bad_user_id(self):
@@ -264,7 +264,7 @@ class AuthTestCase(unittest.TestCase):
# check the token works
request = Mock(args={})
- request.args[b"access_token"] = [token.encode('ascii')]
+ request.args[b"access_token"] = [token.encode("ascii")]
request.requestHeaders.getRawHeaders = mock_getRawHeaders()
requester = yield self.auth.get_user_by_req(request, allow_guest=True)
self.assertEqual(UserID.from_string(USER_ID), requester.user)
@@ -277,7 +277,7 @@ class AuthTestCase(unittest.TestCase):
# the token should *not* work now
request = Mock(args={})
- request.args[b"access_token"] = [guest_tok.encode('ascii')]
+ request.args[b"access_token"] = [guest_tok.encode("ascii")]
request.requestHeaders.getRawHeaders = mock_getRawHeaders()
with self.assertRaises(AuthError) as cm:
@@ -321,11 +321,11 @@ class AuthTestCase(unittest.TestCase):
self.hs.config.limit_usage_by_mau = True
self.hs.config.max_mau_value = 1
self.store.get_monthly_active_count = lambda: defer.succeed(2)
- threepid = {'medium': 'email', 'address': 'reserved@server.com'}
- unknown_threepid = {'medium': 'email', 'address': 'unreserved@server.com'}
+ threepid = {"medium": "email", "address": "reserved@server.com"}
+ unknown_threepid = {"medium": "email", "address": "unreserved@server.com"}
self.hs.config.mau_limits_reserved_threepids = [threepid]
- yield self.store.register(user_id='user1', token="123", password_hash=None)
+ yield self.store.register(user_id="user1", token="123", password_hash=None)
with self.assertRaises(ResourceLimitError):
yield self.auth.check_auth_blocking()
diff --git a/tests/config/test_server.py b/tests/config/test_server.py
index de64965a60..1ca5ea54ca 100644
--- a/tests/config/test_server.py
+++ b/tests/config/test_server.py
@@ -20,10 +20,10 @@ 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'}
- user3 = {'medium': 'email', 'address': 'user3@example.com'}
- user1_msisdn = {'medium': 'msisdn', 'address': '447700000000'}
+ user1 = {"medium": "email", "address": "user1@example.com"}
+ user2 = {"medium": "email", "address": "user2@example.com"}
+ user3 = {"medium": "email", "address": "user3@example.com"}
+ user1_msisdn = {"medium": "msisdn", "address": "447700000000"}
config = [user1, user2]
self.assertTrue(is_threepid_reserved(config, user1))
diff --git a/tests/config/test_tls.py b/tests/config/test_tls.py
index 40ca428778..0cbbf4e885 100644
--- a/tests/config/test_tls.py
+++ b/tests/config/test_tls.py
@@ -32,7 +32,7 @@ class TLSConfigTests(TestCase):
"""
config_dir = self.mktemp()
os.mkdir(config_dir)
- with open(os.path.join(config_dir, "cert.pem"), 'w') as f:
+ with open(os.path.join(config_dir, "cert.pem"), "w") as f:
f.write(
"""-----BEGIN CERTIFICATE-----
MIID6DCCAtACAws9CjANBgkqhkiG9w0BAQUFADCBtzELMAkGA1UEBhMCVFIxDzAN
diff --git a/tests/crypto/test_event_signing.py b/tests/crypto/test_event_signing.py
index 71aa731439..126e176004 100644
--- a/tests/crypto/test_event_signing.py
+++ b/tests/crypto/test_event_signing.py
@@ -41,25 +41,25 @@ class EventSigningTestCase(unittest.TestCase):
def test_sign_minimal(self):
event_dict = {
- 'event_id': "$0:domain",
- 'origin': "domain",
- 'origin_server_ts': 1000000,
- 'signatures': {},
- 'type': "X",
- 'unsigned': {'age_ts': 1000000},
+ "event_id": "$0:domain",
+ "origin": "domain",
+ "origin_server_ts": 1000000,
+ "signatures": {},
+ "type": "X",
+ "unsigned": {"age_ts": 1000000},
}
add_hashes_and_signatures(event_dict, HOSTNAME, self.signing_key)
event = FrozenEvent(event_dict)
- self.assertTrue(hasattr(event, 'hashes'))
- self.assertIn('sha256', event.hashes)
+ self.assertTrue(hasattr(event, "hashes"))
+ self.assertIn("sha256", event.hashes)
self.assertEquals(
- event.hashes['sha256'], "6tJjLpXtggfke8UxFhAKg82QVkJzvKOVOOSjUDK4ZSI"
+ event.hashes["sha256"], "6tJjLpXtggfke8UxFhAKg82QVkJzvKOVOOSjUDK4ZSI"
)
- self.assertTrue(hasattr(event, 'signatures'))
+ self.assertTrue(hasattr(event, "signatures"))
self.assertIn(HOSTNAME, event.signatures)
self.assertIn(KEY_NAME, event.signatures["domain"])
self.assertEquals(
@@ -70,28 +70,28 @@ class EventSigningTestCase(unittest.TestCase):
def test_sign_message(self):
event_dict = {
- 'content': {'body': "Here is the message content"},
- 'event_id': "$0:domain",
- 'origin': "domain",
- 'origin_server_ts': 1000000,
- 'type': "m.room.message",
- 'room_id': "!r:domain",
- 'sender': "@u:domain",
- 'signatures': {},
- 'unsigned': {'age_ts': 1000000},
+ "content": {"body": "Here is the message content"},
+ "event_id": "$0:domain",
+ "origin": "domain",
+ "origin_server_ts": 1000000,
+ "type": "m.room.message",
+ "room_id": "!r:domain",
+ "sender": "@u:domain",
+ "signatures": {},
+ "unsigned": {"age_ts": 1000000},
}
add_hashes_and_signatures(event_dict, HOSTNAME, self.signing_key)
event = FrozenEvent(event_dict)
- self.assertTrue(hasattr(event, 'hashes'))
- self.assertIn('sha256', event.hashes)
+ self.assertTrue(hasattr(event, "hashes"))
+ self.assertIn("sha256", event.hashes)
self.assertEquals(
- event.hashes['sha256'], "onLKD1bGljeBWQhWZ1kaP9SorVmRQNdN5aM2JYU2n/g"
+ event.hashes["sha256"], "onLKD1bGljeBWQhWZ1kaP9SorVmRQNdN5aM2JYU2n/g"
)
- self.assertTrue(hasattr(event, 'signatures'))
+ self.assertTrue(hasattr(event, "signatures"))
self.assertIn(HOSTNAME, event.signatures)
self.assertIn(KEY_NAME, event.signatures["domain"])
self.assertEquals(
diff --git a/tests/events/test_utils.py b/tests/events/test_utils.py
index d0cc492deb..9e3d4d0f47 100644
--- a/tests/events/test_utils.py
+++ b/tests/events/test_utils.py
@@ -37,88 +37,88 @@ class PruneEventTestCase(unittest.TestCase):
def test_minimal(self):
self.run_test(
- {'type': 'A', 'event_id': '$test:domain'},
+ {"type": "A", "event_id": "$test:domain"},
{
- 'type': 'A',
- 'event_id': '$test:domain',
- 'content': {},
- 'signatures': {},
- 'unsigned': {},
+ "type": "A",
+ "event_id": "$test:domain",
+ "content": {},
+ "signatures": {},
+ "unsigned": {},
},
)
def test_basic_keys(self):
self.run_test(
{
- 'type': 'A',
- 'room_id': '!1:domain',
- 'sender': '@2:domain',
- 'event_id': '$3:domain',
- 'origin': 'domain',
+ "type": "A",
+ "room_id": "!1:domain",
+ "sender": "@2:domain",
+ "event_id": "$3:domain",
+ "origin": "domain",
},
{
- 'type': 'A',
- 'room_id': '!1:domain',
- 'sender': '@2:domain',
- 'event_id': '$3:domain',
- 'origin': 'domain',
- 'content': {},
- 'signatures': {},
- 'unsigned': {},
+ "type": "A",
+ "room_id": "!1:domain",
+ "sender": "@2:domain",
+ "event_id": "$3:domain",
+ "origin": "domain",
+ "content": {},
+ "signatures": {},
+ "unsigned": {},
},
)
def test_unsigned_age_ts(self):
self.run_test(
- {'type': 'B', 'event_id': '$test:domain', 'unsigned': {'age_ts': 20}},
+ {"type": "B", "event_id": "$test:domain", "unsigned": {"age_ts": 20}},
{
- 'type': 'B',
- 'event_id': '$test:domain',
- 'content': {},
- 'signatures': {},
- 'unsigned': {'age_ts': 20},
+ "type": "B",
+ "event_id": "$test:domain",
+ "content": {},
+ "signatures": {},
+ "unsigned": {"age_ts": 20},
},
)
self.run_test(
{
- 'type': 'B',
- 'event_id': '$test:domain',
- 'unsigned': {'other_key': 'here'},
+ "type": "B",
+ "event_id": "$test:domain",
+ "unsigned": {"other_key": "here"},
},
{
- 'type': 'B',
- 'event_id': '$test:domain',
- 'content': {},
- 'signatures': {},
- 'unsigned': {},
+ "type": "B",
+ "event_id": "$test:domain",
+ "content": {},
+ "signatures": {},
+ "unsigned": {},
},
)
def test_content(self):
self.run_test(
- {'type': 'C', 'event_id': '$test:domain', 'content': {'things': 'here'}},
+ {"type": "C", "event_id": "$test:domain", "content": {"things": "here"}},
{
- 'type': 'C',
- 'event_id': '$test:domain',
- 'content': {},
- 'signatures': {},
- 'unsigned': {},
+ "type": "C",
+ "event_id": "$test:domain",
+ "content": {},
+ "signatures": {},
+ "unsigned": {},
},
)
self.run_test(
{
- 'type': 'm.room.create',
- 'event_id': '$test:domain',
- 'content': {'creator': '@2:domain', 'other_field': 'here'},
+ "type": "m.room.create",
+ "event_id": "$test:domain",
+ "content": {"creator": "@2:domain", "other_field": "here"},
},
{
- 'type': 'm.room.create',
- 'event_id': '$test:domain',
- 'content': {'creator': '@2:domain'},
- 'signatures': {},
- 'unsigned': {},
+ "type": "m.room.create",
+ "event_id": "$test:domain",
+ "content": {"creator": "@2:domain"},
+ "signatures": {},
+ "unsigned": {},
},
)
diff --git a/tests/federation/test_complexity.py b/tests/federation/test_complexity.py
index 1e3e5aec66..a5b03005d7 100644
--- a/tests/federation/test_complexity.py
+++ b/tests/federation/test_complexity.py
@@ -32,7 +32,7 @@ class RoomComplexityTests(unittest.HomeserverTestCase):
login.register_servlets,
]
- def default_config(self, name='test'):
+ def default_config(self, name="test"):
config = super(RoomComplexityTests, self).default_config(name=name)
config["limit_large_remote_room_joins"] = True
config["limit_large_remote_room_complexity"] = 0.05
diff --git a/tests/federation/test_federation_sender.py b/tests/federation/test_federation_sender.py
index 7bb106b5f7..cce8d8c6de 100644
--- a/tests/federation/test_federation_sender.py
+++ b/tests/federation/test_federation_sender.py
@@ -51,16 +51,16 @@ class FederationSenderTestCases(HomeserverTestCase):
json_cb = mock_send_transaction.call_args[0][1]
data = json_cb()
self.assertEqual(
- data['edus'],
+ data["edus"],
[
{
- 'edu_type': 'm.receipt',
- 'content': {
- 'room_id': {
- 'm.read': {
- 'user_id': {
- 'event_ids': ['event_id'],
- 'data': {'ts': 1234},
+ "edu_type": "m.receipt",
+ "content": {
+ "room_id": {
+ "m.read": {
+ "user_id": {
+ "event_ids": ["event_id"],
+ "data": {"ts": 1234},
}
}
}
@@ -93,16 +93,16 @@ class FederationSenderTestCases(HomeserverTestCase):
json_cb = mock_send_transaction.call_args[0][1]
data = json_cb()
self.assertEqual(
- data['edus'],
+ data["edus"],
[
{
- 'edu_type': 'm.receipt',
- 'content': {
- 'room_id': {
- 'm.read': {
- 'user_id': {
- 'event_ids': ['event_id'],
- 'data': {'ts': 1234},
+ "edu_type": "m.receipt",
+ "content": {
+ "room_id": {
+ "m.read": {
+ "user_id": {
+ "event_ids": ["event_id"],
+ "data": {"ts": 1234},
}
}
}
@@ -128,16 +128,16 @@ class FederationSenderTestCases(HomeserverTestCase):
json_cb = mock_send_transaction.call_args[0][1]
data = json_cb()
self.assertEqual(
- data['edus'],
+ data["edus"],
[
{
- 'edu_type': 'm.receipt',
- 'content': {
- 'room_id': {
- 'm.read': {
- 'user_id': {
- 'event_ids': ['other_id'],
- 'data': {'ts': 1234},
+ "edu_type": "m.receipt",
+ "content": {
+ "room_id": {
+ "m.read": {
+ "user_id": {
+ "event_ids": ["other_id"],
+ "data": {"ts": 1234},
}
}
}
diff --git a/tests/handlers/test_auth.py b/tests/handlers/test_auth.py
index 1e39fe0ec2..b204a0700d 100644
--- a/tests/handlers/test_auth.py
+++ b/tests/handlers/test_auth.py
@@ -117,7 +117,7 @@ class AuthTestCase(unittest.TestCase):
def test_mau_limits_disabled(self):
self.hs.config.limit_usage_by_mau = False
# Ensure does not throw exception
- yield self.auth_handler.get_access_token_for_user_id('user_a')
+ yield self.auth_handler.get_access_token_for_user_id("user_a")
yield self.auth_handler.validate_short_term_login_token_and_get_user_id(
self._get_macaroon().serialize()
@@ -131,7 +131,7 @@ class AuthTestCase(unittest.TestCase):
)
with self.assertRaises(ResourceLimitError):
- yield self.auth_handler.get_access_token_for_user_id('user_a')
+ yield self.auth_handler.get_access_token_for_user_id("user_a")
self.hs.get_datastore().get_monthly_active_count = Mock(
return_value=defer.succeed(self.large_number_of_users)
@@ -150,7 +150,7 @@ class AuthTestCase(unittest.TestCase):
return_value=defer.succeed(self.hs.config.max_mau_value)
)
with self.assertRaises(ResourceLimitError):
- yield self.auth_handler.get_access_token_for_user_id('user_a')
+ yield self.auth_handler.get_access_token_for_user_id("user_a")
self.hs.get_datastore().get_monthly_active_count = Mock(
return_value=defer.succeed(self.hs.config.max_mau_value)
@@ -166,7 +166,7 @@ class AuthTestCase(unittest.TestCase):
self.hs.get_datastore().get_monthly_active_count = Mock(
return_value=defer.succeed(self.hs.config.max_mau_value)
)
- yield self.auth_handler.get_access_token_for_user_id('user_a')
+ yield self.auth_handler.get_access_token_for_user_id("user_a")
self.hs.get_datastore().user_last_seen_monthly_active = Mock(
return_value=defer.succeed(self.hs.get_clock().time_msec())
)
@@ -185,7 +185,7 @@ class AuthTestCase(unittest.TestCase):
return_value=defer.succeed(self.small_number_of_users)
)
# Ensure does not raise exception
- yield self.auth_handler.get_access_token_for_user_id('user_a')
+ yield self.auth_handler.get_access_token_for_user_id("user_a")
self.hs.get_datastore().get_monthly_active_count = Mock(
return_value=defer.succeed(self.small_number_of_users)
diff --git a/tests/handlers/test_directory.py b/tests/handlers/test_directory.py
index 917548bb31..91c7a17070 100644
--- a/tests/handlers/test_directory.py
+++ b/tests/handlers/test_directory.py
@@ -132,7 +132,7 @@ class TestCreateAliasACL(unittest.HomeserverTestCase):
request, channel = self.make_request(
"PUT",
b"directory/room/%23test%3Atest",
- ('{"room_id":"%s"}' % (room_id,)).encode('ascii'),
+ ('{"room_id":"%s"}' % (room_id,)).encode("ascii"),
)
self.render(request)
self.assertEquals(403, channel.code, channel.result)
@@ -143,7 +143,7 @@ class TestCreateAliasACL(unittest.HomeserverTestCase):
request, channel = self.make_request(
"PUT",
b"directory/room/%23unofficial_test%3Atest",
- ('{"room_id":"%s"}' % (room_id,)).encode('ascii'),
+ ('{"room_id":"%s"}' % (room_id,)).encode("ascii"),
)
self.render(request)
self.assertEquals(200, channel.code, channel.result)
@@ -158,7 +158,7 @@ class TestRoomListSearchDisabled(unittest.HomeserverTestCase):
room_id = self.helper.create_room_as(self.user_id)
request, channel = self.make_request(
- "PUT", b"directory/list/room/%s" % (room_id.encode('ascii'),), b'{}'
+ "PUT", b"directory/list/room/%s" % (room_id.encode("ascii"),), b"{}"
)
self.render(request)
self.assertEquals(200, channel.code, channel.result)
@@ -190,7 +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", b"directory/list/room/%s" % (room_id.encode('ascii'),), b'{}'
+ "PUT", b"directory/list/room/%s" % (room_id.encode("ascii"),), b"{}"
)
self.render(request)
self.assertEquals(403, channel.code, channel.result)
diff --git a/tests/handlers/test_e2e_room_keys.py b/tests/handlers/test_e2e_room_keys.py
index 2e72a1dd23..c4503c1611 100644
--- a/tests/handlers/test_e2e_room_keys.py
+++ b/tests/handlers/test_e2e_room_keys.py
@@ -395,37 +395,37 @@ class E2eRoomKeysHandlerTestCase(unittest.TestCase):
yield self.handler.upload_room_keys(self.local_user, version, room_keys)
new_room_keys = copy.deepcopy(room_keys)
- new_room_key = new_room_keys['rooms']['!abc:matrix.org']['sessions']['c0ff33']
+ new_room_key = new_room_keys["rooms"]["!abc:matrix.org"]["sessions"]["c0ff33"]
# test that increasing the message_index doesn't replace the existing session
- new_room_key['first_message_index'] = 2
- new_room_key['session_data'] = 'new'
+ new_room_key["first_message_index"] = 2
+ new_room_key["session_data"] = "new"
yield self.handler.upload_room_keys(self.local_user, version, new_room_keys)
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"],
"SSBBTSBBIEZJU0gK",
)
# test that marking the session as verified however /does/ replace it
- new_room_key['is_verified'] = True
+ new_room_key["is_verified"] = True
yield self.handler.upload_room_keys(self.local_user, version, new_room_keys)
res = yield self.handler.get_room_keys(self.local_user, version)
self.assertEqual(
- res['rooms']['!abc:matrix.org']['sessions']['c0ff33']['session_data'], "new"
+ res["rooms"]["!abc:matrix.org"]["sessions"]["c0ff33"]["session_data"], "new"
)
# test that a session with a higher forwarded_count doesn't replace one
# with a lower forwarding count
- new_room_key['forwarded_count'] = 2
- new_room_key['session_data'] = 'other'
+ new_room_key["forwarded_count"] = 2
+ new_room_key["session_data"] = "other"
yield self.handler.upload_room_keys(self.local_user, version, new_room_keys)
res = yield self.handler.get_room_keys(self.local_user, version)
self.assertEqual(
- res['rooms']['!abc:matrix.org']['sessions']['c0ff33']['session_data'], "new"
+ res["rooms"]["!abc:matrix.org"]["sessions"]["c0ff33"]["session_data"], "new"
)
# TODO: check edge cases as well as the common variations here
diff --git a/tests/handlers/test_identity.py b/tests/handlers/test_identity.py
index 99ce94db52..b8ecdc5c9b 100644
--- a/tests/handlers/test_identity.py
+++ b/tests/handlers/test_identity.py
@@ -38,24 +38,18 @@ class ThreepidISRewrittenURLTestCase(unittest.HomeserverTestCase):
self.rewritten_is_url = "int.testis"
config = self.default_config()
- config["trusted_third_party_id_servers"] = [
- self.is_server_name,
- ]
+ config["trusted_third_party_id_servers"] = [self.is_server_name]
config["rewrite_identity_server_urls"] = {
- self.is_server_name: self.rewritten_is_url,
+ self.is_server_name: self.rewritten_is_url
}
- mock_http_client = Mock(spec=[
- "post_urlencoded_get_json",
- ])
- mock_http_client.post_urlencoded_get_json.return_value = defer.succeed({
- "address": self.address,
- "medium": "email",
- })
+ mock_http_client = Mock(spec=["post_urlencoded_get_json"])
+ mock_http_client.post_urlencoded_get_json.return_value = defer.succeed(
+ {"address": self.address, "medium": "email"}
+ )
self.hs = self.setup_test_homeserver(
- config=config,
- simple_http_client=mock_http_client,
+ config=config, simple_http_client=mock_http_client
)
return self.hs
@@ -74,35 +68,34 @@ class ThreepidISRewrittenURLTestCase(unittest.HomeserverTestCase):
post_urlenc_get_json = self.hs.get_simple_http_client().post_urlencoded_get_json
store = self.hs.get_datastore()
- creds = {
- "sid": "123",
- "client_secret": "some_secret",
- }
+ creds = {"sid": "123", "client_secret": "some_secret"}
# Make sure processing the mocked response goes through.
- data = self.get_success(handler.bind_threepid(
- {
- "id_server": self.is_server_name,
- "client_secret": creds["client_secret"],
- "sid": creds["sid"],
- },
- self.user_id,
- ))
+ data = self.get_success(
+ handler.bind_threepid(
+ {
+ "id_server": self.is_server_name,
+ "client_secret": creds["client_secret"],
+ "sid": creds["sid"],
+ },
+ self.user_id,
+ )
+ )
self.assertEqual(data.get("address"), self.address)
# Check that the request was done against the rewritten server name.
post_urlenc_get_json.assert_called_once_with(
"https://%s/_matrix/identity/api/v1/3pid/bind" % self.rewritten_is_url,
{
- 'sid': creds['sid'],
- 'client_secret': creds["client_secret"],
- 'mxid': self.user_id,
- }
+ "sid": creds["sid"],
+ "client_secret": creds["client_secret"],
+ "mxid": self.user_id,
+ },
)
# Check that the original server name is saved in the database instead of the
# rewritten one.
- id_servers = self.get_success(store.get_id_servers_user_bound(
- self.user_id, "email", self.address
- ))
+ id_servers = self.get_success(
+ store.get_id_servers_user_bound(self.user_id, "email", self.address)
+ )
self.assertEqual(id_servers, [self.is_server_name])
diff --git a/tests/handlers/test_profile.py b/tests/handlers/test_profile.py
index 45cbfeb9a4..2311040201 100644
--- a/tests/handlers/test_profile.py
+++ b/tests/handlers/test_profile.py
@@ -71,9 +71,7 @@ class ProfileTestCase(unittest.TestCase):
@defer.inlineCallbacks
def test_get_my_name(self):
- yield self.store.set_profile_displayname(
- self.frank.localpart, "Frank", 1,
- )
+ yield self.store.set_profile_displayname(self.frank.localpart, "Frank", 1)
displayname = yield self.handler.get_displayname(self.frank)
@@ -127,7 +125,7 @@ class ProfileTestCase(unittest.TestCase):
@defer.inlineCallbacks
def test_get_my_avatar(self):
yield self.store.set_profile_avatar_url(
- self.frank.localpart, "http://my.server/me.png", 1,
+ self.frank.localpart, "http://my.server/me.png", 1
)
avatar_url = yield self.handler.get_avatar_url(self.frank)
diff --git a/tests/handlers/test_register.py b/tests/handlers/test_register.py
index b2aa5c2478..e5a9acd87f 100644
--- a/tests/handlers/test_register.py
+++ b/tests/handlers/test_register.py
@@ -53,7 +53,7 @@ class RegistrationTestCase(unittest.HomeserverTestCase):
self.mock_distributor.declare("registered_user")
self.mock_captcha_client = Mock()
self.macaroon_generator = Mock(
- generate_access_token=Mock(return_value='secret')
+ generate_access_token=Mock(return_value="secret")
)
self.hs.get_macaroon_generator = Mock(return_value=self.macaroon_generator)
self.handler = self.hs.get_registration_handler()
@@ -72,7 +72,7 @@ class RegistrationTestCase(unittest.HomeserverTestCase):
)
self.assertEquals(result_user_id, user_id)
self.assertTrue(result_token is not None)
- self.assertEquals(result_token, 'secret')
+ self.assertEquals(result_token, "secret")
def test_if_user_exists(self):
store = self.hs.get_datastore()
@@ -97,7 +97,7 @@ class RegistrationTestCase(unittest.HomeserverTestCase):
self.hs.config.limit_usage_by_mau = False
# Ensure does not throw exception
self.get_success(
- self.handler.get_or_create_user(self.requester, 'a', "display_name")
+ self.handler.get_or_create_user(self.requester, "a", "display_name")
)
def test_get_or_create_user_mau_not_blocked(self):
@@ -106,7 +106,7 @@ class RegistrationTestCase(unittest.HomeserverTestCase):
return_value=defer.succeed(self.hs.config.max_mau_value - 1)
)
# Ensure does not throw exception
- self.get_success(self.handler.get_or_create_user(self.requester, 'c', "User"))
+ self.get_success(self.handler.get_or_create_user(self.requester, "c", "User"))
def test_get_or_create_user_mau_blocked(self):
self.hs.config.limit_usage_by_mau = True
@@ -114,7 +114,7 @@ class RegistrationTestCase(unittest.HomeserverTestCase):
return_value=defer.succeed(self.lots_of_users)
)
self.get_failure(
- self.handler.get_or_create_user(self.requester, 'b', "display_name"),
+ self.handler.get_or_create_user(self.requester, "b", "display_name"),
ResourceLimitError,
)
@@ -122,7 +122,7 @@ class RegistrationTestCase(unittest.HomeserverTestCase):
return_value=defer.succeed(self.hs.config.max_mau_value)
)
self.get_failure(
- self.handler.get_or_create_user(self.requester, 'b', "display_name"),
+ self.handler.get_or_create_user(self.requester, "b", "display_name"),
ResourceLimitError,
)
@@ -145,13 +145,13 @@ class RegistrationTestCase(unittest.HomeserverTestCase):
def test_auto_create_auto_join_rooms(self):
room_alias_str = "#room:test"
self.hs.config.auto_join_rooms = [room_alias_str]
- res = self.get_success(self.handler.register(localpart='jeff'))
+ res = self.get_success(self.handler.register(localpart="jeff"))
rooms = self.get_success(self.store.get_rooms_for_user(res[0]))
directory_handler = self.hs.get_handlers().directory_handler
room_alias = RoomAlias.from_string(room_alias_str)
room_id = self.get_success(directory_handler.get_association(room_alias))
- self.assertTrue(room_id['room_id'] in rooms)
+ self.assertTrue(room_id["room_id"] in rooms)
self.assertEqual(len(rooms), 1)
def test_auto_create_auto_join_rooms_with_no_rooms(self):
@@ -174,7 +174,7 @@ class RegistrationTestCase(unittest.HomeserverTestCase):
self.hs.config.autocreate_auto_join_rooms = False
room_alias_str = "#room:test"
self.hs.config.auto_join_rooms = [room_alias_str]
- res = self.get_success(self.handler.register(localpart='jeff'))
+ res = self.get_success(self.handler.register(localpart="jeff"))
rooms = self.get_success(self.store.get_rooms_for_user(res[0]))
self.assertEqual(len(rooms), 0)
@@ -183,7 +183,7 @@ class RegistrationTestCase(unittest.HomeserverTestCase):
self.hs.config.auto_join_rooms = [room_alias_str]
self.store.is_support_user = Mock(return_value=True)
- res = self.get_success(self.handler.register(localpart='support'))
+ res = self.get_success(self.handler.register(localpart="support"))
rooms = self.get_success(self.store.get_rooms_for_user(res[0]))
self.assertEqual(len(rooms), 0)
directory_handler = self.hs.get_handlers().directory_handler
@@ -212,7 +212,7 @@ class RegistrationTestCase(unittest.HomeserverTestCase):
# When:-
# * the user is registered and post consent actions are called
- res = self.get_success(self.handler.register(localpart='jeff'))
+ res = self.get_success(self.handler.register(localpart="jeff"))
self.get_success(self.handler.post_consent_actions(res[0]))
# Then:-
@@ -222,37 +222,27 @@ class RegistrationTestCase(unittest.HomeserverTestCase):
def test_register_support_user(self):
res = self.get_success(
- self.handler.register(localpart='user', user_type=UserTypes.SUPPORT)
+ self.handler.register(localpart="user", user_type=UserTypes.SUPPORT)
)
self.assertTrue(self.store.is_support_user(res[0]))
def test_register_not_support_user(self):
- res = self.get_success(self.handler.register(localpart='user'))
+ res = self.get_success(self.handler.register(localpart="user"))
self.assertFalse(self.store.is_support_user(res[0]))
def test_invalid_user_id_length(self):
invalid_user_id = "x" * 256
- self.get_failure(
- self.handler.register(localpart=invalid_user_id),
- SynapseError
- )
+ self.get_failure(self.handler.register(localpart=invalid_user_id), SynapseError)
def test_email_to_displayname_mapping(self):
"""Test that custom emails are mapped to new user displaynames correctly"""
self._check_mapping(
- "jack-phillips.rivers@big-org.com",
- "Jack-Phillips Rivers [Big-Org]",
+ "jack-phillips.rivers@big-org.com", "Jack-Phillips Rivers [Big-Org]"
)
- self._check_mapping(
- "bob.jones@matrix.org",
- "Bob Jones [Tchap Admin]",
- )
+ self._check_mapping("bob.jones@matrix.org", "Bob Jones [Tchap Admin]")
- self._check_mapping(
- "bob-jones.blabla@gouv.fr",
- "Bob-Jones Blabla [Gouv]",
- )
+ self._check_mapping("bob-jones.blabla@gouv.fr", "Bob-Jones Blabla [Gouv]")
# Multibyte unicode characters
self._check_mapping(
diff --git a/tests/handlers/test_stats.py b/tests/handlers/test_stats.py
index 2710c991cf..a8b858eb4f 100644
--- a/tests/handlers/test_stats.py
+++ b/tests/handlers/test_stats.py
@@ -265,10 +265,7 @@ class StatsRoomTests(unittest.HomeserverTestCase):
while not self.get_success(self.store.has_completed_background_updates()):
self.get_success(self.store.do_next_background_update(100), by=0.1)
- events = {
- "a1": None,
- "a2": {"membership": Membership.JOIN},
- }
+ events = {"a1": None, "a2": {"membership": Membership.JOIN}}
def get_event(event_id, allow_none=True):
if events.get(event_id):
diff --git a/tests/handlers/test_typing.py b/tests/handlers/test_typing.py
index cb8b4d2913..5d5e324df2 100644
--- a/tests/handlers/test_typing.py
+++ b/tests/handlers/test_typing.py
@@ -47,7 +47,7 @@ def _expect_edu_transaction(edu_type, content, origin="test"):
def _make_edu_transaction_json(edu_type, content):
- return json.dumps(_expect_edu_transaction(edu_type, content)).encode('utf8')
+ return json.dumps(_expect_edu_transaction(edu_type, content)).encode("utf8")
class TypingNotificationsTestCase(unittest.HomeserverTestCase):
@@ -151,7 +151,7 @@ class TypingNotificationsTestCase(unittest.HomeserverTestCase):
)
)
- 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(room_ids=[ROOM_ID], from_key=0)
@@ -209,12 +209,12 @@ class TypingNotificationsTestCase(unittest.HomeserverTestCase):
"typing": True,
},
),
- federation_auth_origin=b'farm',
+ federation_auth_origin=b"farm",
)
self.render(request)
self.assertEqual(channel.code, 200)
- 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(room_ids=[ROOM_ID], from_key=0)
@@ -247,7 +247,7 @@ class TypingNotificationsTestCase(unittest.HomeserverTestCase):
)
)
- 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(
@@ -285,7 +285,7 @@ class TypingNotificationsTestCase(unittest.HomeserverTestCase):
)
)
- 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)
@@ -303,7 +303,7 @@ class TypingNotificationsTestCase(unittest.HomeserverTestCase):
self.reactor.pump([16])
- self.on_new_event.assert_has_calls([call('typing_key', 2, rooms=[ROOM_ID])])
+ self.on_new_event.assert_has_calls([call("typing_key", 2, rooms=[ROOM_ID])])
self.assertEquals(self.event_source.get_current_key(), 2)
events = self.event_source.get_new_events(room_ids=[ROOM_ID], from_key=1)
@@ -320,7 +320,7 @@ class TypingNotificationsTestCase(unittest.HomeserverTestCase):
)
)
- 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)
diff --git a/tests/handlers/test_user_directory.py b/tests/handlers/test_user_directory.py
index 9021e647fe..b135486c48 100644
--- a/tests/handlers/test_user_directory.py
+++ b/tests/handlers/test_user_directory.py
@@ -60,15 +60,15 @@ class UserDirectoryTestCase(unittest.HomeserverTestCase):
)
profile = self.get_success(self.store.get_user_in_directory(support_user_id))
self.assertTrue(profile is None)
- display_name = 'display_name'
+ display_name = "display_name"
- profile_info = ProfileInfo(avatar_url='avatar_url', display_name=display_name)
- regular_user_id = '@regular:test'
+ profile_info = ProfileInfo(avatar_url="avatar_url", display_name=display_name)
+ regular_user_id = "@regular:test"
self.get_success(
self.handler.handle_local_profile_change(regular_user_id, profile_info)
)
profile = self.get_success(self.store.get_user_in_directory(regular_user_id))
- self.assertTrue(profile['display_name'] == display_name)
+ self.assertTrue(profile["display_name"] == display_name)
def test_handle_user_deactivated_support_user(self):
s_user_id = "@support:test"
diff --git a/tests/http/federation/test_matrix_federation_agent.py b/tests/http/federation/test_matrix_federation_agent.py
index 6609d6b366..2fe3567dfa 100644
--- a/tests/http/federation/test_matrix_federation_agent.py
+++ b/tests/http/federation/test_matrix_federation_agent.py
@@ -53,13 +53,15 @@ def get_connection_factory():
# this needs to happen once, but not until we are ready to run the first test
global test_server_connection_factory
if test_server_connection_factory is None:
- test_server_connection_factory = TestServerTLSConnectionFactory(sanlist=[
- b'DNS:testserv',
- b'DNS:target-server',
- b'DNS:xn--bcher-kva.com',
- b'IP:1.2.3.4',
- b'IP:::1',
- ])
+ test_server_connection_factory = TestServerTLSConnectionFactory(
+ sanlist=[
+ b"DNS:testserv",
+ b"DNS:target-server",
+ b"DNS:xn--bcher-kva.com",
+ b"IP:1.2.3.4",
+ b"IP:::1",
+ ]
+ )
return test_server_connection_factory
@@ -138,7 +140,7 @@ class MatrixFederationAgentTests(TestCase):
Sends a simple GET request via the agent, and checks its logcontext management
"""
with LoggingContext("one") as context:
- fetch_d = self.agent.request(b'GET', uri)
+ fetch_d = self.agent.request(b"GET", uri)
# Nothing happened yet
self.assertNoResult(fetch_d)
@@ -182,9 +184,9 @@ class MatrixFederationAgentTests(TestCase):
"""Check that an incoming request looks like a valid .well-known request, and
send back the response.
"""
- self.assertEqual(request.method, b'GET')
- self.assertEqual(request.path, b'/.well-known/matrix/server')
- self.assertEqual(request.requestHeaders.getRawHeaders(b'host'), [b'testserv'])
+ self.assertEqual(request.method, b"GET")
+ self.assertEqual(request.path, b"/.well-known/matrix/server")
+ self.assertEqual(request.requestHeaders.getRawHeaders(b"host"), [b"testserv"])
# send back a response
for k, v in headers.items():
request.setHeader(k, v)
@@ -207,7 +209,7 @@ class MatrixFederationAgentTests(TestCase):
clients = self.reactor.tcpClients
self.assertEqual(len(clients), 1)
(host, port, client_factory, _timeout, _bindAddress) = clients[0]
- self.assertEqual(host, '1.2.3.4')
+ self.assertEqual(host, "1.2.3.4")
self.assertEqual(port, 8448)
# make a test server, and wire up the client
@@ -215,20 +217,20 @@ class MatrixFederationAgentTests(TestCase):
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.method, b"GET")
+ self.assertEqual(request.path, b"/foo/bar")
self.assertEqual(
- request.requestHeaders.getRawHeaders(b'host'), [b'testserv:8448']
+ request.requestHeaders.getRawHeaders(b"host"), [b"testserv:8448"]
)
content = request.content.read()
- self.assertEqual(content, b'')
+ self.assertEqual(content, b"")
# Deferred is still without a result
self.assertNoResult(test_d)
# send the headers
- request.responseHeaders.setRawHeaders(b'Content-Type', [b'application/json'])
- request.write('')
+ request.responseHeaders.setRawHeaders(b"Content-Type", [b"application/json"])
+ request.write("")
self.reactor.pump((0.1,))
@@ -238,7 +240,7 @@ class MatrixFederationAgentTests(TestCase):
self.assertEqual(response.code, 200)
# Send the body
- request.write('{ "a": 1 }'.encode('ascii'))
+ request.write('{ "a": 1 }'.encode("ascii"))
request.finish()
self.reactor.pump((0.1,))
@@ -263,7 +265,7 @@ class MatrixFederationAgentTests(TestCase):
clients = self.reactor.tcpClients
self.assertEqual(len(clients), 1)
(host, port, client_factory, _timeout, _bindAddress) = clients[0]
- self.assertEqual(host, '1.2.3.4')
+ self.assertEqual(host, "1.2.3.4")
self.assertEqual(port, 8448)
# make a test server, and wire up the client
@@ -271,9 +273,9 @@ class MatrixFederationAgentTests(TestCase):
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'), [b'1.2.3.4'])
+ self.assertEqual(request.method, b"GET")
+ self.assertEqual(request.path, b"/foo/bar")
+ self.assertEqual(request.requestHeaders.getRawHeaders(b"host"), [b"1.2.3.4"])
# finish the request
request.finish()
@@ -298,7 +300,7 @@ class MatrixFederationAgentTests(TestCase):
clients = self.reactor.tcpClients
self.assertEqual(len(clients), 1)
(host, port, client_factory, _timeout, _bindAddress) = clients[0]
- self.assertEqual(host, '::1')
+ self.assertEqual(host, "::1")
self.assertEqual(port, 8448)
# make a test server, and wire up the client
@@ -306,9 +308,9 @@ class MatrixFederationAgentTests(TestCase):
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'), [b'[::1]'])
+ self.assertEqual(request.method, b"GET")
+ self.assertEqual(request.path, b"/foo/bar")
+ self.assertEqual(request.requestHeaders.getRawHeaders(b"host"), [b"[::1]"])
# finish the request
request.finish()
@@ -333,7 +335,7 @@ class MatrixFederationAgentTests(TestCase):
clients = self.reactor.tcpClients
self.assertEqual(len(clients), 1)
(host, port, client_factory, _timeout, _bindAddress) = clients[0]
- self.assertEqual(host, '::1')
+ self.assertEqual(host, "::1")
self.assertEqual(port, 80)
# make a test server, and wire up the client
@@ -341,9 +343,9 @@ class MatrixFederationAgentTests(TestCase):
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'), [b'[::1]:80'])
+ self.assertEqual(request.method, b"GET")
+ self.assertEqual(request.path, b"/foo/bar")
+ self.assertEqual(request.requestHeaders.getRawHeaders(b"host"), [b"[::1]:80"])
# finish the request
request.finish()
@@ -369,7 +371,7 @@ class MatrixFederationAgentTests(TestCase):
clients = self.reactor.tcpClients
self.assertEqual(len(clients), 1)
(host, port, client_factory, _timeout, _bindAddress) = clients[0]
- self.assertEqual(host, '1.2.3.4')
+ self.assertEqual(host, "1.2.3.4")
self.assertEqual(port, 443)
# fonx the connection
@@ -387,11 +389,11 @@ class MatrixFederationAgentTests(TestCase):
# we should fall back to a direct connection
self.assertEqual(len(clients), 2)
(host, port, client_factory, _timeout, _bindAddress) = clients[1]
- self.assertEqual(host, '1.2.3.4')
+ self.assertEqual(host, "1.2.3.4")
self.assertEqual(port, 8448)
# make a test server, and wire up the client
- http_server = self._make_connection(client_factory, expected_sni=b'testserv1')
+ http_server = self._make_connection(client_factory, expected_sni=b"testserv1")
# there should be no requests
self.assertEqual(len(http_server.requests), 0)
@@ -418,7 +420,7 @@ class MatrixFederationAgentTests(TestCase):
clients = self.reactor.tcpClients
self.assertEqual(len(clients), 1)
(host, port, client_factory, _timeout, _bindAddress) = clients[0]
- self.assertEqual(host, '1.2.3.5')
+ self.assertEqual(host, "1.2.3.5")
self.assertEqual(port, 8448)
# make a test server, and wire up the client
@@ -452,7 +454,7 @@ class MatrixFederationAgentTests(TestCase):
clients = self.reactor.tcpClients
self.assertEqual(len(clients), 1)
(host, port, client_factory, _timeout, _bindAddress) = clients[0]
- self.assertEqual(host, '1.2.3.4')
+ self.assertEqual(host, "1.2.3.4")
self.assertEqual(port, 443)
# fonx the connection
@@ -470,17 +472,17 @@ class MatrixFederationAgentTests(TestCase):
# we should fall back to a direct connection
self.assertEqual(len(clients), 2)
(host, port, client_factory, _timeout, _bindAddress) = clients[1]
- self.assertEqual(host, '1.2.3.4')
+ self.assertEqual(host, "1.2.3.4")
self.assertEqual(port, 8448)
# make a test server, and wire up the client
- http_server = self._make_connection(client_factory, expected_sni=b'testserv')
+ http_server = self._make_connection(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'), [b'testserv'])
+ self.assertEqual(request.method, b"GET")
+ self.assertEqual(request.path, b"/foo/bar")
+ self.assertEqual(request.requestHeaders.getRawHeaders(b"host"), [b"testserv"])
# finish the request
request.finish()
@@ -504,7 +506,7 @@ class MatrixFederationAgentTests(TestCase):
clients = self.reactor.tcpClients
self.assertEqual(len(clients), 1)
(host, port, client_factory, _timeout, _bindAddress) = clients[0]
- self.assertEqual(host, '1.2.3.4')
+ self.assertEqual(host, "1.2.3.4")
self.assertEqual(port, 443)
self._handle_well_known_connection(
@@ -521,20 +523,20 @@ class MatrixFederationAgentTests(TestCase):
# now we should get a connection to the target server
self.assertEqual(len(clients), 2)
(host, port, client_factory, _timeout, _bindAddress) = clients[1]
- self.assertEqual(host, '1::f')
+ self.assertEqual(host, "1::f")
self.assertEqual(port, 8448)
# make a test server, and wire up the client
http_server = self._make_connection(
- client_factory, expected_sni=b'target-server'
+ client_factory, expected_sni=b"target-server"
)
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.method, b"GET")
+ self.assertEqual(request.path, b"/foo/bar")
self.assertEqual(
- request.requestHeaders.getRawHeaders(b'host'), [b'target-server']
+ request.requestHeaders.getRawHeaders(b"host"), [b"target-server"]
)
# finish the request
@@ -566,7 +568,7 @@ class MatrixFederationAgentTests(TestCase):
clients = self.reactor.tcpClients
self.assertEqual(len(clients), 1)
(host, port, client_factory, _timeout, _bindAddress) = clients.pop()
- self.assertEqual(host, '1.2.3.4')
+ self.assertEqual(host, "1.2.3.4")
self.assertEqual(port, 443)
redirect_server = self._make_connection(
@@ -576,7 +578,7 @@ class MatrixFederationAgentTests(TestCase):
# send a 302 redirect
self.assertEqual(len(redirect_server.requests), 1)
request = redirect_server.requests[0]
- request.redirect(b'https://testserv/even_better_known')
+ request.redirect(b"https://testserv/even_better_known")
request.finish()
self.reactor.pump((0.1,))
@@ -585,7 +587,7 @@ class MatrixFederationAgentTests(TestCase):
clients = self.reactor.tcpClients
self.assertEqual(len(clients), 1)
(host, port, client_factory, _timeout, _bindAddress) = clients.pop()
- self.assertEqual(host, '1.2.3.4')
+ self.assertEqual(host, "1.2.3.4")
self.assertEqual(port, 443)
well_known_server = self._make_connection(
@@ -594,8 +596,8 @@ class MatrixFederationAgentTests(TestCase):
self.assertEqual(len(well_known_server.requests), 1, "No request after 302")
request = well_known_server.requests[0]
- self.assertEqual(request.method, b'GET')
- self.assertEqual(request.path, b'/even_better_known')
+ self.assertEqual(request.method, b"GET")
+ self.assertEqual(request.path, b"/even_better_known")
request.write(b'{ "m.server": "target-server" }')
request.finish()
@@ -609,20 +611,20 @@ class MatrixFederationAgentTests(TestCase):
# now we should get a connection to the target server
self.assertEqual(len(clients), 1)
(host, port, client_factory, _timeout, _bindAddress) = clients[0]
- self.assertEqual(host, '1::f')
+ self.assertEqual(host, "1::f")
self.assertEqual(port, 8448)
# make a test server, and wire up the client
http_server = self._make_connection(
- client_factory, expected_sni=b'target-server'
+ client_factory, expected_sni=b"target-server"
)
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.method, b"GET")
+ self.assertEqual(request.path, b"/foo/bar")
self.assertEqual(
- request.requestHeaders.getRawHeaders(b'host'), [b'target-server']
+ request.requestHeaders.getRawHeaders(b"host"), [b"target-server"]
)
# finish the request
@@ -657,11 +659,11 @@ class MatrixFederationAgentTests(TestCase):
clients = self.reactor.tcpClients
self.assertEqual(len(clients), 1)
(host, port, client_factory, _timeout, _bindAddress) = clients.pop()
- self.assertEqual(host, '1.2.3.4')
+ self.assertEqual(host, "1.2.3.4")
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
@@ -672,17 +674,17 @@ class MatrixFederationAgentTests(TestCase):
# we should fall back to a direct connection
self.assertEqual(len(clients), 1)
(host, port, client_factory, _timeout, _bindAddress) = clients.pop()
- self.assertEqual(host, '1.2.3.4')
+ self.assertEqual(host, "1.2.3.4")
self.assertEqual(port, 8448)
# make a test server, and wire up the client
- http_server = self._make_connection(client_factory, expected_sni=b'testserv')
+ http_server = self._make_connection(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'), [b'testserv'])
+ self.assertEqual(request.method, b"GET")
+ self.assertEqual(request.path, b"/foo/bar")
+ self.assertEqual(request.requestHeaders.getRawHeaders(b"host"), [b"testserv"])
# finish the request
request.finish()
@@ -717,12 +719,10 @@ class MatrixFederationAgentTests(TestCase):
clients = self.reactor.tcpClients
self.assertEqual(len(clients), 1)
(host, port, client_factory, _timeout, _bindAddress) = clients[0]
- self.assertEqual(host, '1.2.3.4')
+ self.assertEqual(host, "1.2.3.4")
self.assertEqual(port, 443)
- http_proto = self._make_connection(
- client_factory, expected_sni=b"testserv",
- )
+ http_proto = self._make_connection(client_factory, expected_sni=b"testserv")
# there should be no requests
self.assertEqual(len(http_proto.requests), 0)
@@ -755,17 +755,17 @@ class MatrixFederationAgentTests(TestCase):
clients = self.reactor.tcpClients
self.assertEqual(len(clients), 1)
(host, port, client_factory, _timeout, _bindAddress) = clients[0]
- self.assertEqual(host, '1.2.3.4')
+ self.assertEqual(host, "1.2.3.4")
self.assertEqual(port, 8443)
# make a test server, and wire up the client
- http_server = self._make_connection(client_factory, expected_sni=b'testserv')
+ http_server = self._make_connection(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'), [b'testserv'])
+ self.assertEqual(request.method, b"GET")
+ self.assertEqual(request.path, b"/foo/bar")
+ self.assertEqual(request.requestHeaders.getRawHeaders(b"host"), [b"testserv"])
# finish the request
request.finish()
@@ -788,7 +788,7 @@ class MatrixFederationAgentTests(TestCase):
clients = self.reactor.tcpClients
self.assertEqual(len(clients), 1)
(host, port, client_factory, _timeout, _bindAddress) = clients[0]
- self.assertEqual(host, '1.2.3.4')
+ self.assertEqual(host, "1.2.3.4")
self.assertEqual(port, 443)
self.mock_resolver.resolve_service.side_effect = lambda _: [
@@ -809,20 +809,20 @@ class MatrixFederationAgentTests(TestCase):
# now we should get a connection to the target of the SRV record
self.assertEqual(len(clients), 2)
(host, port, client_factory, _timeout, _bindAddress) = clients[1]
- self.assertEqual(host, '5.6.7.8')
+ self.assertEqual(host, "5.6.7.8")
self.assertEqual(port, 8443)
# make a test server, and wire up the client
http_server = self._make_connection(
- client_factory, expected_sni=b'target-server'
+ client_factory, expected_sni=b"target-server"
)
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.method, b"GET")
+ self.assertEqual(request.path, b"/foo/bar")
self.assertEqual(
- request.requestHeaders.getRawHeaders(b'host'), [b'target-server']
+ request.requestHeaders.getRawHeaders(b"host"), [b"target-server"]
)
# finish the request
@@ -851,7 +851,7 @@ class MatrixFederationAgentTests(TestCase):
clients = self.reactor.tcpClients
self.assertEqual(len(clients), 1)
(host, port, client_factory, _timeout, _bindAddress) = clients[0]
- self.assertEqual(host, '1.2.3.4')
+ self.assertEqual(host, "1.2.3.4")
self.assertEqual(port, 443)
# fonx the connection
@@ -870,20 +870,20 @@ class MatrixFederationAgentTests(TestCase):
clients = self.reactor.tcpClients
self.assertEqual(len(clients), 2)
(host, port, client_factory, _timeout, _bindAddress) = clients[1]
- self.assertEqual(host, '1.2.3.4')
+ self.assertEqual(host, "1.2.3.4")
self.assertEqual(port, 8448)
# make a test server, and wire up the client
http_server = self._make_connection(
- client_factory, expected_sni=b'xn--bcher-kva.com'
+ client_factory, expected_sni=b"xn--bcher-kva.com"
)
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.method, b"GET")
+ self.assertEqual(request.path, b"/foo/bar")
self.assertEqual(
- request.requestHeaders.getRawHeaders(b'host'), [b'xn--bcher-kva.com']
+ request.requestHeaders.getRawHeaders(b"host"), [b"xn--bcher-kva.com"]
)
# finish the request
@@ -912,20 +912,20 @@ class MatrixFederationAgentTests(TestCase):
clients = self.reactor.tcpClients
self.assertEqual(len(clients), 1)
(host, port, client_factory, _timeout, _bindAddress) = clients[0]
- self.assertEqual(host, '1.2.3.4')
+ self.assertEqual(host, "1.2.3.4")
self.assertEqual(port, 8443)
# make a test server, and wire up the client
http_server = self._make_connection(
- client_factory, expected_sni=b'xn--bcher-kva.com'
+ client_factory, expected_sni=b"xn--bcher-kva.com"
)
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.method, b"GET")
+ self.assertEqual(request.path, b"/foo/bar")
self.assertEqual(
- request.requestHeaders.getRawHeaders(b'host'), [b'xn--bcher-kva.com']
+ request.requestHeaders.getRawHeaders(b"host"), [b"xn--bcher-kva.com"]
)
# finish the request
@@ -946,42 +946,42 @@ class MatrixFederationAgentTests(TestCase):
def test_well_known_cache(self):
self.reactor.lookups["testserv"] = "1.2.3.4"
- fetch_d = self.do_get_well_known(b'testserv')
+ fetch_d = self.do_get_well_known(b"testserv")
# there should be an attempt to connect on port 443 for the .well-known
clients = self.reactor.tcpClients
self.assertEqual(len(clients), 1)
(host, port, client_factory, _timeout, _bindAddress) = clients.pop(0)
- self.assertEqual(host, '1.2.3.4')
+ self.assertEqual(host, "1.2.3.4")
self.assertEqual(port, 443)
well_known_server = self._handle_well_known_connection(
client_factory,
expected_sni=b"testserv",
- response_headers={b'Cache-Control': b'max-age=10'},
+ response_headers={b"Cache-Control": b"max-age=10"},
content=b'{ "m.server": "target-server" }',
)
r = self.successResultOf(fetch_d)
- self.assertEqual(r, b'target-server')
+ self.assertEqual(r, b"target-server")
# close the tcp connection
well_known_server.loseConnection()
# repeat the request: it should hit the cache
- fetch_d = self.do_get_well_known(b'testserv')
+ fetch_d = self.do_get_well_known(b"testserv")
r = self.successResultOf(fetch_d)
- self.assertEqual(r, b'target-server')
+ self.assertEqual(r, b"target-server")
# expire the cache
self.reactor.pump((10.0,))
# now it should connect again
- fetch_d = self.do_get_well_known(b'testserv')
+ fetch_d = self.do_get_well_known(b"testserv")
self.assertEqual(len(clients), 1)
(host, port, client_factory, _timeout, _bindAddress) = clients.pop(0)
- self.assertEqual(host, '1.2.3.4')
+ self.assertEqual(host, "1.2.3.4")
self.assertEqual(port, 443)
self._handle_well_known_connection(
@@ -991,7 +991,7 @@ class MatrixFederationAgentTests(TestCase):
)
r = self.successResultOf(fetch_d)
- self.assertEqual(r, b'other-server')
+ self.assertEqual(r, b"other-server")
class TestCachePeriodFromHeaders(TestCase):
@@ -999,27 +999,27 @@ 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,
)
# missing value
self.assertIsNone(
- _cache_period_from_headers(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(
- Headers({b'Cache-Control': [b'private; max-age=0']})
+ 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,
)
@@ -1027,7 +1027,7 @@ class TestCachePeriodFromHeaders(TestCase):
# 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,
)
@@ -1035,7 +1035,7 @@ class TestCachePeriodFromHeaders(TestCase):
def test_expires(self):
self.assertEqual(
_cache_period_from_headers(
- Headers({b'Expires': [b'Wed, 30 Jan 2019 07:35:33 GMT']}),
+ Headers({b"Expires": [b"Wed, 30 Jan 2019 07:35:33 GMT"]}),
time_now=lambda: 1548833700,
),
33,
@@ -1046,8 +1046,8 @@ class TestCachePeriodFromHeaders(TestCase):
_cache_period_from_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,
@@ -1056,7 +1056,7 @@ class TestCachePeriodFromHeaders(TestCase):
)
# invalid expires means immediate expiry
- self.assertEqual(_cache_period_from_headers(Headers({b'Expires': [b'0']})), 0)
+ self.assertEqual(_cache_period_from_headers(Headers({b"Expires": [b"0"]})), 0)
def _check_logcontext(context):
diff --git a/tests/http/federation/test_srv_resolver.py b/tests/http/federation/test_srv_resolver.py
index 034c0db8d2..cf6c6e95b5 100644
--- a/tests/http/federation/test_srv_resolver.py
+++ b/tests/http/federation/test_srv_resolver.py
@@ -100,7 +100,7 @@ class SrvResolverTestCase(unittest.TestCase):
def test_from_cache(self):
clock = MockClock()
- dns_client_mock = Mock(spec_set=['lookupService'])
+ dns_client_mock = Mock(spec_set=["lookupService"])
dns_client_mock.lookupService = Mock(spec_set=[])
service_name = b"test_service.example.com"
diff --git a/tests/http/test_endpoint.py b/tests/http/test_endpoint.py
index 3b0155ed03..b2e9533b07 100644
--- a/tests/http/test_endpoint.py
+++ b/tests/http/test_endpoint.py
@@ -20,12 +20,12 @@ from tests import unittest
class ServerNameTestCase(unittest.TestCase):
def test_parse_server_name(self):
test_data = {
- 'localhost': ('localhost', None),
- 'my-example.com:1234': ('my-example.com', 1234),
- '1.2.3.4': ('1.2.3.4', None),
- '[0abc:1def::1234]': ('[0abc:1def::1234]', None),
- '1.2.3.4:1': ('1.2.3.4', 1),
- '[0abc:1def::1234]:8080': ('[0abc:1def::1234]', 8080),
+ "localhost": ("localhost", None),
+ "my-example.com:1234": ("my-example.com", 1234),
+ "1.2.3.4": ("1.2.3.4", None),
+ "[0abc:1def::1234]": ("[0abc:1def::1234]", None),
+ "1.2.3.4:1": ("1.2.3.4", 1),
+ "[0abc:1def::1234]:8080": ("[0abc:1def::1234]", 8080),
}
for i, o in test_data.items():
diff --git a/tests/http/test_fedclient.py b/tests/http/test_fedclient.py
index ee767f3a5a..c4c0d9b968 100644
--- a/tests/http/test_fedclient.py
+++ b/tests/http/test_fedclient.py
@@ -83,7 +83,7 @@ class FederationClientTests(HomeserverTestCase):
clients = self.reactor.tcpClients
self.assertEqual(len(clients), 1)
(host, port, factory, _timeout, _bindAddress) = clients[0]
- self.assertEqual(host, '1.2.3.4')
+ self.assertEqual(host, "1.2.3.4")
self.assertEqual(port, 8008)
# complete the connection and wire it up to a fake transport
@@ -99,7 +99,7 @@ class FederationClientTests(HomeserverTestCase):
self.assertNoResult(test_d)
# Send it the HTTP response
- res_json = '{ "a": 1 }'.encode('ascii')
+ res_json = '{ "a": 1 }'.encode("ascii")
protocol.dataReceived(
b"HTTP/1.1 200 OK\r\n"
b"Server: Fake\r\n"
@@ -138,7 +138,7 @@ class FederationClientTests(HomeserverTestCase):
clients = self.reactor.tcpClients
self.assertEqual(len(clients), 1)
(host, port, factory, _timeout, _bindAddress) = clients[0]
- self.assertEqual(host, '1.2.3.4')
+ self.assertEqual(host, "1.2.3.4")
self.assertEqual(port, 8008)
e = Exception("go away")
factory.clientConnectionFailed(None, e)
@@ -164,7 +164,7 @@ class FederationClientTests(HomeserverTestCase):
# Make sure treq is trying to connect
clients = self.reactor.tcpClients
self.assertEqual(len(clients), 1)
- self.assertEqual(clients[0][0], '1.2.3.4')
+ self.assertEqual(clients[0][0], "1.2.3.4")
self.assertEqual(clients[0][1], 8008)
# Deferred is still without a result
@@ -194,7 +194,7 @@ class FederationClientTests(HomeserverTestCase):
# Make sure treq is trying to connect
clients = self.reactor.tcpClients
self.assertEqual(len(clients), 1)
- self.assertEqual(clients[0][0], '1.2.3.4')
+ self.assertEqual(clients[0][0], "1.2.3.4")
self.assertEqual(clients[0][1], 8008)
conn = Mock()
@@ -215,10 +215,9 @@ class FederationClientTests(HomeserverTestCase):
"""Ensure that Synapse does not try to connect to blacklisted IPs"""
# Set up the ip_range blacklist
- self.hs.config.federation_ip_range_blacklist = IPSet([
- "127.0.0.0/8",
- "fe80::/64",
- ])
+ self.hs.config.federation_ip_range_blacklist = IPSet(
+ ["127.0.0.0/8", "fe80::/64"]
+ )
self.reactor.lookups["internal"] = "127.0.0.1"
self.reactor.lookups["internalv6"] = "fe80:0:0:0:0:8a2e:370:7337"
self.reactor.lookups["fine"] = "10.20.30.40"
@@ -382,7 +381,7 @@ class FederationClientTests(HomeserverTestCase):
b"Content-Type: application/json\r\n"
b"Content-Length: 2\r\n"
b"\r\n"
- b'{}'
+ b"{}"
)
# We should get a successful response
diff --git a/tests/push/test_email.py b/tests/push/test_email.py
index 72760a0733..358b593cd4 100644
--- a/tests/push/test_email.py
+++ b/tests/push/test_email.py
@@ -57,7 +57,7 @@ class EmailPusherTests(HomeserverTestCase):
config["email"] = {
"enable_notifs": True,
"template_dir": os.path.abspath(
- pkg_resources.resource_filename('synapse', 'res/templates')
+ pkg_resources.resource_filename("synapse", "res/templates")
),
"expiry_template_html": "notice_expiry.html",
"expiry_template_text": "notice_expiry.txt",
@@ -120,7 +120,7 @@ class EmailPusherTests(HomeserverTestCase):
# Create a simple room with two users
room = self.helper.create_room_as(self.user_id, tok=self.access_token)
self.helper.invite(
- room=room, src=self.user_id, tok=self.access_token, targ=self.others[0].id,
+ room=room, src=self.user_id, tok=self.access_token, targ=self.others[0].id
)
self.helper.join(room=room, user=self.others[0].id, tok=self.others[0].token)
@@ -141,7 +141,7 @@ class EmailPusherTests(HomeserverTestCase):
for other in self.others:
self.helper.invite(
- room=room, src=self.user_id, tok=self.access_token, targ=other.id,
+ room=room, src=self.user_id, tok=self.access_token, targ=other.id
)
self.helper.join(room=room, user=other.id, tok=other.token)
diff --git a/tests/rest/admin/test_admin.py b/tests/rest/admin/test_admin.py
index e5fc2fcd15..b62ab36fda 100644
--- a/tests/rest/admin/test_admin.py
+++ b/tests/rest/admin/test_admin.py
@@ -30,7 +30,7 @@ from tests import unittest
class VersionTestCase(unittest.HomeserverTestCase):
- url = '/_synapse/admin/v1/server_version'
+ url = "/_synapse/admin/v1/server_version"
def create_test_json_resource(self):
resource = JsonResource(self.hs)
@@ -43,7 +43,7 @@ class VersionTestCase(unittest.HomeserverTestCase):
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(
- {'server_version', 'python_version'}, set(channel.json_body.keys())
+ {"server_version", "python_version"}, set(channel.json_body.keys())
)
@@ -82,12 +82,12 @@ class UserRegisterTestCase(unittest.HomeserverTestCase):
"""
self.hs.config.registration_shared_secret = None
- request, channel = self.make_request("POST", self.url, b'{}')
+ request, channel = self.make_request("POST", self.url, b"{}")
self.render(request)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(
- 'Shared secret registration is not enabled', channel.json_body["error"]
+ "Shared secret registration is not enabled", channel.json_body["error"]
)
def test_get_nonce(self):
@@ -118,20 +118,20 @@ class UserRegisterTestCase(unittest.HomeserverTestCase):
self.reactor.advance(59)
body = json.dumps({"nonce": nonce})
- request, channel = self.make_request("POST", self.url, body.encode('utf8'))
+ request, channel = self.make_request("POST", self.url, body.encode("utf8"))
self.render(request)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
- self.assertEqual('username must be specified', channel.json_body["error"])
+ self.assertEqual("username must be specified", channel.json_body["error"])
# 61 seconds
self.reactor.advance(2)
- request, channel = self.make_request("POST", self.url, body.encode('utf8'))
+ request, channel = self.make_request("POST", self.url, body.encode("utf8"))
self.render(request)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
- self.assertEqual('unrecognised nonce', channel.json_body["error"])
+ self.assertEqual("unrecognised nonce", channel.json_body["error"])
def test_register_incorrect_nonce(self):
"""
@@ -154,7 +154,7 @@ class UserRegisterTestCase(unittest.HomeserverTestCase):
"mac": want_mac,
}
)
- request, channel = self.make_request("POST", self.url, body.encode('utf8'))
+ request, channel = self.make_request("POST", self.url, body.encode("utf8"))
self.render(request)
self.assertEqual(403, int(channel.result["code"]), msg=channel.result["body"])
@@ -171,7 +171,7 @@ class UserRegisterTestCase(unittest.HomeserverTestCase):
want_mac = hmac.new(key=b"shared", digestmod=hashlib.sha1)
want_mac.update(
- nonce.encode('ascii') + b"\x00bob\x00abc123\x00admin\x00support"
+ nonce.encode("ascii") + b"\x00bob\x00abc123\x00admin\x00support"
)
want_mac = want_mac.hexdigest()
@@ -185,7 +185,7 @@ class UserRegisterTestCase(unittest.HomeserverTestCase):
"mac": want_mac,
}
)
- request, channel = self.make_request("POST", self.url, body.encode('utf8'))
+ request, channel = self.make_request("POST", self.url, body.encode("utf8"))
self.render(request)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@@ -200,7 +200,7 @@ class UserRegisterTestCase(unittest.HomeserverTestCase):
nonce = channel.json_body["nonce"]
want_mac = hmac.new(key=b"shared", digestmod=hashlib.sha1)
- want_mac.update(nonce.encode('ascii') + b"\x00bob\x00abc123\x00admin")
+ want_mac.update(nonce.encode("ascii") + b"\x00bob\x00abc123\x00admin")
want_mac = want_mac.hexdigest()
body = json.dumps(
@@ -212,18 +212,18 @@ class UserRegisterTestCase(unittest.HomeserverTestCase):
"mac": want_mac,
}
)
- request, channel = self.make_request("POST", self.url, body.encode('utf8'))
+ request, channel = self.make_request("POST", self.url, body.encode("utf8"))
self.render(request)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual("@bob:test", channel.json_body["user_id"])
# Now, try and reuse it
- request, channel = self.make_request("POST", self.url, body.encode('utf8'))
+ request, channel = self.make_request("POST", self.url, body.encode("utf8"))
self.render(request)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
- self.assertEqual('unrecognised nonce', channel.json_body["error"])
+ self.assertEqual("unrecognised nonce", channel.json_body["error"])
def test_missing_parts(self):
"""
@@ -243,11 +243,11 @@ class UserRegisterTestCase(unittest.HomeserverTestCase):
# Must be present
body = json.dumps({})
- request, channel = self.make_request("POST", self.url, body.encode('utf8'))
+ request, channel = self.make_request("POST", self.url, body.encode("utf8"))
self.render(request)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
- self.assertEqual('nonce must be specified', channel.json_body["error"])
+ self.assertEqual("nonce must be specified", channel.json_body["error"])
#
# Username checks
@@ -255,35 +255,35 @@ class UserRegisterTestCase(unittest.HomeserverTestCase):
# Must be present
body = json.dumps({"nonce": nonce()})
- request, channel = self.make_request("POST", self.url, body.encode('utf8'))
+ request, channel = self.make_request("POST", self.url, body.encode("utf8"))
self.render(request)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
- self.assertEqual('username must be specified', channel.json_body["error"])
+ self.assertEqual("username must be specified", channel.json_body["error"])
# Must be a string
body = json.dumps({"nonce": nonce(), "username": 1234})
- request, channel = self.make_request("POST", self.url, body.encode('utf8'))
+ request, channel = self.make_request("POST", self.url, body.encode("utf8"))
self.render(request)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
- self.assertEqual('Invalid username', channel.json_body["error"])
+ self.assertEqual("Invalid username", channel.json_body["error"])
# Must not have null bytes
body = json.dumps({"nonce": nonce(), "username": u"abcd\u0000"})
- request, channel = self.make_request("POST", self.url, body.encode('utf8'))
+ request, channel = self.make_request("POST", self.url, body.encode("utf8"))
self.render(request)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
- self.assertEqual('Invalid username', channel.json_body["error"])
+ self.assertEqual("Invalid username", channel.json_body["error"])
# Must not have null bytes
body = json.dumps({"nonce": nonce(), "username": "a" * 1000})
- request, channel = self.make_request("POST", self.url, body.encode('utf8'))
+ request, channel = self.make_request("POST", self.url, body.encode("utf8"))
self.render(request)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
- self.assertEqual('Invalid username', channel.json_body["error"])
+ self.assertEqual("Invalid username", channel.json_body["error"])
#
# Password checks
@@ -291,37 +291,37 @@ class UserRegisterTestCase(unittest.HomeserverTestCase):
# Must be present
body = json.dumps({"nonce": nonce(), "username": "a"})
- request, channel = self.make_request("POST", self.url, body.encode('utf8'))
+ request, channel = self.make_request("POST", self.url, body.encode("utf8"))
self.render(request)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
- self.assertEqual('password must be specified', channel.json_body["error"])
+ self.assertEqual("password must be specified", channel.json_body["error"])
# Must be a string
body = json.dumps({"nonce": nonce(), "username": "a", "password": 1234})
- request, channel = self.make_request("POST", self.url, body.encode('utf8'))
+ request, channel = self.make_request("POST", self.url, body.encode("utf8"))
self.render(request)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
- self.assertEqual('Invalid password', channel.json_body["error"])
+ self.assertEqual("Invalid password", channel.json_body["error"])
# Must not have null bytes
body = json.dumps(
{"nonce": nonce(), "username": "a", "password": u"abcd\u0000"}
)
- request, channel = self.make_request("POST", self.url, body.encode('utf8'))
+ request, channel = self.make_request("POST", self.url, body.encode("utf8"))
self.render(request)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
- self.assertEqual('Invalid password', channel.json_body["error"])
+ self.assertEqual("Invalid password", channel.json_body["error"])
# Super long
body = json.dumps({"nonce": nonce(), "username": "a", "password": "A" * 1000})
- request, channel = self.make_request("POST", self.url, body.encode('utf8'))
+ request, channel = self.make_request("POST", self.url, body.encode("utf8"))
self.render(request)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
- self.assertEqual('Invalid password', channel.json_body["error"])
+ self.assertEqual("Invalid password", channel.json_body["error"])
#
# user_type check
@@ -336,11 +336,11 @@ class UserRegisterTestCase(unittest.HomeserverTestCase):
"user_type": "invalid",
}
)
- request, channel = self.make_request("POST", self.url, body.encode('utf8'))
+ request, channel = self.make_request("POST", self.url, body.encode("utf8"))
self.render(request)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
- self.assertEqual('Invalid user type', channel.json_body["error"])
+ self.assertEqual("Invalid user type", channel.json_body["error"])
class ShutdownRoomTestCase(unittest.HomeserverTestCase):
@@ -396,7 +396,7 @@ class ShutdownRoomTestCase(unittest.HomeserverTestCase):
url = "admin/shutdown_room/" + room_id
request, channel = self.make_request(
"POST",
- url.encode('ascii'),
+ url.encode("ascii"),
json.dumps({"new_room_user_id": self.admin_user}),
access_token=self.admin_user_tok,
)
@@ -421,7 +421,7 @@ class ShutdownRoomTestCase(unittest.HomeserverTestCase):
url = "rooms/%s/state/m.room.history_visibility" % (room_id,)
request, channel = self.make_request(
"PUT",
- url.encode('ascii'),
+ url.encode("ascii"),
json.dumps({"history_visibility": "world_readable"}),
access_token=self.other_user_token,
)
@@ -432,7 +432,7 @@ class ShutdownRoomTestCase(unittest.HomeserverTestCase):
url = "admin/shutdown_room/" + room_id
request, channel = self.make_request(
"POST",
- url.encode('ascii'),
+ url.encode("ascii"),
json.dumps({"new_room_user_id": self.admin_user}),
access_token=self.admin_user_tok,
)
@@ -449,7 +449,7 @@ class ShutdownRoomTestCase(unittest.HomeserverTestCase):
url = "rooms/%s/initialSync" % (room_id,)
request, channel = self.make_request(
- "GET", url.encode('ascii'), access_token=self.admin_user_tok
+ "GET", url.encode("ascii"), access_token=self.admin_user_tok
)
self.render(request)
self.assertEqual(
@@ -458,7 +458,7 @@ class ShutdownRoomTestCase(unittest.HomeserverTestCase):
url = "events?timeout=0&room_id=" + room_id
request, channel = self.make_request(
- "GET", url.encode('ascii'), access_token=self.admin_user_tok
+ "GET", url.encode("ascii"), access_token=self.admin_user_tok
)
self.render(request)
self.assertEqual(
@@ -486,7 +486,7 @@ class DeleteGroupTestCase(unittest.HomeserverTestCase):
# Create a new group
request, channel = self.make_request(
"POST",
- "/create_group".encode('ascii'),
+ "/create_group".encode("ascii"),
access_token=self.admin_user_tok,
content={"localpart": "test"},
)
@@ -502,14 +502,14 @@ class DeleteGroupTestCase(unittest.HomeserverTestCase):
url = "/groups/%s/admin/users/invite/%s" % (group_id, self.other_user)
request, channel = self.make_request(
- "PUT", url.encode('ascii'), access_token=self.admin_user_tok, content={}
+ "PUT", url.encode("ascii"), access_token=self.admin_user_tok, content={}
)
self.render(request)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
url = "/groups/%s/self/accept_invite" % (group_id,)
request, channel = self.make_request(
- "PUT", url.encode('ascii'), access_token=self.other_user_token, content={}
+ "PUT", url.encode("ascii"), access_token=self.other_user_token, content={}
)
self.render(request)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@@ -522,7 +522,7 @@ class DeleteGroupTestCase(unittest.HomeserverTestCase):
url = "/admin/delete_group/" + group_id
request, channel = self.make_request(
"POST",
- url.encode('ascii'),
+ url.encode("ascii"),
access_token=self.admin_user_tok,
content={"localpart": "test"},
)
@@ -544,7 +544,7 @@ class DeleteGroupTestCase(unittest.HomeserverTestCase):
url = "/groups/%s/profile" % (group_id,)
request, channel = self.make_request(
- "GET", url.encode('ascii'), access_token=self.admin_user_tok
+ "GET", url.encode("ascii"), access_token=self.admin_user_tok
)
self.render(request)
@@ -556,7 +556,7 @@ class DeleteGroupTestCase(unittest.HomeserverTestCase):
"""Returns the list of groups the user is in (given their access token)
"""
request, channel = self.make_request(
- "GET", "/joined_groups".encode('ascii'), access_token=access_token
+ "GET", "/joined_groups".encode("ascii"), access_token=access_token
)
self.render(request)
diff --git a/tests/rest/client/test_consent.py b/tests/rest/client/test_consent.py
index efc5a99db3..6803b372ac 100644
--- a/tests/rest/client/test_consent.py
+++ b/tests/rest/client/test_consent.py
@@ -42,17 +42,17 @@ class ConsentResourceTestCase(unittest.HomeserverTestCase):
# Make some temporary templates...
temp_consent_path = self.mktemp()
os.mkdir(temp_consent_path)
- os.mkdir(os.path.join(temp_consent_path, 'en'))
+ os.mkdir(os.path.join(temp_consent_path, "en"))
config["user_consent"] = {
"version": "1",
"template_dir": os.path.abspath(temp_consent_path),
}
- with open(os.path.join(temp_consent_path, "en/1.html"), 'w') as f:
+ with open(os.path.join(temp_consent_path, "en/1.html"), "w") as f:
f.write("{{version}},{{has_consented}}")
- with open(os.path.join(temp_consent_path, "en/success.html"), 'w') as f:
+ with open(os.path.join(temp_consent_path, "en/success.html"), "w") as f:
f.write("yay!")
hs = self.setup_test_homeserver(config=config)
@@ -88,7 +88,7 @@ class ConsentResourceTestCase(unittest.HomeserverTestCase):
self.assertEqual(channel.code, 200)
# Get the version from the body, and whether we've consented
- version, consented = channel.result["body"].decode('ascii').split(",")
+ version, consented = channel.result["body"].decode("ascii").split(",")
self.assertEqual(consented, "False")
# POST to the consent page, saying we've agreed
@@ -111,6 +111,6 @@ class ConsentResourceTestCase(unittest.HomeserverTestCase):
# Get the version from the body, and check that it's the version we
# agreed to, and that we've consented to it.
- version, consented = channel.result["body"].decode('ascii').split(",")
+ version, consented = channel.result["body"].decode("ascii").split(",")
self.assertEqual(consented, "True")
self.assertEqual(version, "1")
diff --git a/tests/rest/client/test_identity.py b/tests/rest/client/test_identity.py
index c9b9eff83e..f81f81602e 100644
--- a/tests/rest/client/test_identity.py
+++ b/tests/rest/client/test_identity.py
@@ -39,9 +39,7 @@ class IdentityDisabledTestCase(unittest.HomeserverTestCase):
def make_homeserver(self, reactor, clock):
config = self.default_config()
- config["trusted_third_party_id_servers"] = [
- "testis",
- ]
+ config["trusted_third_party_id_servers"] = ["testis"]
config["enable_3pid_lookup"] = False
self.hs = self.setup_test_homeserver(config=config)
@@ -53,7 +51,7 @@ class IdentityDisabledTestCase(unittest.HomeserverTestCase):
def test_3pid_invite_disabled(self):
request, channel = self.make_request(
- b"POST", "/createRoom", b"{}", access_token=self.tok,
+ b"POST", "/createRoom", b"{}", access_token=self.tok
)
self.render(request)
self.assertEquals(channel.result["code"], b"200", channel.result)
@@ -65,18 +63,18 @@ class IdentityDisabledTestCase(unittest.HomeserverTestCase):
"address": "test@example.com",
}
request_data = json.dumps(params)
- request_url = (
- "/rooms/%s/invite" % (room_id)
- ).encode('ascii')
+ request_url = ("/rooms/%s/invite" % (room_id)).encode("ascii")
request, channel = self.make_request(
- b"POST", request_url, request_data, access_token=self.tok,
+ b"POST", request_url, request_data, access_token=self.tok
)
self.render(request)
self.assertEquals(channel.result["code"], b"403", channel.result)
def test_3pid_lookup_disabled(self):
- url = ("/_matrix/client/unstable/account/3pid/lookup"
- "?id_server=testis&medium=email&address=foo@bar.baz")
+ url = (
+ "/_matrix/client/unstable/account/3pid/lookup"
+ "?id_server=testis&medium=email&address=foo@bar.baz"
+ )
request, channel = self.make_request("GET", url, access_token=self.tok)
self.render(request)
self.assertEqual(channel.result["code"], b"403", channel.result)
@@ -85,20 +83,11 @@ class IdentityDisabledTestCase(unittest.HomeserverTestCase):
url = "/_matrix/client/unstable/account/3pid/bulk_lookup"
data = {
"id_server": "testis",
- "threepids": [
- [
- "email",
- "foo@bar.baz"
- ],
- [
- "email",
- "john.doe@matrix.org"
- ]
- ]
+ "threepids": [["email", "foo@bar.baz"], ["email", "john.doe@matrix.org"]],
}
request_data = json.dumps(data)
request, channel = self.make_request(
- "POST", url, request_data, access_token=self.tok,
+ "POST", url, request_data, access_token=self.tok
)
self.render(request)
self.assertEqual(channel.result["code"], b"403", channel.result)
@@ -118,20 +107,14 @@ class IdentityEnabledTestCase(unittest.HomeserverTestCase):
config = self.default_config()
config["enable_3pid_lookup"] = True
- config["trusted_third_party_id_servers"] = [
- "testis",
- ]
-
- mock_http_client = Mock(spec=[
- "get_json",
- "post_json_get_json",
- ])
+ config["trusted_third_party_id_servers"] = ["testis"]
+
+ mock_http_client = Mock(spec=["get_json", "post_json_get_json"])
mock_http_client.get_json.return_value = defer.succeed((200, "{}"))
mock_http_client.post_json_get_json.return_value = defer.succeed((200, "{}"))
self.hs = self.setup_test_homeserver(
- config=config,
- simple_http_client=mock_http_client,
+ config=config, simple_http_client=mock_http_client
)
return self.hs
@@ -142,7 +125,7 @@ class IdentityEnabledTestCase(unittest.HomeserverTestCase):
def test_3pid_invite_enabled(self):
request, channel = self.make_request(
- b"POST", "/createRoom", b"{}", access_token=self.tok,
+ b"POST", "/createRoom", b"{}", access_token=self.tok
)
self.render(request)
self.assertEquals(channel.result["code"], b"200", channel.result)
@@ -154,70 +137,46 @@ class IdentityEnabledTestCase(unittest.HomeserverTestCase):
"address": "test@example.com",
}
request_data = json.dumps(params)
- request_url = ("/rooms/%s/invite" % (room_id)).encode('ascii')
+ request_url = ("/rooms/%s/invite" % (room_id)).encode("ascii")
request, channel = self.make_request(
- b"POST", request_url, request_data, access_token=self.tok,
+ b"POST", request_url, request_data, access_token=self.tok
)
self.render(request)
get_json = self.hs.get_simple_http_client().get_json
get_json.assert_called_once_with(
"https://testis/_matrix/identity/api/v1/lookup",
- {
- "address": "test@example.com",
- "medium": "email",
- },
+ {"address": "test@example.com", "medium": "email"},
)
def test_3pid_lookup_enabled(self):
- url = ("/_matrix/client/unstable/account/3pid/lookup"
- "?id_server=testis&medium=email&address=foo@bar.baz")
+ url = (
+ "/_matrix/client/unstable/account/3pid/lookup"
+ "?id_server=testis&medium=email&address=foo@bar.baz"
+ )
request, channel = self.make_request("GET", url, access_token=self.tok)
self.render(request)
get_json = self.hs.get_simple_http_client().get_json
get_json.assert_called_once_with(
"https://testis/_matrix/identity/api/v1/lookup",
- {
- "address": "foo@bar.baz",
- "medium": "email",
- },
+ {"address": "foo@bar.baz", "medium": "email"},
)
def test_3pid_bulk_lookup_enabled(self):
url = "/_matrix/client/unstable/account/3pid/bulk_lookup"
data = {
"id_server": "testis",
- "threepids": [
- [
- "email",
- "foo@bar.baz"
- ],
- [
- "email",
- "john.doe@matrix.org"
- ]
- ]
+ "threepids": [["email", "foo@bar.baz"], ["email", "john.doe@matrix.org"]],
}
request_data = json.dumps(data)
request, channel = self.make_request(
- "POST", url, request_data, access_token=self.tok,
+ "POST", url, request_data, access_token=self.tok
)
self.render(request)
post_json = self.hs.get_simple_http_client().post_json_get_json
post_json.assert_called_once_with(
"https://testis/_matrix/identity/api/v1/bulk_lookup",
- {
- "threepids": [
- [
- "email",
- "foo@bar.baz"
- ],
- [
- "email",
- "john.doe@matrix.org"
- ]
- ],
- },
+ {"threepids": [["email", "foo@bar.baz"], ["email", "john.doe@matrix.org"]]},
)
diff --git a/tests/rest/client/test_retention.py b/tests/rest/client/test_retention.py
index d0deff5a3b..4303f95206 100644
--- a/tests/rest/client/test_retention.py
+++ b/tests/rest/client/test_retention.py
@@ -61,9 +61,7 @@ class RetentionTestCase(unittest.HomeserverTestCase):
self.helper.send_state(
room_id=room_id,
event_type=EventTypes.Retention,
- body={
- "max_lifetime": one_day_ms * 4,
- },
+ body={"max_lifetime": one_day_ms * 4},
tok=self.token,
expect_code=400,
)
@@ -71,9 +69,7 @@ class RetentionTestCase(unittest.HomeserverTestCase):
self.helper.send_state(
room_id=room_id,
event_type=EventTypes.Retention,
- body={
- "max_lifetime": one_hour_ms,
- },
+ body={"max_lifetime": one_hour_ms},
tok=self.token,
expect_code=400,
)
@@ -89,9 +85,7 @@ class RetentionTestCase(unittest.HomeserverTestCase):
self.helper.send_state(
room_id=room_id,
event_type=EventTypes.Retention,
- body={
- "max_lifetime": lifetime,
- },
+ body={"max_lifetime": lifetime},
tok=self.token,
)
@@ -114,48 +108,32 @@ class RetentionTestCase(unittest.HomeserverTestCase):
events = []
# Send a first event, which should be filtered out at the end of the test.
- resp = self.helper.send(
- room_id=room_id,
- body="1",
- tok=self.token,
- )
+ resp = self.helper.send(room_id=room_id, body="1", tok=self.token)
# Get the event from the store so that we end up with a FrozenEvent that we can
# give to filter_events_for_client. We need to do this now because the event won't
# be in the database anymore after it has expired.
- events.append(self.get_success(
- store.get_event(
- resp.get("event_id")
- )
- ))
+ events.append(self.get_success(store.get_event(resp.get("event_id"))))
# Advance the time by 2 days. We're using the default retention policy, therefore
# after this the first event will still be valid.
self.reactor.advance(one_day_ms * 2 / 1000)
# Send another event, which shouldn't get filtered out.
- resp = self.helper.send(
- room_id=room_id,
- body="2",
- tok=self.token,
- )
+ resp = self.helper.send(room_id=room_id, body="2", tok=self.token)
valid_event_id = resp.get("event_id")
- events.append(self.get_success(
- store.get_event(
- valid_event_id
- )
- ))
+ events.append(self.get_success(store.get_event(valid_event_id)))
# Advance the time by anothe 2 days. After this, the first event should be
# outdated but not the second one.
self.reactor.advance(one_day_ms * 2 / 1000)
# Run filter_events_for_client with our list of FrozenEvents.
- filtered_events = self.get_success(filter_events_for_client(
- store, self.user_id, events
- ))
+ filtered_events = self.get_success(
+ filter_events_for_client(store, self.user_id, events)
+ )
# We should only get one event back.
self.assertEqual(len(filtered_events), 1, filtered_events)
@@ -171,28 +149,22 @@ class RetentionTestCase(unittest.HomeserverTestCase):
# Send a first event to the room. This is the event we'll want to be purged at the
# end of the test.
- resp = self.helper.send(
- room_id=room_id,
- body="1",
- tok=self.token,
- )
+ resp = self.helper.send(room_id=room_id, body="1", tok=self.token)
expired_event_id = resp.get("event_id")
# Check that we can retrieve the event.
expired_event = self.get_event(room_id, expired_event_id)
- self.assertEqual(expired_event.get("content", {}).get("body"), "1", expired_event)
+ self.assertEqual(
+ expired_event.get("content", {}).get("body"), "1", expired_event
+ )
# Advance the time.
self.reactor.advance(increment / 1000)
# Send another event. We need this because the purge job won't purge the most
# recent event in the room.
- resp = self.helper.send(
- room_id=room_id,
- body="2",
- tok=self.token,
- )
+ resp = self.helper.send(room_id=room_id, body="2", tok=self.token)
valid_event_id = resp.get("event_id")
@@ -232,15 +204,12 @@ class RetentionNoDefaultPolicyTestCase(unittest.HomeserverTestCase):
def make_homeserver(self, reactor, clock):
config = self.default_config()
config["default_room_version"] = "1"
- config["retention"] = {
- "enabled": True,
- }
+ config["retention"] = {"enabled": True}
mock_federation_client = Mock(spec=["backfill"])
self.hs = self.setup_test_homeserver(
- config=config,
- federation_client=mock_federation_client,
+ config=config, federation_client=mock_federation_client
)
return self.hs
@@ -267,9 +236,7 @@ class RetentionNoDefaultPolicyTestCase(unittest.HomeserverTestCase):
self.helper.send_state(
room_id=room_id,
event_type=EventTypes.Retention,
- body={
- "max_lifetime": one_day_ms * 35,
- },
+ body={"max_lifetime": one_day_ms * 35},
tok=self.token,
)
@@ -278,28 +245,22 @@ class RetentionNoDefaultPolicyTestCase(unittest.HomeserverTestCase):
def _test_retention(self, room_id, expected_code_for_first_event=200):
# Send a first event to the room. This is the event we'll want to be purged at the
# end of the test.
- resp = self.helper.send(
- room_id=room_id,
- body="1",
- tok=self.token,
- )
+ resp = self.helper.send(room_id=room_id, body="1", tok=self.token)
first_event_id = resp.get("event_id")
# Check that we can retrieve the event.
expired_event = self.get_event(room_id, first_event_id)
- self.assertEqual(expired_event.get("content", {}).get("body"), "1", expired_event)
+ self.assertEqual(
+ expired_event.get("content", {}).get("body"), "1", expired_event
+ )
# Advance the time by a month.
self.reactor.advance(one_day_ms * 30 / 1000)
# Send another event. We need this because the purge job won't purge the most
# recent event in the room.
- resp = self.helper.send(
- room_id=room_id,
- body="2",
- tok=self.token,
- )
+ resp = self.helper.send(room_id=room_id, body="2", tok=self.token)
second_event_id = resp.get("event_id")
@@ -312,7 +273,9 @@ class RetentionNoDefaultPolicyTestCase(unittest.HomeserverTestCase):
)
if expected_code_for_first_event == 200:
- self.assertEqual(first_event.get("content", {}).get("body"), "1", first_event)
+ self.assertEqual(
+ first_event.get("content", {}).get("body"), "1", first_event
+ )
# Check that the event that hasn't been purged can still be retrieved.
second_event = self.get_event(room_id, second_event_id)
diff --git a/tests/rest/client/test_room_access_rules.py b/tests/rest/client/test_room_access_rules.py
index 13caea3b01..c17b0c226d 100644
--- a/tests/rest/client/test_room_access_rules.py
+++ b/tests/rest/client/test_room_access_rules.py
@@ -49,15 +49,11 @@ class RoomAccessTestCase(unittest.HomeserverTestCase):
config["third_party_event_rules"] = {
"module": "synapse.third_party_rules.access_rules.RoomAccessRules",
"config": {
- "domains_forbidden_when_restricted": [
- "forbidden_domain"
- ],
+ "domains_forbidden_when_restricted": ["forbidden_domain"],
"id_server": "testis",
- }
+ },
}
- config["trusted_third_party_id_servers"] = [
- "testis",
- ]
+ config["trusted_third_party_id_servers"] = ["testis"]
def send_invite(destination, room_id, event_id, pdu):
return defer.succeed(pdu)
@@ -67,31 +63,28 @@ class RoomAccessTestCase(unittest.HomeserverTestCase):
return defer.succeed({"hs": address_domain})
def post_urlencoded_get_json(uri, args={}, headers=None):
- token = ''.join(random.choice(string.ascii_letters) for _ in range(10))
- return defer.succeed({
- "token": token,
- "public_keys": [
- {
- "public_key": "serverpublickey",
- "key_validity_url": "https://testis/pubkey/isvalid",
- },
- {
- "public_key": "phemeralpublickey",
- "key_validity_url": "https://testis/pubkey/ephemeral/isvalid",
- },
- ],
- "display_name": "f...@b...",
- })
-
- mock_federation_client = Mock(spec=[
- "send_invite",
- ])
+ token = "".join(random.choice(string.ascii_letters) for _ in range(10))
+ return defer.succeed(
+ {
+ "token": token,
+ "public_keys": [
+ {
+ "public_key": "serverpublickey",
+ "key_validity_url": "https://testis/pubkey/isvalid",
+ },
+ {
+ "public_key": "phemeralpublickey",
+ "key_validity_url": "https://testis/pubkey/ephemeral/isvalid",
+ },
+ ],
+ "display_name": "f...@b...",
+ }
+ )
+
+ mock_federation_client = Mock(spec=["send_invite"])
mock_federation_client.send_invite.side_effect = send_invite
- mock_http_client = Mock(spec=[
- "get_json",
- "post_urlencoded_get_json"
- ])
+ mock_http_client = Mock(spec=["get_json", "post_urlencoded_get_json"])
# Mocking the response for /info on the IS API.
mock_http_client.get_json.side_effect = get_json
# Mocking the response for /store-invite on the IS API.
@@ -164,74 +157,80 @@ class RoomAccessTestCase(unittest.HomeserverTestCase):
# rule to restricted.
preset_room_id = self.create_room(preset=RoomCreationPreset.PUBLIC_CHAT)
self.assertEqual(
- self.current_rule_in_room(preset_room_id), ACCESS_RULE_RESTRICTED,
+ self.current_rule_in_room(preset_room_id), ACCESS_RULE_RESTRICTED
)
# Creating a room with the public join rule in its initial state should succeed
# and set the access rule to restricted.
- init_state_room_id = self.create_room(initial_state=[{
- "type": "m.room.join_rules",
- "content": {
- "join_rule": JoinRules.PUBLIC,
- },
- }])
+ init_state_room_id = self.create_room(
+ initial_state=[
+ {
+ "type": "m.room.join_rules",
+ "content": {"join_rule": JoinRules.PUBLIC},
+ }
+ ]
+ )
self.assertEqual(
- self.current_rule_in_room(init_state_room_id), ACCESS_RULE_RESTRICTED,
+ self.current_rule_in_room(init_state_room_id), ACCESS_RULE_RESTRICTED
)
# Changing access rule to unrestricted should fail.
self.change_rule_in_room(
- preset_room_id, ACCESS_RULE_UNRESTRICTED, expected_code=403,
+ preset_room_id, ACCESS_RULE_UNRESTRICTED, expected_code=403
)
self.change_rule_in_room(
- init_state_room_id, ACCESS_RULE_UNRESTRICTED, expected_code=403,
+ init_state_room_id, ACCESS_RULE_UNRESTRICTED, expected_code=403
)
# Changing access rule to direct should fail.
+ self.change_rule_in_room(preset_room_id, ACCESS_RULE_DIRECT, expected_code=403)
self.change_rule_in_room(
- preset_room_id, ACCESS_RULE_DIRECT, expected_code=403,
- )
- self.change_rule_in_room(
- init_state_room_id, ACCESS_RULE_DIRECT, expected_code=403,
+ init_state_room_id, ACCESS_RULE_DIRECT, expected_code=403
)
# Changing join rule to public in an unrestricted room should fail.
self.change_join_rule_in_room(
- self.unrestricted_room, JoinRules.PUBLIC, expected_code=403,
+ self.unrestricted_room, JoinRules.PUBLIC, expected_code=403
)
# Changing join rule to public in an direct room should fail.
self.change_join_rule_in_room(
- self.direct_rooms[0], JoinRules.PUBLIC, expected_code=403,
+ self.direct_rooms[0], JoinRules.PUBLIC, expected_code=403
)
# Creating a new room with the public_chat preset and an access rule that isn't
# restricted should fail.
self.create_room(
- preset=RoomCreationPreset.PUBLIC_CHAT, rule=ACCESS_RULE_UNRESTRICTED,
+ preset=RoomCreationPreset.PUBLIC_CHAT,
+ rule=ACCESS_RULE_UNRESTRICTED,
expected_code=400,
)
self.create_room(
- preset=RoomCreationPreset.PUBLIC_CHAT, rule=ACCESS_RULE_DIRECT,
+ preset=RoomCreationPreset.PUBLIC_CHAT,
+ rule=ACCESS_RULE_DIRECT,
expected_code=400,
)
# Creating a room with the public join rule in its initial state and an access
# rule that isn't restricted should fail.
self.create_room(
- initial_state=[{
- "type": "m.room.join_rules",
- "content": {
- "join_rule": JoinRules.PUBLIC,
- },
- }], rule=ACCESS_RULE_UNRESTRICTED, expected_code=400,
+ initial_state=[
+ {
+ "type": "m.room.join_rules",
+ "content": {"join_rule": JoinRules.PUBLIC},
+ }
+ ],
+ rule=ACCESS_RULE_UNRESTRICTED,
+ expected_code=400,
)
self.create_room(
- initial_state=[{
- "type": "m.room.join_rules",
- "content": {
- "join_rule": JoinRules.PUBLIC,
- },
- }], rule=ACCESS_RULE_DIRECT, expected_code=400,
+ initial_state=[
+ {
+ "type": "m.room.join_rules",
+ "content": {"join_rule": JoinRules.PUBLIC},
+ }
+ ],
+ rule=ACCESS_RULE_DIRECT,
+ expected_code=400,
)
def test_restricted(self):
@@ -405,12 +404,7 @@ class RoomAccessTestCase(unittest.HomeserverTestCase):
self.helper.send_state(
room_id=self.unrestricted_room,
event_type=EventTypes.PowerLevels,
- body={
- "users": {
- self.user_id: 100,
- "@test:not_forbidden_domain": 10,
- },
- },
+ body={"users": {self.user_id: 100, "@test:not_forbidden_domain": 10}},
tok=self.tok,
expect_code=200,
)
@@ -421,10 +415,7 @@ class RoomAccessTestCase(unittest.HomeserverTestCase):
room_id=self.unrestricted_room,
event_type=EventTypes.PowerLevels,
body={
- "users": {
- self.user_id: 100,
- "@test:not_forbidden_domain": 10,
- },
+ "users": {self.user_id: 100, "@test:not_forbidden_domain": 10},
"users_default": 10,
},
tok=self.tok,
@@ -436,12 +427,7 @@ class RoomAccessTestCase(unittest.HomeserverTestCase):
self.helper.send_state(
room_id=self.unrestricted_room,
event_type=EventTypes.PowerLevels,
- body={
- "users": {
- self.user_id: 100,
- "@test:forbidden_domain": 10,
- },
- },
+ body={"users": {self.user_id: 100, "@test:forbidden_domain": 10}},
tok=self.tok,
expect_code=403,
)
@@ -459,9 +445,7 @@ class RoomAccessTestCase(unittest.HomeserverTestCase):
# We can't change the rule from restricted to direct.
self.change_rule_in_room(
- room_id=self.restricted_room,
- new_rule=ACCESS_RULE_DIRECT,
- expected_code=403,
+ room_id=self.restricted_room, new_rule=ACCESS_RULE_DIRECT, expected_code=403
)
# We can't change the rule from unrestricted to restricted.
@@ -498,12 +482,7 @@ class RoomAccessTestCase(unittest.HomeserverTestCase):
"""
avatar_content = {
- "info": {
- "h": 398,
- "mimetype": "image/jpeg",
- "size": 31037,
- "w": 394
- },
+ "info": {"h": 398, "mimetype": "image/jpeg", "size": 31037, "w": 394},
"url": "mxc://example.org/JWEIFJgwEIhweiWJE",
}
@@ -536,9 +515,7 @@ class RoomAccessTestCase(unittest.HomeserverTestCase):
chat, in which case it's forbidden.
"""
- name_content = {
- "name": "My super room",
- }
+ name_content = {"name": "My super room"}
self.helper.send_state(
room_id=self.restricted_room,
@@ -569,9 +546,7 @@ class RoomAccessTestCase(unittest.HomeserverTestCase):
direct chat, in which case it's forbidden.
"""
- topic_content = {
- "topic": "Welcome to this room",
- }
+ topic_content = {"topic": "Welcome to this room"}
self.helper.send_state(
room_id=self.restricted_room,
@@ -608,15 +583,15 @@ class RoomAccessTestCase(unittest.HomeserverTestCase):
"public_keys": [
{
"key_validity_url": "https://validity_url",
- "public_key": "ta8IQ0u1sp44HVpxYi7dFOdS/bfwDjcy4xLFlfY5KOA"
+ "public_key": "ta8IQ0u1sp44HVpxYi7dFOdS/bfwDjcy4xLFlfY5KOA",
},
{
"key_validity_url": "https://validity_url",
- "public_key": "4_9nzEeDwR5N9s51jPodBiLnqH43A2_g2InVT137t9I"
- }
+ "public_key": "4_9nzEeDwR5N9s51jPodBiLnqH43A2_g2InVT137t9I",
+ },
],
"key_validity_url": "https://validity_url",
- "public_key": "ta8IQ0u1sp44HVpxYi7dFOdS/bfwDjcy4xLFlfY5KOA"
+ "public_key": "ta8IQ0u1sp44HVpxYi7dFOdS/bfwDjcy4xLFlfY5KOA",
}
self.send_state_with_state_key(
@@ -646,22 +621,19 @@ class RoomAccessTestCase(unittest.HomeserverTestCase):
)
def create_room(
- self, direct=False, rule=None, preset=RoomCreationPreset.TRUSTED_PRIVATE_CHAT,
- initial_state=None, expected_code=200,
+ self,
+ direct=False,
+ rule=None,
+ preset=RoomCreationPreset.TRUSTED_PRIVATE_CHAT,
+ initial_state=None,
+ expected_code=200,
):
- content = {
- "is_direct": direct,
- "preset": preset,
- }
+ content = {"is_direct": direct, "preset": preset}
if rule:
- content["initial_state"] = [{
- "type": ACCESS_RULES_TYPE,
- "state_key": "",
- "content": {
- "rule": rule,
- }
- }]
+ content["initial_state"] = [
+ {"type": ACCESS_RULES_TYPE, "state_key": "", "content": {"rule": rule}}
+ ]
if initial_state:
if "initial_state" not in content:
@@ -694,9 +666,7 @@ class RoomAccessTestCase(unittest.HomeserverTestCase):
return channel.json_body["rule"]
def change_rule_in_room(self, room_id, new_rule, expected_code=200):
- data = {
- "rule": new_rule,
- }
+ data = {"rule": new_rule}
request, channel = self.make_request(
"PUT",
"/_matrix/client/r0/rooms/%s/state/%s" % (room_id, ACCESS_RULES_TYPE),
@@ -708,9 +678,7 @@ class RoomAccessTestCase(unittest.HomeserverTestCase):
self.assertEqual(channel.code, expected_code, channel.result)
def change_join_rule_in_room(self, room_id, new_join_rule, expected_code=200):
- data = {
- "join_rule": new_join_rule,
- }
+ data = {"join_rule": new_join_rule}
request, channel = self.make_request(
"PUT",
"/_matrix/client/r0/rooms/%s/state/%s" % (room_id, EventTypes.JoinRules),
@@ -722,11 +690,7 @@ class RoomAccessTestCase(unittest.HomeserverTestCase):
self.assertEqual(channel.code, expected_code, channel.result)
def send_threepid_invite(self, address, room_id, expected_code=200):
- params = {
- "id_server": "testis",
- "medium": "email",
- "address": address,
- }
+ params = {"id_server": "testis", "medium": "email", "address": address}
request, channel = self.make_request(
"POST",
@@ -741,7 +705,9 @@ class RoomAccessTestCase(unittest.HomeserverTestCase):
self, room_id, event_type, state_key, body, tok, expect_code=200
):
path = "/_matrix/client/r0/rooms/%s/state/%s/%s" % (
- room_id, event_type, state_key
+ room_id,
+ event_type,
+ state_key,
)
request, channel = self.make_request(
diff --git a/tests/rest/client/v1/test_profile.py b/tests/rest/client/v1/test_profile.py
index 6958430608..02b4b8f5eb 100644
--- a/tests/rest/client/v1/test_profile.py
+++ b/tests/rest/client/v1/test_profile.py
@@ -183,7 +183,7 @@ class ProfileTestCase(unittest.HomeserverTestCase):
def test_set_displayname(self):
request, channel = self.make_request(
"PUT",
- "/profile/%s/displayname" % (self.owner, ),
+ "/profile/%s/displayname" % (self.owner,),
content=json.dumps({"displayname": "test"}),
access_token=self.owner_tok,
)
@@ -197,7 +197,7 @@ class ProfileTestCase(unittest.HomeserverTestCase):
"""Attempts to set a stupid displayname should get a 400"""
request, channel = self.make_request(
"PUT",
- "/profile/%s/displayname" % (self.owner, ),
+ "/profile/%s/displayname" % (self.owner,),
content=json.dumps({"displayname": "test" * 100}),
access_token=self.owner_tok,
)
@@ -209,8 +209,7 @@ class ProfileTestCase(unittest.HomeserverTestCase):
def get_displayname(self):
request, channel = self.make_request(
- "GET",
- "/profile/%s/displayname" % (self.owner, ),
+ "GET", "/profile/%s/displayname" % (self.owner,)
)
self.render(request)
self.assertEqual(channel.code, 200, channel.result)
diff --git a/tests/rest/client/v1/test_rooms.py b/tests/rest/client/v1/test_rooms.py
index 2d64b338be..fe741637f5 100644
--- a/tests/rest/client/v1/test_rooms.py
+++ b/tests/rest/client/v1/test_rooms.py
@@ -79,7 +79,7 @@ class RoomPermissionsTestCase(RoomBase):
# send a message in one of the rooms
self.created_rmid_msg_path = (
"rooms/%s/send/m.room.message/a1" % (self.created_rmid)
- ).encode('ascii')
+ ).encode("ascii")
request, channel = self.make_request(
"PUT", self.created_rmid_msg_path, b'{"msgtype":"m.text","body":"test msg"}'
)
@@ -89,7 +89,7 @@ class RoomPermissionsTestCase(RoomBase):
# set topic for public room
request, channel = self.make_request(
"PUT",
- ("rooms/%s/state/m.room.topic" % self.created_public_rmid).encode('ascii'),
+ ("rooms/%s/state/m.room.topic" % self.created_public_rmid).encode("ascii"),
b'{"topic":"Public Room Topic"}',
)
self.render(request)
@@ -193,7 +193,7 @@ class RoomPermissionsTestCase(RoomBase):
request, channel = self.make_request("GET", topic_path)
self.render(request)
self.assertEquals(200, channel.code, msg=channel.result["body"])
- self.assert_dict(json.loads(topic_content.decode('utf8')), channel.json_body)
+ self.assert_dict(json.loads(topic_content.decode("utf8")), channel.json_body)
# set/get topic in created PRIVATE room and left, expect 403
self.helper.leave(room=self.created_rmid, user=self.user_id)
@@ -497,7 +497,7 @@ class RoomTopicTestCase(RoomBase):
def test_invalid_puts(self):
# missing keys or invalid json
- request, channel = self.make_request("PUT", self.path, '{}')
+ request, channel = self.make_request("PUT", self.path, "{}")
self.render(request)
self.assertEquals(400, channel.code, msg=channel.result["body"])
@@ -515,11 +515,11 @@ class RoomTopicTestCase(RoomBase):
self.render(request)
self.assertEquals(400, channel.code, msg=channel.result["body"])
- request, channel = self.make_request("PUT", self.path, 'text only')
+ request, channel = self.make_request("PUT", self.path, "text only")
self.render(request)
self.assertEquals(400, channel.code, msg=channel.result["body"])
- request, channel = self.make_request("PUT", self.path, '')
+ request, channel = self.make_request("PUT", self.path, "")
self.render(request)
self.assertEquals(400, channel.code, msg=channel.result["body"])
@@ -572,7 +572,7 @@ class RoomMemberStateTestCase(RoomBase):
def test_invalid_puts(self):
path = "/rooms/%s/state/m.room.member/%s" % (self.room_id, self.user_id)
# missing keys or invalid json
- request, channel = self.make_request("PUT", path, '{}')
+ request, channel = self.make_request("PUT", path, "{}")
self.render(request)
self.assertEquals(400, channel.code, msg=channel.result["body"])
@@ -590,11 +590,11 @@ class RoomMemberStateTestCase(RoomBase):
self.render(request)
self.assertEquals(400, channel.code, msg=channel.result["body"])
- request, channel = self.make_request("PUT", path, 'text only')
+ request, channel = self.make_request("PUT", path, "text only")
self.render(request)
self.assertEquals(400, channel.code, msg=channel.result["body"])
- request, channel = self.make_request("PUT", path, '')
+ request, channel = self.make_request("PUT", path, "")
self.render(request)
self.assertEquals(400, channel.code, msg=channel.result["body"])
@@ -604,7 +604,7 @@ class RoomMemberStateTestCase(RoomBase):
Membership.JOIN,
Membership.LEAVE,
)
- request, channel = self.make_request("PUT", path, content.encode('ascii'))
+ request, channel = self.make_request("PUT", path, content.encode("ascii"))
self.render(request)
self.assertEquals(400, channel.code, msg=channel.result["body"])
@@ -616,7 +616,7 @@ class RoomMemberStateTestCase(RoomBase):
# valid join message (NOOP since we made the room)
content = '{"membership":"%s"}' % Membership.JOIN
- request, channel = self.make_request("PUT", path, content.encode('ascii'))
+ request, channel = self.make_request("PUT", path, content.encode("ascii"))
self.render(request)
self.assertEquals(200, channel.code, msg=channel.result["body"])
@@ -678,7 +678,7 @@ class RoomMessagesTestCase(RoomBase):
def test_invalid_puts(self):
path = "/rooms/%s/send/m.room.message/mid1" % (urlparse.quote(self.room_id))
# missing keys or invalid json
- request, channel = self.make_request("PUT", path, b'{}')
+ request, channel = self.make_request("PUT", path, b"{}")
self.render(request)
self.assertEquals(400, channel.code, msg=channel.result["body"])
@@ -696,11 +696,11 @@ class RoomMessagesTestCase(RoomBase):
self.render(request)
self.assertEquals(400, channel.code, msg=channel.result["body"])
- request, channel = self.make_request("PUT", path, b'text only')
+ request, channel = self.make_request("PUT", path, b"text only")
self.render(request)
self.assertEquals(400, channel.code, msg=channel.result["body"])
- request, channel = self.make_request("PUT", path, b'')
+ request, channel = self.make_request("PUT", path, b"")
self.render(request)
self.assertEquals(400, channel.code, msg=channel.result["body"])
@@ -786,7 +786,7 @@ class RoomMessageListTestCase(RoomBase):
self.render(request)
self.assertEquals(200, channel.code)
self.assertTrue("start" in channel.json_body)
- self.assertEquals(token, channel.json_body['start'])
+ self.assertEquals(token, channel.json_body["start"])
self.assertTrue("chunk" in channel.json_body)
self.assertTrue("end" in channel.json_body)
@@ -798,7 +798,7 @@ class RoomMessageListTestCase(RoomBase):
self.render(request)
self.assertEquals(200, channel.code)
self.assertTrue("start" in channel.json_body)
- self.assertEquals(token, channel.json_body['start'])
+ self.assertEquals(token, channel.json_body["start"])
self.assertTrue("chunk" in channel.json_body)
self.assertTrue("end" in channel.json_body)
@@ -961,9 +961,7 @@ class PerRoomProfilesForbiddenTestCase(unittest.HomeserverTestCase):
# Set a profile for the test user
self.displayname = "test user"
- data = {
- "displayname": self.displayname,
- }
+ data = {"displayname": self.displayname}
request_data = json.dumps(data)
request, channel = self.make_request(
"PUT",
@@ -977,16 +975,12 @@ class PerRoomProfilesForbiddenTestCase(unittest.HomeserverTestCase):
self.room_id = self.helper.create_room_as(self.user_id, tok=self.tok)
def test_per_room_profile_forbidden(self):
- data = {
- "membership": "join",
- "displayname": "other test user"
- }
+ data = {"membership": "join", "displayname": "other test user"}
request_data = json.dumps(data)
request, channel = self.make_request(
"PUT",
- "/_matrix/client/r0/rooms/%s/state/m.room.member/%s" % (
- self.room_id, self.user_id,
- ),
+ "/_matrix/client/r0/rooms/%s/state/m.room.member/%s"
+ % (self.room_id, self.user_id),
request_data,
access_token=self.tok,
)
diff --git a/tests/rest/client/v1/utils.py b/tests/rest/client/v1/utils.py
index 449a69183f..cdded88b7f 100644
--- a/tests/rest/client/v1/utils.py
+++ b/tests/rest/client/v1/utils.py
@@ -44,7 +44,7 @@ class RestHelper(object):
path = path + "?access_token=%s" % tok
request, channel = make_request(
- self.hs.get_reactor(), "POST", path, json.dumps(content).encode('utf8')
+ self.hs.get_reactor(), "POST", path, json.dumps(content).encode("utf8")
)
render(request, self.resource, self.hs.get_reactor())
@@ -93,7 +93,7 @@ class RestHelper(object):
data = {"membership": membership}
request, channel = make_request(
- self.hs.get_reactor(), "PUT", path, json.dumps(data).encode('utf8')
+ self.hs.get_reactor(), "PUT", path, json.dumps(data).encode("utf8")
)
render(request, self.resource, self.hs.get_reactor())
@@ -117,7 +117,7 @@ class RestHelper(object):
path = path + "?access_token=%s" % tok
request, channel = make_request(
- self.hs.get_reactor(), "PUT", path, json.dumps(content).encode('utf8')
+ self.hs.get_reactor(), "PUT", path, json.dumps(content).encode("utf8")
)
render(request, self.resource, self.hs.get_reactor())
diff --git a/tests/rest/client/v2_alpha/test_account.py b/tests/rest/client/v2_alpha/test_account.py
index 32adf88c35..9fed900f4a 100644
--- a/tests/rest/client/v2_alpha/test_account.py
+++ b/tests/rest/client/v2_alpha/test_account.py
@@ -135,9 +135,7 @@ class PasswordResetTestCase(unittest.HomeserverTestCase):
self.assertEquals(len(self.email_attempts), 1)
# Attempt to reset password without clicking the link
- self._reset_password(
- new_password, session_id, client_secret, expected_code=401,
- )
+ self._reset_password(new_password, session_id, client_secret, expected_code=401)
# Assert we can log in with the old password
self.login("kermit", old_password)
@@ -172,9 +170,7 @@ class PasswordResetTestCase(unittest.HomeserverTestCase):
session_id = "weasle"
# Attempt to reset password without even requesting an email
- self._reset_password(
- new_password, session_id, client_secret, expected_code=401,
- )
+ self._reset_password(new_password, session_id, client_secret, expected_code=401)
# Assert we can log in with the old password
self.login("kermit", old_password)
@@ -259,19 +255,18 @@ class DeactivateTestCase(unittest.HomeserverTestCase):
user_id = self.register_user("kermit", "test")
tok = self.login("kermit", "test")
- request_data = json.dumps({
- "auth": {
- "type": "m.login.password",
- "user": user_id,
- "password": "test",
- },
- "erase": False,
- })
+ request_data = json.dumps(
+ {
+ "auth": {
+ "type": "m.login.password",
+ "user": user_id,
+ "password": "test",
+ },
+ "erase": False,
+ }
+ )
request, channel = self.make_request(
- "POST",
- "account/deactivate",
- request_data,
- access_token=tok,
+ "POST", "account/deactivate", request_data, access_token=tok
)
self.render(request)
self.assertEqual(request.code, 200)
diff --git a/tests/rest/client/v2_alpha/test_capabilities.py b/tests/rest/client/v2_alpha/test_capabilities.py
index bce5b0cf4c..b9e01c9418 100644
--- a/tests/rest/client/v2_alpha/test_capabilities.py
+++ b/tests/rest/client/v2_alpha/test_capabilities.py
@@ -47,15 +47,15 @@ class CapabilitiesTestCase(unittest.HomeserverTestCase):
request, channel = self.make_request("GET", self.url, access_token=access_token)
self.render(request)
- capabilities = channel.json_body['capabilities']
+ capabilities = channel.json_body["capabilities"]
self.assertEqual(channel.code, 200)
- for room_version in capabilities['m.room_versions']['available'].keys():
+ for room_version in capabilities["m.room_versions"]["available"].keys():
self.assertTrue(room_version in KNOWN_ROOM_VERSIONS, "" + room_version)
self.assertEqual(
self.config.default_room_version.identifier,
- capabilities['m.room_versions']['default'],
+ capabilities["m.room_versions"]["default"],
)
def test_get_change_password_capabilities(self):
@@ -66,16 +66,16 @@ class CapabilitiesTestCase(unittest.HomeserverTestCase):
request, channel = self.make_request("GET", self.url, access_token=access_token)
self.render(request)
- capabilities = channel.json_body['capabilities']
+ capabilities = channel.json_body["capabilities"]
self.assertEqual(channel.code, 200)
# Test case where password is handled outside of Synapse
- self.assertTrue(capabilities['m.change_password']['enabled'])
+ self.assertTrue(capabilities["m.change_password"]["enabled"])
self.get_success(self.store.user_set_password_hash(user, None))
request, channel = self.make_request("GET", self.url, access_token=access_token)
self.render(request)
- capabilities = channel.json_body['capabilities']
+ capabilities = channel.json_body["capabilities"]
self.assertEqual(channel.code, 200)
- self.assertFalse(capabilities['m.change_password']['enabled'])
+ self.assertFalse(capabilities["m.change_password"]["enabled"])
diff --git a/tests/rest/client/v2_alpha/test_password_policy.py b/tests/rest/client/v2_alpha/test_password_policy.py
index 17c22fe751..37f970c6b0 100644
--- a/tests/rest/client/v2_alpha/test_password_policy.py
+++ b/tests/rest/client/v2_alpha/test_password_policy.py
@@ -60,9 +60,7 @@ class PasswordPolicyTestCase(unittest.HomeserverTestCase):
}
config = self.default_config()
- config["password_config"] = {
- "policy": self.policy,
- }
+ config["password_config"] = {"policy": self.policy}
hs = self.setup_test_homeserver(config=config)
return hs
@@ -70,17 +68,23 @@ class PasswordPolicyTestCase(unittest.HomeserverTestCase):
def test_get_policy(self):
"""Tests if the /password_policy endpoint returns the configured policy."""
- request, channel = self.make_request("GET", "/_matrix/client/r0/password_policy")
+ request, channel = self.make_request(
+ "GET", "/_matrix/client/r0/password_policy"
+ )
self.render(request)
self.assertEqual(channel.code, 200, channel.result)
- self.assertEqual(channel.json_body, {
- "m.minimum_length": 10,
- "m.require_digit": True,
- "m.require_symbol": True,
- "m.require_lowercase": True,
- "m.require_uppercase": True,
- }, channel.result)
+ self.assertEqual(
+ channel.json_body,
+ {
+ "m.minimum_length": 10,
+ "m.require_digit": True,
+ "m.require_symbol": True,
+ "m.require_lowercase": True,
+ "m.require_uppercase": True,
+ },
+ channel.result,
+ )
def test_password_too_short(self):
request_data = json.dumps({"username": "kermit", "password": "shorty"})
@@ -89,9 +93,7 @@ class PasswordPolicyTestCase(unittest.HomeserverTestCase):
self.assertEqual(channel.code, 400, channel.result)
self.assertEqual(
- channel.json_body["errcode"],
- Codes.PASSWORD_TOO_SHORT,
- channel.result,
+ channel.json_body["errcode"], Codes.PASSWORD_TOO_SHORT, channel.result
)
def test_password_no_digit(self):
@@ -101,9 +103,7 @@ class PasswordPolicyTestCase(unittest.HomeserverTestCase):
self.assertEqual(channel.code, 400, channel.result)
self.assertEqual(
- channel.json_body["errcode"],
- Codes.PASSWORD_NO_DIGIT,
- channel.result,
+ channel.json_body["errcode"], Codes.PASSWORD_NO_DIGIT, channel.result
)
def test_password_no_symbol(self):
@@ -113,9 +113,7 @@ class PasswordPolicyTestCase(unittest.HomeserverTestCase):
self.assertEqual(channel.code, 400, channel.result)
self.assertEqual(
- channel.json_body["errcode"],
- Codes.PASSWORD_NO_SYMBOL,
- channel.result,
+ channel.json_body["errcode"], Codes.PASSWORD_NO_SYMBOL, channel.result
)
def test_password_no_uppercase(self):
@@ -125,9 +123,7 @@ class PasswordPolicyTestCase(unittest.HomeserverTestCase):
self.assertEqual(channel.code, 400, channel.result)
self.assertEqual(
- channel.json_body["errcode"],
- Codes.PASSWORD_NO_UPPERCASE,
- channel.result,
+ channel.json_body["errcode"], Codes.PASSWORD_NO_UPPERCASE, channel.result
)
def test_password_no_lowercase(self):
@@ -137,9 +133,7 @@ class PasswordPolicyTestCase(unittest.HomeserverTestCase):
self.assertEqual(channel.code, 400, channel.result)
self.assertEqual(
- channel.json_body["errcode"],
- Codes.PASSWORD_NO_LOWERCASE,
- channel.result,
+ channel.json_body["errcode"], Codes.PASSWORD_NO_LOWERCASE, channel.result
)
def test_password_compliant(self):
@@ -161,14 +155,16 @@ class PasswordPolicyTestCase(unittest.HomeserverTestCase):
user_id = self.register_user("kermit", compliant_password)
tok = self.login("kermit", compliant_password)
- request_data = json.dumps({
- "new_password": not_compliant_password,
- "auth": {
- "password": compliant_password,
- "type": LoginType.PASSWORD,
- "user": user_id,
+ request_data = json.dumps(
+ {
+ "new_password": not_compliant_password,
+ "auth": {
+ "password": compliant_password,
+ "type": LoginType.PASSWORD,
+ "user": user_id,
+ },
}
- })
+ )
request, channel = self.make_request(
"POST",
"/_matrix/client/r0/account/password",
diff --git a/tests/rest/client/v2_alpha/test_register.py b/tests/rest/client/v2_alpha/test_register.py
index a5c7aaa9c0..085978b4a6 100644
--- a/tests/rest/client/v2_alpha/test_register.py
+++ b/tests/rest/client/v2_alpha/test_register.py
@@ -206,9 +206,7 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
class RegisterHideProfileTestCase(unittest.HomeserverTestCase):
- servlets = [
- synapse.rest.admin.register_servlets_for_client_rest_resource,
- ]
+ servlets = [synapse.rest.admin.register_servlets_for_client_rest_resource]
def make_homeserver(self, reactor, clock):
@@ -219,15 +217,11 @@ class RegisterHideProfileTestCase(unittest.HomeserverTestCase):
config["show_users_in_user_directory"] = False
config["replicate_user_profiles_to"] = ["fakeserver"]
- mock_http_client = Mock(spec=[
- "get_json",
- "post_json_get_json",
- ])
+ mock_http_client = Mock(spec=["get_json", "post_json_get_json"])
mock_http_client.post_json_get_json.return_value = defer.succeed((200, "{}"))
self.hs = self.setup_test_homeserver(
- config=config,
- simple_http_client=mock_http_client,
+ config=config, simple_http_client=mock_http_client
)
return self.hs
@@ -376,14 +370,11 @@ class AccountValidityUserDirectoryTestCase(unittest.HomeserverTestCase):
config["replicate_user_profiles_to"] = "test.is"
# Mock homeserver requests to an identity server
- mock_http_client = Mock(spec=[
- "post_json_get_json",
- ])
+ mock_http_client = Mock(spec=["post_json_get_json"])
mock_http_client.post_json_get_json.return_value = defer.succeed((200, "{}"))
self.hs = self.setup_test_homeserver(
- config=config,
- simple_http_client=mock_http_client,
+ config=config, simple_http_client=mock_http_client
)
return self.hs
@@ -524,7 +515,7 @@ class AccountValidityRenewalByEmailTestCase(unittest.HomeserverTestCase):
config["email"] = {
"enable_notifs": True,
"template_dir": os.path.abspath(
- pkg_resources.resource_filename('synapse', 'res/templates')
+ pkg_resources.resource_filename("synapse", "res/templates")
),
"expiry_template_html": "notice_expiry.html",
"expiry_template_text": "notice_expiry.txt",
@@ -624,19 +615,18 @@ class AccountValidityRenewalByEmailTestCase(unittest.HomeserverTestCase):
(user_id, tok) = self.create_user()
- request_data = json.dumps({
- "auth": {
- "type": "m.login.password",
- "user": user_id,
- "password": "monkey",
- },
- "erase": False,
- })
+ request_data = json.dumps(
+ {
+ "auth": {
+ "type": "m.login.password",
+ "user": user_id,
+ "password": "monkey",
+ },
+ "erase": False,
+ }
+ )
request, channel = self.make_request(
- "POST",
- "account/deactivate",
- request_data,
- access_token=tok,
+ "POST", "account/deactivate", request_data, access_token=tok
)
self.render(request)
self.assertEqual(request.code, 200, channel.result)
@@ -700,9 +690,7 @@ class AccountValidityRenewalByEmailTestCase(unittest.HomeserverTestCase):
class AccountValidityBackgroundJobTestCase(unittest.HomeserverTestCase):
- servlets = [
- synapse.rest.admin.register_servlets_for_client_rest_resource,
- ]
+ servlets = [synapse.rest.admin.register_servlets_for_client_rest_resource]
def make_homeserver(self, reactor, clock):
self.validity_period = 10
@@ -711,9 +699,7 @@ class AccountValidityBackgroundJobTestCase(unittest.HomeserverTestCase):
config = self.default_config()
config["enable_registration"] = True
- config["account_validity"] = {
- "enabled": False,
- }
+ config["account_validity"] = {"enabled": False}
self.hs = self.setup_test_homeserver(config=config)
self.hs.config.account_validity.period = self.validity_period
diff --git a/tests/rest/media/v1/test_base.py b/tests/rest/media/v1/test_base.py
index 00688a7325..aa6a5f880c 100644
--- a/tests/rest/media/v1/test_base.py
+++ b/tests/rest/media/v1/test_base.py
@@ -24,14 +24,14 @@ class GetFileNameFromHeadersTests(unittest.TestCase):
b"inline; filename=abc.txt": u"abc.txt",
b'inline; filename="azerty"': u"azerty",
b'inline; filename="aze%20rty"': u"aze%20rty",
- b'inline; filename="aze\"rty"': u'aze"rty',
+ 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({b'Content-Disposition': [hdr]})
+ res = get_filename_from_headers({b"Content-Disposition": [hdr]})
self.assertEqual(
res,
expected,
diff --git a/tests/rest/media/v1/test_media_storage.py b/tests/rest/media/v1/test_media_storage.py
index 1069a44145..3c6480b3b2 100644
--- a/tests/rest/media/v1/test_media_storage.py
+++ b/tests/rest/media/v1/test_media_storage.py
@@ -143,7 +143,7 @@ class MediaRepoTests(unittest.HomeserverTestCase):
def prepare(self, reactor, clock, hs):
self.media_repo = hs.get_media_repository_resource()
- self.download_resource = self.media_repo.children[b'download']
+ self.download_resource = self.media_repo.children[b"download"]
# smol png
self.end_content = unhexlify(
@@ -171,7 +171,7 @@ class MediaRepoTests(unittest.HomeserverTestCase):
headers = {
b"Content-Length": [b"%d" % (len(self.end_content))],
- b"Content-Type": [b'image/png'],
+ b"Content-Type": [b"image/png"],
}
if content_disposition:
headers[b"Content-Disposition"] = [content_disposition]
@@ -204,7 +204,7 @@ class MediaRepoTests(unittest.HomeserverTestCase):
correctly decode it as the UTF-8 string, and use filename* in the
response.
"""
- filename = parse.quote(u"\u2603".encode('utf8')).encode('ascii')
+ filename = parse.quote(u"\u2603".encode("utf8")).encode("ascii")
channel = self._req(b"inline; filename*=utf-8''" + filename + b".png")
headers = channel.headers
diff --git a/tests/rest/media/v1/test_url_preview.py b/tests/rest/media/v1/test_url_preview.py
index 1ab0f7293a..1fcb0dd4df 100644
--- a/tests/rest/media/v1/test_url_preview.py
+++ b/tests/rest/media/v1/test_url_preview.py
@@ -55,10 +55,10 @@ class URLPreviewTests(unittest.HomeserverTestCase):
hijack_auth = True
user_id = "@test:user"
end_content = (
- b'<html><head>'
+ b"<html><head>"
b'<meta property="og:title" content="~matrix~" />'
b'<meta property="og:description" content="hi" />'
- b'</head></html>'
+ b"</head></html>"
)
def make_homeserver(self, reactor, clock):
@@ -98,7 +98,7 @@ class URLPreviewTests(unittest.HomeserverTestCase):
def prepare(self, reactor, clock, hs):
self.media_repo = hs.get_media_repository_resource()
- self.preview_url = self.media_repo.children[b'preview_url']
+ self.preview_url = self.media_repo.children[b"preview_url"]
self.lookups = {}
@@ -109,7 +109,7 @@ class URLPreviewTests(unittest.HomeserverTestCase):
hostName,
portNumber=0,
addressTypes=None,
- transportSemantics='TCP',
+ transportSemantics="TCP",
):
resolution = HostResolution(hostName)
@@ -118,7 +118,7 @@ class URLPreviewTests(unittest.HomeserverTestCase):
raise DNSLookupError("OH NO")
for i in self.lookups[hostName]:
- resolutionReceiver.addressResolved(i[0]('TCP', i[1], portNumber))
+ resolutionReceiver.addressResolved(i[0]("TCP", i[1], portNumber))
resolutionReceiver.resolutionComplete()
return resolutionReceiver
@@ -184,11 +184,11 @@ class URLPreviewTests(unittest.HomeserverTestCase):
self.lookups["matrix.org"] = [(IPv4Address, "8.8.8.8")]
end_content = (
- b'<html><head>'
+ b"<html><head>"
b'<meta http-equiv="Content-Type" content="text/html; charset=windows-1251"/>'
b'<meta property="og:title" content="\xe4\xea\xe0" />'
b'<meta property="og:description" content="hi" />'
- b'</head></html>'
+ b"</head></html>"
)
request, channel = self.make_request(
@@ -204,7 +204,7 @@ class URLPreviewTests(unittest.HomeserverTestCase):
client.dataReceived(
(
b"HTTP/1.0 200 OK\r\nContent-Length: %d\r\n"
- b"Content-Type: text/html; charset=\"utf8\"\r\n\r\n"
+ b'Content-Type: text/html; charset="utf8"\r\n\r\n'
)
% (len(end_content),)
+ end_content
@@ -218,10 +218,10 @@ class URLPreviewTests(unittest.HomeserverTestCase):
self.lookups["matrix.org"] = [(IPv4Address, "8.8.8.8")]
end_content = (
- b'<html><head>'
+ b"<html><head>"
b'<meta property="og:title" content="\xe4\xea\xe0" />'
b'<meta property="og:description" content="hi" />'
- b'</head></html>'
+ b"</head></html>"
)
request, channel = self.make_request(
@@ -237,7 +237,7 @@ class URLPreviewTests(unittest.HomeserverTestCase):
client.dataReceived(
(
b"HTTP/1.0 200 OK\r\nContent-Length: %d\r\n"
- b"Content-Type: text/html; charset=\"windows-1251\"\r\n\r\n"
+ b'Content-Type: text/html; charset="windows-1251"\r\n\r\n'
)
% (len(end_content),)
+ end_content
@@ -293,8 +293,8 @@ class URLPreviewTests(unittest.HomeserverTestCase):
self.assertEqual(
channel.json_body,
{
- 'errcode': 'M_UNKNOWN',
- 'error': 'DNS resolution failure during URL preview generation',
+ "errcode": "M_UNKNOWN",
+ "error": "DNS resolution failure during URL preview generation",
},
)
@@ -314,8 +314,8 @@ class URLPreviewTests(unittest.HomeserverTestCase):
self.assertEqual(
channel.json_body,
{
- 'errcode': 'M_UNKNOWN',
- 'error': 'DNS resolution failure during URL preview generation',
+ "errcode": "M_UNKNOWN",
+ "error": "DNS resolution failure during URL preview generation",
},
)
@@ -334,8 +334,8 @@ class URLPreviewTests(unittest.HomeserverTestCase):
self.assertEqual(
channel.json_body,
{
- 'errcode': 'M_UNKNOWN',
- 'error': 'IP address blocked by IP blacklist entry',
+ "errcode": "M_UNKNOWN",
+ "error": "IP address blocked by IP blacklist entry",
},
)
self.assertEqual(channel.code, 403)
@@ -354,8 +354,8 @@ class URLPreviewTests(unittest.HomeserverTestCase):
self.assertEqual(
channel.json_body,
{
- 'errcode': 'M_UNKNOWN',
- 'error': 'IP address blocked by IP blacklist entry',
+ "errcode": "M_UNKNOWN",
+ "error": "IP address blocked by IP blacklist entry",
},
)
@@ -410,8 +410,8 @@ class URLPreviewTests(unittest.HomeserverTestCase):
self.assertEqual(
channel.json_body,
{
- 'errcode': 'M_UNKNOWN',
- 'error': 'DNS resolution failure during URL preview generation',
+ "errcode": "M_UNKNOWN",
+ "error": "DNS resolution failure during URL preview generation",
},
)
@@ -435,8 +435,8 @@ class URLPreviewTests(unittest.HomeserverTestCase):
self.assertEqual(
channel.json_body,
{
- 'errcode': 'M_UNKNOWN',
- 'error': 'DNS resolution failure during URL preview generation',
+ "errcode": "M_UNKNOWN",
+ "error": "DNS resolution failure during URL preview generation",
},
)
@@ -456,7 +456,7 @@ class URLPreviewTests(unittest.HomeserverTestCase):
self.assertEqual(
channel.json_body,
{
- 'errcode': 'M_UNKNOWN',
- 'error': 'DNS resolution failure during URL preview generation',
+ "errcode": "M_UNKNOWN",
+ "error": "DNS resolution failure during URL preview generation",
},
)
diff --git a/tests/rulecheck/test_domainrulecheck.py b/tests/rulecheck/test_domainrulecheck.py
index 564fad0d77..1accc70dc9 100644
--- a/tests/rulecheck/test_domainrulecheck.py
+++ b/tests/rulecheck/test_domainrulecheck.py
@@ -33,7 +33,7 @@ class DomainRuleCheckerTestCase(unittest.TestCase):
"source_one": ["target_one", "target_two"],
"source_two": ["target_two"],
},
- "domains_prevented_from_being_invited_to_published_rooms": ["target_two"]
+ "domains_prevented_from_being_invited_to_published_rooms": ["target_two"],
}
check = DomainRuleChecker(config)
self.assertTrue(
@@ -55,14 +55,14 @@ class DomainRuleCheckerTestCase(unittest.TestCase):
# User can invite internal user to a published room
self.assertTrue(
check.user_may_invite(
- "test:source_one", "test1:target_one", None, "room", False, True,
+ "test:source_one", "test1:target_one", None, "room", False, True
)
)
# User can invite external user to a non-published room
self.assertTrue(
check.user_may_invite(
- "test:source_one", "test:target_two", None, "room", False, False,
+ "test:source_one", "test:target_two", None, "room", False, False
)
)
@@ -100,7 +100,7 @@ class DomainRuleCheckerTestCase(unittest.TestCase):
# User cannot invite external user to a published room
self.assertTrue(
check.user_may_invite(
- "test:source_one", "test:target_two", None, "room", False, True,
+ "test:source_one", "test:target_two", None, "room", False, True
)
)
@@ -165,9 +165,7 @@ class DomainRuleCheckerRoomTestCase(unittest.HomeserverTestCase):
def make_homeserver(self, reactor, clock):
config = self.default_config()
- config["trusted_third_party_id_servers"] = [
- "localhost",
- ]
+ config["trusted_third_party_id_servers"] = ["localhost"]
config["spam_checker"] = {
"module": "synapse.rulecheck.domain_rule_checker.DomainRuleChecker",
@@ -302,9 +300,7 @@ class DomainRuleCheckerRoomTestCase(unittest.HomeserverTestCase):
)
self.helper.join(
- room_id, self.normal_user_id,
- tok=self.normal_access_token,
- expect_code=200,
+ room_id, self.normal_user_id, tok=self.normal_access_token, expect_code=200
)
self.helper.invite(
@@ -318,11 +314,7 @@ class DomainRuleCheckerRoomTestCase(unittest.HomeserverTestCase):
request, channel = self.make_request(
"POST",
"rooms/%s/invite" % (room_id),
- {
- "address": "foo@bar.com",
- "medium": "email",
- "id_server": "localhost"
- },
+ {"address": "foo@bar.com", "medium": "email", "id_server": "localhost"},
access_token=self.normal_access_token,
)
self.render(request)
diff --git a/tests/server.py b/tests/server.py
index aa0958f6e9..d10c0603e9 100644
--- a/tests/server.py
+++ b/tests/server.py
@@ -46,7 +46,7 @@ class FakeChannel(object):
def json_body(self):
if not self.result:
raise Exception("No result yet.")
- return json.loads(self.result["body"].decode('utf8'))
+ return json.loads(self.result["body"].decode("utf8"))
@property
def code(self):
@@ -151,10 +151,10 @@ def make_request(
Tuple[synapse.http.site.SynapseRequest, channel]
"""
if not isinstance(method, bytes):
- method = method.encode('ascii')
+ method = method.encode("ascii")
if not isinstance(path, bytes):
- path = path.encode('ascii')
+ path = path.encode("ascii")
# Decorate it to be the full path, if we're using shorthand
if shorthand and not path.startswith(b"/_matrix"):
@@ -165,7 +165,7 @@ def make_request(
path = b"/" + path
if isinstance(content, text_type):
- content = content.encode('utf8')
+ content = content.encode("utf8")
site = FakeSite()
channel = FakeChannel(reactor)
@@ -173,11 +173,11 @@ def make_request(
req = request(site, channel)
req.process = lambda: b""
req.content = BytesIO(content)
- req.postpath = list(map(unquote, path[1:].split(b'/')))
+ req.postpath = list(map(unquote, path[1:].split(b"/")))
if access_token:
req.requestHeaders.addRawHeader(
- b"Authorization", b"Bearer " + access_token.encode('ascii')
+ b"Authorization", b"Bearer " + access_token.encode("ascii")
)
if federation_auth_origin is not None:
@@ -242,7 +242,7 @@ class ThreadedMemoryReactorClock(MemoryReactorClock):
self.nameResolver = SimpleResolverComplexifier(FakeResolver())
super(ThreadedMemoryReactorClock, self).__init__()
- def listenUDP(self, port, protocol, interface='', maxPacketSize=8196):
+ def listenUDP(self, port, protocol, interface="", maxPacketSize=8196):
p = udp.Port(port, protocol, interface, maxPacketSize, self)
p.startListening()
self._udp.append(p)
@@ -371,7 +371,7 @@ class FakeTransport(object):
disconnecting = False
disconnected = False
- buffer = attr.ib(default=b'')
+ buffer = attr.ib(default=b"")
producer = attr.ib(default=None)
autoflush = attr.ib(default=True)
diff --git a/tests/server_notices/test_resource_limits_server_notices.py b/tests/server_notices/test_resource_limits_server_notices.py
index 739ee59ce4..e1e0c3184d 100644
--- a/tests/server_notices/test_resource_limits_server_notices.py
+++ b/tests/server_notices/test_resource_limits_server_notices.py
@@ -20,7 +20,7 @@ from twisted.internet import defer
from synapse.api.constants import EventTypes, ServerNoticeMsgType
from synapse.api.errors import ResourceLimitError
from synapse.server_notices.resource_limits_server_notices import (
- ResourceLimitsServerNotices,
+ ResourceLimitsServerNotices
)
from tests import unittest
@@ -109,7 +109,7 @@ class TestResourceLimitsServerNotices(unittest.HomeserverTestCase):
Test when user has blocked notice, but notice ought to be there (NOOP)
"""
self._rlsn._auth.check_auth_blocking = Mock(
- side_effect=ResourceLimitError(403, 'foo')
+ side_effect=ResourceLimitError(403, "foo")
)
mock_event = Mock(
@@ -128,7 +128,7 @@ class TestResourceLimitsServerNotices(unittest.HomeserverTestCase):
"""
self._rlsn._auth.check_auth_blocking = Mock(
- side_effect=ResourceLimitError(403, 'foo')
+ side_effect=ResourceLimitError(403, "foo")
)
self.get_success(self._rlsn.maybe_send_server_notice_to_user(self.user_id))
diff --git a/tests/state/test_v2.py b/tests/state/test_v2.py
index 9c5311d916..8d3845c870 100644
--- a/tests/state/test_v2.py
+++ b/tests/state/test_v2.py
@@ -181,7 +181,7 @@ class StateTestCase(unittest.TestCase):
id="PB",
sender=BOB,
type=EventTypes.PowerLevels,
- state_key='',
+ state_key="",
content={"users": {ALICE: 100, BOB: 50}},
),
]
@@ -229,14 +229,14 @@ class StateTestCase(unittest.TestCase):
id="PB",
sender=BOB,
type=EventTypes.PowerLevels,
- state_key='',
+ state_key="",
content={"users": {ALICE: 100, BOB: 50, CHARLIE: 50}},
),
FakeEvent(
id="PC",
sender=CHARLIE,
type=EventTypes.PowerLevels,
- state_key='',
+ state_key="",
content={"users": {ALICE: 100, BOB: 50, CHARLIE: 0}},
),
]
@@ -256,7 +256,7 @@ class StateTestCase(unittest.TestCase):
id="PA1",
sender=ALICE,
type=EventTypes.PowerLevels,
- state_key='',
+ state_key="",
content={"users": {ALICE: 100, BOB: 50}},
),
FakeEvent(
@@ -266,14 +266,14 @@ class StateTestCase(unittest.TestCase):
id="PA2",
sender=ALICE,
type=EventTypes.PowerLevels,
- state_key='',
+ state_key="",
content={"users": {ALICE: 100, BOB: 0}},
),
FakeEvent(
id="PB",
sender=BOB,
type=EventTypes.PowerLevels,
- state_key='',
+ state_key="",
content={"users": {ALICE: 100, BOB: 50}},
),
FakeEvent(
@@ -296,7 +296,7 @@ class StateTestCase(unittest.TestCase):
id="PA",
sender=ALICE,
type=EventTypes.PowerLevels,
- state_key='',
+ state_key="",
content={"users": {ALICE: 100, BOB: 50}},
),
FakeEvent(
@@ -326,7 +326,7 @@ class StateTestCase(unittest.TestCase):
id="PA1",
sender=ALICE,
type=EventTypes.PowerLevels,
- state_key='',
+ state_key="",
content={"users": {ALICE: 100, BOB: 50}},
),
FakeEvent(
@@ -336,14 +336,14 @@ class StateTestCase(unittest.TestCase):
id="PA2",
sender=ALICE,
type=EventTypes.PowerLevels,
- state_key='',
+ state_key="",
content={"users": {ALICE: 100, BOB: 0}},
),
FakeEvent(
id="PB",
sender=BOB,
type=EventTypes.PowerLevels,
- state_key='',
+ state_key="",
content={"users": {ALICE: 100, BOB: 50}},
),
FakeEvent(
diff --git a/tests/storage/test_appservice.py b/tests/storage/test_appservice.py
index 25a6c89ef5..622b16a071 100644
--- a/tests/storage/test_appservice.py
+++ b/tests/storage/test_appservice.py
@@ -74,7 +74,7 @@ class ApplicationServiceStoreTestCase(unittest.TestCase):
namespaces={},
)
# use the token as the filename
- with open(as_token, 'w') as outfile:
+ with open(as_token, "w") as outfile:
outfile.write(yaml.dump(as_yaml))
self.as_yaml_files.append(as_token)
@@ -135,7 +135,7 @@ class ApplicationServiceTransactionStoreTestCase(unittest.TestCase):
namespaces={},
)
# use the token as the filename
- with open(as_token, 'w') as outfile:
+ with open(as_token, "w") as outfile:
outfile.write(yaml.dump(as_yaml))
self.as_yaml_files.append(as_token)
diff --git a/tests/storage/test_client_ips.py b/tests/storage/test_client_ips.py
index b62eae7abc..59c6f8c227 100644
--- a/tests/storage/test_client_ips.py
+++ b/tests/storage/test_client_ips.py
@@ -94,11 +94,11 @@ class ClientIpStoreTestCase(unittest.HomeserverTestCase):
result,
[
{
- 'access_token': 'access_token',
- 'ip': 'ip',
- 'user_agent': 'user_agent',
- 'device_id': None,
- 'last_seen': 12345678000,
+ "access_token": "access_token",
+ "ip": "ip",
+ "user_agent": "user_agent",
+ "device_id": None,
+ "last_seen": 12345678000,
}
],
)
@@ -125,11 +125,11 @@ class ClientIpStoreTestCase(unittest.HomeserverTestCase):
result,
[
{
- 'access_token': 'access_token',
- 'ip': 'ip',
- 'user_agent': 'user_agent',
- 'device_id': None,
- 'last_seen': 12345878000,
+ "access_token": "access_token",
+ "ip": "ip",
+ "user_agent": "user_agent",
+ "device_id": None,
+ "last_seen": 12345878000,
}
],
)
diff --git a/tests/storage/test_devices.py b/tests/storage/test_devices.py
index 6396ccddb5..3cc18f9f1c 100644
--- a/tests/storage/test_devices.py
+++ b/tests/storage/test_devices.py
@@ -77,12 +77,12 @@ class DeviceStoreTestCase(tests.unittest.TestCase):
# Add two device updates with a single stream_id
yield self.store.add_device_change_to_streams(
- "user_id", device_ids, ["somehost"],
+ "user_id", device_ids, ["somehost"]
)
# Get all device updates ever meant for this remote
now_stream_id, device_updates = yield self.store.get_devices_by_remote(
- "somehost", -1, limit=100,
+ "somehost", -1, limit=100
)
# Check original device_ids are contained within these updates
@@ -95,19 +95,19 @@ class DeviceStoreTestCase(tests.unittest.TestCase):
# first add one device
device_ids1 = ["device_id0"]
yield self.store.add_device_change_to_streams(
- "user_id", device_ids1, ["someotherhost"],
+ "user_id", device_ids1, ["someotherhost"]
)
# then add 101
device_ids2 = ["device_id" + str(i + 1) for i in range(101)]
yield self.store.add_device_change_to_streams(
- "user_id", device_ids2, ["someotherhost"],
+ "user_id", device_ids2, ["someotherhost"]
)
# then one more
device_ids3 = ["newdevice"]
yield self.store.add_device_change_to_streams(
- "user_id", device_ids3, ["someotherhost"],
+ "user_id", device_ids3, ["someotherhost"]
)
#
@@ -116,20 +116,20 @@ class DeviceStoreTestCase(tests.unittest.TestCase):
# first we should get a single update
now_stream_id, device_updates = yield self.store.get_devices_by_remote(
- "someotherhost", -1, limit=100,
+ "someotherhost", -1, limit=100
)
self._check_devices_in_updates(device_ids1, device_updates)
# Then we should get an empty list back as the 101 devices broke the limit
now_stream_id, device_updates = yield self.store.get_devices_by_remote(
- "someotherhost", now_stream_id, limit=100,
+ "someotherhost", now_stream_id, limit=100
)
self.assertEqual(len(device_updates), 0)
# The 101 devices should've been cleared, so we should now just get one device
# update
now_stream_id, device_updates = yield self.store.get_devices_by_remote(
- "someotherhost", now_stream_id, limit=100,
+ "someotherhost", now_stream_id, limit=100
)
self._check_devices_in_updates(device_ids3, device_updates)
diff --git a/tests/storage/test_end_to_end_keys.py b/tests/storage/test_end_to_end_keys.py
index cd2bcd4ca3..c8ece15284 100644
--- a/tests/storage/test_end_to_end_keys.py
+++ b/tests/storage/test_end_to_end_keys.py
@@ -80,10 +80,10 @@ class EndToEndKeyStoreTestCase(tests.unittest.TestCase):
yield self.store.store_device("user2", "device1", None)
yield self.store.store_device("user2", "device2", None)
- yield self.store.set_e2e_device_keys("user1", "device1", now, 'json11')
- yield self.store.set_e2e_device_keys("user1", "device2", now, 'json12')
- yield self.store.set_e2e_device_keys("user2", "device1", now, 'json21')
- yield self.store.set_e2e_device_keys("user2", "device2", now, 'json22')
+ yield self.store.set_e2e_device_keys("user1", "device1", now, "json11")
+ yield self.store.set_e2e_device_keys("user1", "device2", now, "json12")
+ yield self.store.set_e2e_device_keys("user2", "device1", now, "json21")
+ yield self.store.set_e2e_device_keys("user2", "device2", now, "json22")
res = yield self.store.get_e2e_device_keys(
(("user1", "device1"), ("user2", "device2"))
diff --git a/tests/storage/test_event_federation.py b/tests/storage/test_event_federation.py
index 0d4e74d637..86c7ac350d 100644
--- a/tests/storage/test_event_federation.py
+++ b/tests/storage/test_event_federation.py
@@ -27,11 +27,11 @@ class EventFederationWorkerStoreTestCase(tests.unittest.TestCase):
@defer.inlineCallbacks
def test_get_prev_events_for_room(self):
- room_id = '@ROOM:local'
+ room_id = "@ROOM:local"
# add a bunch of events and hashes to act as forward extremities
def insert_event(txn, i):
- event_id = '$event_%i:local' % i
+ event_id = "$event_%i:local" % i
txn.execute(
(
@@ -45,19 +45,19 @@ class EventFederationWorkerStoreTestCase(tests.unittest.TestCase):
txn.execute(
(
- 'INSERT INTO event_forward_extremities (room_id, event_id) '
- 'VALUES (?, ?)'
+ "INSERT INTO event_forward_extremities (room_id, event_id) "
+ "VALUES (?, ?)"
),
(room_id, event_id),
)
txn.execute(
(
- 'INSERT INTO event_reference_hashes '
- '(event_id, algorithm, hash) '
+ "INSERT INTO event_reference_hashes "
+ "(event_id, algorithm, hash) "
"VALUES (?, 'sha256', ?)"
),
- (event_id, b'ffff'),
+ (event_id, b"ffff"),
)
for i in range(0, 11):
diff --git a/tests/storage/test_event_metrics.py b/tests/storage/test_event_metrics.py
index 19f9ccf5e0..d44359ff93 100644
--- a/tests/storage/test_event_metrics.py
+++ b/tests/storage/test_event_metrics.py
@@ -61,22 +61,24 @@ class ExtremStatisticsTestCase(HomeserverTestCase):
)
)
- expected = set([
- b'synapse_forward_extremities_bucket{le="1.0"} 0.0',
- b'synapse_forward_extremities_bucket{le="2.0"} 2.0',
- b'synapse_forward_extremities_bucket{le="3.0"} 2.0',
- b'synapse_forward_extremities_bucket{le="5.0"} 2.0',
- b'synapse_forward_extremities_bucket{le="7.0"} 3.0',
- b'synapse_forward_extremities_bucket{le="10.0"} 3.0',
- b'synapse_forward_extremities_bucket{le="15.0"} 3.0',
- b'synapse_forward_extremities_bucket{le="20.0"} 3.0',
- b'synapse_forward_extremities_bucket{le="50.0"} 3.0',
- b'synapse_forward_extremities_bucket{le="100.0"} 3.0',
- b'synapse_forward_extremities_bucket{le="200.0"} 3.0',
- b'synapse_forward_extremities_bucket{le="500.0"} 3.0',
- b'synapse_forward_extremities_bucket{le="+Inf"} 3.0',
- b'synapse_forward_extremities_count 3.0',
- b'synapse_forward_extremities_sum 10.0',
- ])
+ expected = set(
+ [
+ b'synapse_forward_extremities_bucket{le="1.0"} 0.0',
+ b'synapse_forward_extremities_bucket{le="2.0"} 2.0',
+ b'synapse_forward_extremities_bucket{le="3.0"} 2.0',
+ b'synapse_forward_extremities_bucket{le="5.0"} 2.0',
+ b'synapse_forward_extremities_bucket{le="7.0"} 3.0',
+ b'synapse_forward_extremities_bucket{le="10.0"} 3.0',
+ b'synapse_forward_extremities_bucket{le="15.0"} 3.0',
+ b'synapse_forward_extremities_bucket{le="20.0"} 3.0',
+ b'synapse_forward_extremities_bucket{le="50.0"} 3.0',
+ b'synapse_forward_extremities_bucket{le="100.0"} 3.0',
+ b'synapse_forward_extremities_bucket{le="200.0"} 3.0',
+ b'synapse_forward_extremities_bucket{le="500.0"} 3.0',
+ b'synapse_forward_extremities_bucket{le="+Inf"} 3.0',
+ b"synapse_forward_extremities_count 3.0",
+ b"synapse_forward_extremities_sum 10.0",
+ ]
+ )
self.assertEqual(items, expected)
diff --git a/tests/storage/test_monthly_active_users.py b/tests/storage/test_monthly_active_users.py
index f458c03054..0ce0b991f9 100644
--- a/tests/storage/test_monthly_active_users.py
+++ b/tests/storage/test_monthly_active_users.py
@@ -46,9 +46,9 @@ class MonthlyActiveUsersTestCase(unittest.HomeserverTestCase):
user3_email = "user3@matrix.org"
threepids = [
- {'medium': 'email', 'address': user1_email},
- {'medium': 'email', 'address': user2_email},
- {'medium': 'email', 'address': user3_email},
+ {"medium": "email", "address": user1_email},
+ {"medium": "email", "address": user2_email},
+ {"medium": "email", "address": user3_email},
]
# -1 because user3 is a support user and does not count
user_num = len(threepids) - 1
@@ -177,7 +177,7 @@ class MonthlyActiveUsersTestCase(unittest.HomeserverTestCase):
self.store.user_last_seen_monthly_active = Mock(
return_value=defer.succeed(None)
)
- self.store.populate_monthly_active_users('user_id')
+ self.store.populate_monthly_active_users("user_id")
self.pump()
self.store.upsert_monthly_active_user.assert_called_once()
@@ -188,7 +188,7 @@ class MonthlyActiveUsersTestCase(unittest.HomeserverTestCase):
self.store.user_last_seen_monthly_active = Mock(
return_value=defer.succeed(self.hs.get_clock().time_msec())
)
- self.store.populate_monthly_active_users('user_id')
+ self.store.populate_monthly_active_users("user_id")
self.pump()
self.store.upsert_monthly_active_user.assert_not_called()
@@ -198,13 +198,13 @@ class MonthlyActiveUsersTestCase(unittest.HomeserverTestCase):
self.assertEquals(self.get_success(count), 0)
# Test reserved users but no registered users
- user1 = '@user1:example.com'
- user2 = '@user2:example.com'
- user1_email = 'user1@example.com'
- user2_email = 'user2@example.com'
+ user1 = "@user1:example.com"
+ user2 = "@user2:example.com"
+ user1_email = "user1@example.com"
+ user2_email = "user2@example.com"
threepids = [
- {'medium': 'email', 'address': user1_email},
- {'medium': 'email', 'address': user2_email},
+ {"medium": "email", "address": user1_email},
+ {"medium": "email", "address": user2_email},
]
self.hs.config.mau_limits_reserved_threepids = threepids
self.store.runInteraction(
diff --git a/tests/storage/test_profile.py b/tests/storage/test_profile.py
index c125a0d797..13e9f8ec09 100644
--- a/tests/storage/test_profile.py
+++ b/tests/storage/test_profile.py
@@ -34,19 +34,16 @@ class ProfileStoreTestCase(unittest.TestCase):
@defer.inlineCallbacks
def test_displayname(self):
- yield self.store.set_profile_displayname(
- self.u_frank.localpart, "Frank", 1,
- )
+ yield self.store.set_profile_displayname(self.u_frank.localpart, "Frank", 1)
self.assertEquals(
- "Frank",
- (yield self.store.get_profile_displayname(self.u_frank.localpart))
+ "Frank", (yield self.store.get_profile_displayname(self.u_frank.localpart))
)
@defer.inlineCallbacks
def test_avatar_url(self):
yield self.store.set_profile_avatar_url(
- self.u_frank.localpart, "http://my.site/here", 1,
+ self.u_frank.localpart, "http://my.site/here", 1
)
self.assertEquals(
diff --git a/tests/storage/test_state.py b/tests/storage/test_state.py
index b6169436de..212a7ae765 100644
--- a/tests/storage/test_state.py
+++ b/tests/storage/test_state.py
@@ -76,10 +76,10 @@ class StateStoreTestCase(tests.unittest.TestCase):
@defer.inlineCallbacks
def test_get_state_groups_ids(self):
e1 = yield self.inject_state_event(
- self.room, self.u_alice, EventTypes.Create, '', {}
+ self.room, self.u_alice, EventTypes.Create, "", {}
)
e2 = yield self.inject_state_event(
- self.room, self.u_alice, EventTypes.Name, '', {"name": "test room"}
+ self.room, self.u_alice, EventTypes.Name, "", {"name": "test room"}
)
state_group_map = yield self.store.get_state_groups_ids(
@@ -89,16 +89,16 @@ class StateStoreTestCase(tests.unittest.TestCase):
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
def test_get_state_groups(self):
e1 = yield self.inject_state_event(
- self.room, self.u_alice, EventTypes.Create, '', {}
+ self.room, self.u_alice, EventTypes.Create, "", {}
)
e2 = yield self.inject_state_event(
- self.room, self.u_alice, EventTypes.Name, '', {"name": "test room"}
+ self.room, self.u_alice, EventTypes.Name, "", {"name": "test room"}
)
state_group_map = yield self.store.get_state_groups(self.room, [e2.event_id])
@@ -113,10 +113,10 @@ class StateStoreTestCase(tests.unittest.TestCase):
# this defaults to a linear DAG as each new injection defaults to whatever
# forward extremities are currently in the DB for this room.
e1 = yield self.inject_state_event(
- self.room, self.u_alice, EventTypes.Create, '', {}
+ self.room, self.u_alice, EventTypes.Create, "", {}
)
e2 = yield self.inject_state_event(
- self.room, self.u_alice, EventTypes.Name, '', {"name": "test room"}
+ self.room, self.u_alice, EventTypes.Name, "", {"name": "test room"}
)
e3 = yield self.inject_state_event(
self.room,
@@ -158,7 +158,7 @@ class StateStoreTestCase(tests.unittest.TestCase):
# check we can filter to the m.room.name event (with a '' state key)
state = yield self.store.get_state_for_event(
- e5.event_id, StateFilter.from_types([(EventTypes.Name, '')])
+ e5.event_id, StateFilter.from_types([(EventTypes.Name, "")])
)
self.assertStateMapEqual({(e2.type, e2.state_key): e2}, state)
diff --git a/tests/test_server.py b/tests/test_server.py
index 08fb3fe02f..3a7cb56479 100644
--- a/tests/test_server.py
+++ b/tests/test_server.py
@@ -69,7 +69,7 @@ class JsonResourceTests(unittest.TestCase):
)
render(request, res, self.reactor)
- self.assertEqual(request.args, {b'a': [u"\N{SNOWMAN}".encode('utf8')]})
+ self.assertEqual(request.args, {b"a": [u"\N{SNOWMAN}".encode("utf8")]})
self.assertEqual(got_kwargs, {u"room_id": u"\N{SNOWMAN}"})
def test_callback_direct_exception(self):
@@ -87,7 +87,7 @@ class JsonResourceTests(unittest.TestCase):
request, channel = make_request(self.reactor, b"GET", b"/_matrix/foo")
render(request, res, self.reactor)
- self.assertEqual(channel.result["code"], b'500')
+ self.assertEqual(channel.result["code"], b"500")
def test_callback_indirect_exception(self):
"""
@@ -110,7 +110,7 @@ class JsonResourceTests(unittest.TestCase):
request, channel = make_request(self.reactor, b"GET", b"/_matrix/foo")
render(request, res, self.reactor)
- self.assertEqual(channel.result["code"], b'500')
+ self.assertEqual(channel.result["code"], b"500")
def test_callback_synapseerror(self):
"""
@@ -127,7 +127,7 @@ class JsonResourceTests(unittest.TestCase):
request, channel = make_request(self.reactor, b"GET", b"/_matrix/foo")
render(request, res, self.reactor)
- self.assertEqual(channel.result["code"], b'403')
+ self.assertEqual(channel.result["code"], b"403")
self.assertEqual(channel.json_body["error"], "Forbidden!!one!")
self.assertEqual(channel.json_body["errcode"], "M_FORBIDDEN")
@@ -148,7 +148,7 @@ class JsonResourceTests(unittest.TestCase):
request, channel = make_request(self.reactor, b"GET", b"/_matrix/foobar")
render(request, res, self.reactor)
- self.assertEqual(channel.result["code"], b'400')
+ self.assertEqual(channel.result["code"], b"400")
self.assertEqual(channel.json_body["error"], "Unrecognized request")
self.assertEqual(channel.json_body["errcode"], "M_UNRECOGNIZED")
@@ -180,7 +180,7 @@ class SiteTestCase(unittest.HomeserverTestCase):
# Make a resource and a Site, the resource will hang and allow us to
# time out the request while it's 'processing'
base_resource = Resource()
- base_resource.putChild(b'', HangingResource())
+ base_resource.putChild(b"", HangingResource())
site = SynapseSite("test", "site_tag", {}, base_resource, "1.0")
server = site.buildProtocol(None)
diff --git a/tests/test_state.py b/tests/test_state.py
index 6491a7105a..6d33566f47 100644
--- a/tests/test_state.py
+++ b/tests/test_state.py
@@ -366,11 +366,11 @@ class StateTestCase(unittest.TestCase):
def _add_depths(self, nodes, edges):
def _get_depth(ev):
node = nodes[ev]
- if 'depth' not in node:
+ if "depth" not in node:
prevs = edges[ev]
depth = max(_get_depth(prev) for prev in prevs) + 1
- node['depth'] = depth
- return node['depth']
+ node["depth"] = depth
+ return node["depth"]
for n in nodes:
_get_depth(n)
diff --git a/tests/test_types.py b/tests/test_types.py
index 73d3b2cda2..1477d6a67d 100644
--- a/tests/test_types.py
+++ b/tests/test_types.py
@@ -109,9 +109,9 @@ class MapUsernameTestCase(unittest.TestCase):
def testNonAscii(self):
# 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"), "t=c3=aast")
self.assertEqual(
- map_username_to_mxid_localpart(u'têst'.encode('utf-8')), "t=c3=aast"
+ map_username_to_mxid_localpart(u"têst".encode("utf-8")), "t=c3=aast"
)
diff --git a/tests/test_utils/logging_setup.py b/tests/test_utils/logging_setup.py
index fde0baee8e..813f984199 100644
--- a/tests/test_utils/logging_setup.py
+++ b/tests/test_utils/logging_setup.py
@@ -27,7 +27,7 @@ class ToTwistedHandler(logging.Handler):
def emit(self, record):
log_entry = self.format(record)
- log_level = record.levelname.lower().replace('warning', 'warn')
+ log_level = record.levelname.lower().replace("warning", "warn")
self.tx_log.emit(
twisted.logger.LogLevel.levelWithName(log_level),
log_entry.replace("{", r"(").replace("}", r")"),
diff --git a/tests/test_visibility.py b/tests/test_visibility.py
index 6a180ddc32..118c3bd238 100644
--- a/tests/test_visibility.py
+++ b/tests/test_visibility.py
@@ -265,7 +265,7 @@ class FilterEventsForServerTestCase(tests.unittest.TestCase):
pr.disable()
with open("filter_events_for_server.profile", "w+") as f:
- ps = pstats.Stats(pr, stream=f).sort_stats('cumulative')
+ ps = pstats.Stats(pr, stream=f).sort_stats("cumulative")
ps.print_stats()
# the result should be 5 redacted events, and 5 unredacted events.
diff --git a/tests/unittest.py b/tests/unittest.py
index b6dc7932ce..251b0b850e 100644
--- a/tests/unittest.py
+++ b/tests/unittest.py
@@ -298,7 +298,7 @@ class HomeserverTestCase(TestCase):
Tuple[synapse.http.site.SynapseRequest, channel]
"""
if isinstance(content, dict):
- content = json.dumps(content).encode('utf8')
+ content = json.dumps(content).encode("utf8")
return make_request(
self.reactor,
@@ -397,13 +397,13 @@ class HomeserverTestCase(TestCase):
nonce = channel.json_body["nonce"]
want_mac = hmac.new(key=b"shared", digestmod=hashlib.sha1)
- nonce_str = b"\x00".join([username.encode('utf8'), password.encode('utf8')])
+ nonce_str = b"\x00".join([username.encode("utf8"), password.encode("utf8")])
if admin:
nonce_str += b"\x00admin"
else:
nonce_str += b"\x00notadmin"
- want_mac.update(nonce.encode('ascii') + b"\x00" + nonce_str)
+ want_mac.update(nonce.encode("ascii") + b"\x00" + nonce_str)
want_mac = want_mac.hexdigest()
body = json.dumps(
@@ -416,7 +416,7 @@ class HomeserverTestCase(TestCase):
}
)
request, channel = self.make_request(
- "POST", "/_matrix/client/r0/admin/register", body.encode('utf8')
+ "POST", "/_matrix/client/r0/admin/register", body.encode("utf8")
)
self.render(request)
self.assertEqual(channel.code, 200)
@@ -435,7 +435,7 @@ class HomeserverTestCase(TestCase):
body["device_id"] = device_id
request, channel = self.make_request(
- "POST", "/_matrix/client/r0/login", json.dumps(body).encode('utf8')
+ "POST", "/_matrix/client/r0/login", json.dumps(body).encode("utf8")
)
self.render(request)
self.assertEqual(channel.code, 200, channel.result)
@@ -481,9 +481,7 @@ class HomeserverTestCase(TestCase):
if soft_failed:
event.internal_metadata.soft_failed = True
- self.get_success(
- event_creator.send_nonmember_event(requester, event, context)
- )
+ self.get_success(event_creator.send_nonmember_event(requester, event, context))
return event.event_id
@@ -508,7 +506,7 @@ class HomeserverTestCase(TestCase):
body = {"type": "m.login.password", "user": username, "password": password}
request, channel = self.make_request(
- "POST", "/_matrix/client/r0/login", json.dumps(body).encode('utf8')
+ "POST", "/_matrix/client/r0/login", json.dumps(body).encode("utf8")
)
self.render(request)
self.assertEqual(channel.code, 403, channel.result)
diff --git a/tests/util/caches/test_descriptors.py b/tests/util/caches/test_descriptors.py
index 463a737efa..6f8f52537c 100644
--- a/tests/util/caches/test_descriptors.py
+++ b/tests/util/caches/test_descriptors.py
@@ -88,24 +88,24 @@ class DescriptorTestCase(unittest.TestCase):
obj = Cls()
- obj.mock.return_value = 'fish'
+ obj.mock.return_value = "fish"
r = yield obj.fn(1, 2)
- self.assertEqual(r, 'fish')
+ self.assertEqual(r, "fish")
obj.mock.assert_called_once_with(1, 2)
obj.mock.reset_mock()
# a call with different params should call the mock again
- obj.mock.return_value = 'chips'
+ obj.mock.return_value = "chips"
r = yield obj.fn(1, 3)
- self.assertEqual(r, 'chips')
+ self.assertEqual(r, "chips")
obj.mock.assert_called_once_with(1, 3)
obj.mock.reset_mock()
# the two values should now be cached
r = yield obj.fn(1, 2)
- self.assertEqual(r, 'fish')
+ self.assertEqual(r, "fish")
r = yield obj.fn(1, 3)
- self.assertEqual(r, 'chips')
+ self.assertEqual(r, "chips")
obj.mock.assert_not_called()
@defer.inlineCallbacks
@@ -121,25 +121,25 @@ class DescriptorTestCase(unittest.TestCase):
return self.mock(arg1, arg2)
obj = Cls()
- obj.mock.return_value = 'fish'
+ obj.mock.return_value = "fish"
r = yield obj.fn(1, 2)
- self.assertEqual(r, 'fish')
+ self.assertEqual(r, "fish")
obj.mock.assert_called_once_with(1, 2)
obj.mock.reset_mock()
# a call with different params should call the mock again
- obj.mock.return_value = 'chips'
+ obj.mock.return_value = "chips"
r = yield obj.fn(2, 3)
- self.assertEqual(r, 'chips')
+ self.assertEqual(r, "chips")
obj.mock.assert_called_once_with(2, 3)
obj.mock.reset_mock()
# the two values should now be cached; we should be able to vary
# the second argument and still get the cached result.
r = yield obj.fn(1, 4)
- self.assertEqual(r, 'fish')
+ self.assertEqual(r, "fish")
r = yield obj.fn(2, 5)
- self.assertEqual(r, 'chips')
+ self.assertEqual(r, "chips")
obj.mock.assert_not_called()
def test_cache_logcontexts(self):
@@ -248,30 +248,30 @@ class DescriptorTestCase(unittest.TestCase):
obj = Cls()
- obj.mock.return_value = 'fish'
+ obj.mock.return_value = "fish"
r = yield obj.fn(1, 2, 3)
- self.assertEqual(r, 'fish')
+ self.assertEqual(r, "fish")
obj.mock.assert_called_once_with(1, 2, 3)
obj.mock.reset_mock()
# a call with same params shouldn't call the mock again
r = yield obj.fn(1, 2)
- self.assertEqual(r, 'fish')
+ self.assertEqual(r, "fish")
obj.mock.assert_not_called()
obj.mock.reset_mock()
# a call with different params should call the mock again
- obj.mock.return_value = 'chips'
+ obj.mock.return_value = "chips"
r = yield obj.fn(2, 3)
- self.assertEqual(r, 'chips')
+ self.assertEqual(r, "chips")
obj.mock.assert_called_once_with(2, 3, 3)
obj.mock.reset_mock()
# the two values should now be cached
r = yield obj.fn(1, 2)
- self.assertEqual(r, 'fish')
+ self.assertEqual(r, "fish")
r = yield obj.fn(2, 3)
- self.assertEqual(r, 'chips')
+ self.assertEqual(r, "chips")
obj.mock.assert_not_called()
@@ -297,7 +297,7 @@ class CachedListDescriptorTestCase(unittest.TestCase):
with logcontext.LoggingContext() as c1:
c1.request = "c1"
obj = Cls()
- obj.mock.return_value = {10: 'fish', 20: 'chips'}
+ obj.mock.return_value = {10: "fish", 20: "chips"}
d1 = obj.list_fn([10, 20], 2)
self.assertEqual(
logcontext.LoggingContext.current_context(),
@@ -306,26 +306,26 @@ class CachedListDescriptorTestCase(unittest.TestCase):
r = yield d1
self.assertEqual(logcontext.LoggingContext.current_context(), c1)
obj.mock.assert_called_once_with([10, 20], 2)
- self.assertEqual(r, {10: 'fish', 20: 'chips'})
+ self.assertEqual(r, {10: "fish", 20: "chips"})
obj.mock.reset_mock()
# a call with different params should call the mock again
- obj.mock.return_value = {30: 'peas'}
+ obj.mock.return_value = {30: "peas"}
r = yield obj.list_fn([20, 30], 2)
obj.mock.assert_called_once_with([30], 2)
- self.assertEqual(r, {20: 'chips', 30: 'peas'})
+ self.assertEqual(r, {20: "chips", 30: "peas"})
obj.mock.reset_mock()
# all the values should now be cached
r = yield obj.fn(10, 2)
- self.assertEqual(r, 'fish')
+ self.assertEqual(r, "fish")
r = yield obj.fn(20, 2)
- self.assertEqual(r, 'chips')
+ self.assertEqual(r, "chips")
r = yield obj.fn(30, 2)
- self.assertEqual(r, 'peas')
+ self.assertEqual(r, "peas")
r = yield obj.list_fn([10, 20, 30], 2)
obj.mock.assert_not_called()
- self.assertEqual(r, {10: 'fish', 20: 'chips', 30: 'peas'})
+ self.assertEqual(r, {10: "fish", 20: "chips", 30: "peas"})
@defer.inlineCallbacks
def test_invalidate(self):
@@ -350,16 +350,16 @@ class CachedListDescriptorTestCase(unittest.TestCase):
invalidate1 = mock.Mock()
# cache miss
- obj.mock.return_value = {10: 'fish', 20: 'chips'}
+ obj.mock.return_value = {10: "fish", 20: "chips"}
r1 = yield obj.list_fn([10, 20], 2, on_invalidate=invalidate0)
obj.mock.assert_called_once_with([10, 20], 2)
- self.assertEqual(r1, {10: 'fish', 20: 'chips'})
+ self.assertEqual(r1, {10: "fish", 20: "chips"})
obj.mock.reset_mock()
# cache hit
r2 = yield obj.list_fn([10, 20], 2, on_invalidate=invalidate1)
obj.mock.assert_not_called()
- self.assertEqual(r2, {10: 'fish', 20: 'chips'})
+ self.assertEqual(r2, {10: "fish", 20: "chips"})
invalidate0.assert_not_called()
invalidate1.assert_not_called()
diff --git a/tests/util/caches/test_ttlcache.py b/tests/util/caches/test_ttlcache.py
index 03b3c15db6..c94cbb662b 100644
--- a/tests/util/caches/test_ttlcache.py
+++ b/tests/util/caches/test_ttlcache.py
@@ -27,57 +27,57 @@ class CacheTestCase(unittest.TestCase):
def test_get(self):
"""simple set/get tests"""
- self.cache.set('one', '1', 10)
- self.cache.set('two', '2', 20)
- self.cache.set('three', '3', 30)
+ self.cache.set("one", "1", 10)
+ self.cache.set("two", "2", 20)
+ self.cache.set("three", "3", 30)
self.assertEqual(len(self.cache), 3)
- self.assertTrue('one' in self.cache)
- self.assertEqual(self.cache.get('one'), '1')
- self.assertEqual(self.cache['one'], '1')
- self.assertEqual(self.cache.get_with_expiry('one'), ('1', 110))
+ self.assertTrue("one" in self.cache)
+ self.assertEqual(self.cache.get("one"), "1")
+ self.assertEqual(self.cache["one"], "1")
+ self.assertEqual(self.cache.get_with_expiry("one"), ("1", 110))
self.assertEqual(self.cache._metrics.hits, 3)
self.assertEqual(self.cache._metrics.misses, 0)
- self.cache.set('two', '2.5', 20)
- self.assertEqual(self.cache['two'], '2.5')
+ self.cache.set("two", "2.5", 20)
+ self.assertEqual(self.cache["two"], "2.5")
self.assertEqual(self.cache._metrics.hits, 4)
# non-existent-item tests
- self.assertEqual(self.cache.get('four', '4'), '4')
- self.assertIs(self.cache.get('four', None), None)
+ self.assertEqual(self.cache.get("four", "4"), "4")
+ self.assertIs(self.cache.get("four", None), None)
with self.assertRaises(KeyError):
- self.cache['four']
+ self.cache["four"]
with self.assertRaises(KeyError):
- self.cache.get('four')
+ self.cache.get("four")
with self.assertRaises(KeyError):
- self.cache.get_with_expiry('four')
+ self.cache.get_with_expiry("four")
self.assertEqual(self.cache._metrics.hits, 4)
self.assertEqual(self.cache._metrics.misses, 5)
def test_expiry(self):
- self.cache.set('one', '1', 10)
- self.cache.set('two', '2', 20)
- self.cache.set('three', '3', 30)
+ self.cache.set("one", "1", 10)
+ self.cache.set("two", "2", 20)
+ self.cache.set("three", "3", 30)
self.assertEqual(len(self.cache), 3)
- self.assertEqual(self.cache['one'], '1')
- self.assertEqual(self.cache['two'], '2')
+ self.assertEqual(self.cache["one"], "1")
+ self.assertEqual(self.cache["two"], "2")
# enough for the first entry to expire, but not the rest
self.mock_timer.side_effect = lambda: 110.0
self.assertEqual(len(self.cache), 2)
- self.assertFalse('one' in self.cache)
- self.assertEqual(self.cache['two'], '2')
- self.assertEqual(self.cache['three'], '3')
+ self.assertFalse("one" in self.cache)
+ self.assertEqual(self.cache["two"], "2")
+ self.assertEqual(self.cache["three"], "3")
- self.assertEqual(self.cache.get_with_expiry('two'), ('2', 120))
+ self.assertEqual(self.cache.get_with_expiry("two"), ("2", 120))
self.assertEqual(self.cache._metrics.hits, 5)
self.assertEqual(self.cache._metrics.misses, 0)
diff --git a/tests/utils.py b/tests/utils.py
index f8c7ad2604..bd2c7c954c 100644
--- a/tests/utils.py
+++ b/tests/utils.py
@@ -358,9 +358,9 @@ def setup_test_homeserver(
# Need to let the HS build an auth handler and then mess with it
# because AuthHandler's constructor requires the HS, so we can't make one
# beforehand and pass it in to the HS's constructor (chicken / egg)
- hs.get_auth_handler().hash = lambda p: hashlib.md5(p.encode('utf8')).hexdigest()
+ hs.get_auth_handler().hash = lambda p: hashlib.md5(p.encode("utf8")).hexdigest()
hs.get_auth_handler().validate_hash = (
- lambda p, h: hashlib.md5(p.encode('utf8')).hexdigest() == h
+ lambda p, h: hashlib.md5(p.encode("utf8")).hexdigest() == h
)
fed = kargs.get("resource_for_federation", None)
@@ -407,7 +407,7 @@ class MockHttpResource(HttpServer):
def trigger_get(self, path):
return self.trigger(b"GET", path, None)
- @patch('twisted.web.http.Request')
+ @patch("twisted.web.http.Request")
@defer.inlineCallbacks
def trigger(
self, http_method, path, content, mock_request, federation_auth_origin=None
@@ -431,12 +431,12 @@ class MockHttpResource(HttpServer):
# annoyingly we return a twisted http request which has chained calls
# to get at the http content, hence mock it here.
mock_content = Mock()
- config = {'read.return_value': content}
+ config = {"read.return_value": content}
mock_content.configure_mock(**config)
mock_request.content = mock_content
- mock_request.method = http_method.encode('ascii')
- mock_request.uri = path.encode('ascii')
+ mock_request.method = http_method.encode("ascii")
+ mock_request.uri = path.encode("ascii")
mock_request.getClientIP.return_value = "-"
@@ -452,14 +452,14 @@ class MockHttpResource(HttpServer):
# add in query params to the right place
try:
- mock_request.args = urlparse.parse_qs(path.split('?')[1])
- mock_request.path = path.split('?')[0]
+ mock_request.args = urlparse.parse_qs(path.split("?")[1])
+ mock_request.path = path.split("?")[0]
path = mock_request.path
except Exception:
pass
if isinstance(path, bytes):
- path = path.decode('utf8')
+ path = path.decode("utf8")
for (method, pattern, func) in self.callbacks:
if http_method != method:
|
