diff --git a/tests/rest/admin/test_room.py b/tests/rest/admin/test_room.py
index 09c48e85c7..95282f078e 100644
--- a/tests/rest/admin/test_room.py
+++ b/tests/rest/admin/test_room.py
@@ -1909,7 +1909,7 @@ class JoinAliasRoomTestCase(unittest.HomeserverTestCase):
"/_matrix/client/r0/joined_rooms",
access_token=self.second_tok,
)
- self.assertEquals(HTTPStatus.OK, channel.code, msg=channel.json_body)
+ self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.json_body)
self.assertEqual(self.public_room_id, channel.json_body["joined_rooms"][0])
def test_join_private_room_if_not_member(self) -> None:
@@ -1957,7 +1957,7 @@ class JoinAliasRoomTestCase(unittest.HomeserverTestCase):
"/_matrix/client/r0/joined_rooms",
access_token=self.admin_user_tok,
)
- self.assertEquals(HTTPStatus.OK, channel.code, msg=channel.json_body)
+ self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.json_body)
self.assertEqual(private_room_id, channel.json_body["joined_rooms"][0])
# Join user to room.
@@ -1980,7 +1980,7 @@ class JoinAliasRoomTestCase(unittest.HomeserverTestCase):
"/_matrix/client/r0/joined_rooms",
access_token=self.second_tok,
)
- self.assertEquals(HTTPStatus.OK, channel.code, msg=channel.json_body)
+ self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.json_body)
self.assertEqual(private_room_id, channel.json_body["joined_rooms"][0])
def test_join_private_room_if_owner(self) -> None:
@@ -2010,7 +2010,7 @@ class JoinAliasRoomTestCase(unittest.HomeserverTestCase):
"/_matrix/client/r0/joined_rooms",
access_token=self.second_tok,
)
- self.assertEquals(HTTPStatus.OK, channel.code, msg=channel.json_body)
+ self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.json_body)
self.assertEqual(private_room_id, channel.json_body["joined_rooms"][0])
def test_context_as_non_admin(self) -> None:
@@ -2044,7 +2044,7 @@ class JoinAliasRoomTestCase(unittest.HomeserverTestCase):
% (room_id, events[midway]["event_id"]),
access_token=tok,
)
- self.assertEquals(HTTPStatus.FORBIDDEN, channel.code, msg=channel.json_body)
+ self.assertEqual(HTTPStatus.FORBIDDEN, channel.code, msg=channel.json_body)
self.assertEqual(Codes.FORBIDDEN, channel.json_body["errcode"])
def test_context_as_admin(self) -> None:
@@ -2074,8 +2074,8 @@ class JoinAliasRoomTestCase(unittest.HomeserverTestCase):
% (room_id, events[midway]["event_id"]),
access_token=self.admin_user_tok,
)
- self.assertEquals(HTTPStatus.OK, channel.code, msg=channel.json_body)
- self.assertEquals(
+ self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.json_body)
+ self.assertEqual(
channel.json_body["event"]["event_id"], events[midway]["event_id"]
)
diff --git a/tests/rest/client/test_account.py b/tests/rest/client/test_account.py
index 008d635b70..6c4462e74a 100644
--- a/tests/rest/client/test_account.py
+++ b/tests/rest/client/test_account.py
@@ -104,7 +104,7 @@ class PasswordResetTestCase(unittest.HomeserverTestCase):
client_secret = "foobar"
session_id = self._request_token(email, client_secret)
- self.assertEquals(len(self.email_attempts), 1)
+ self.assertEqual(len(self.email_attempts), 1)
link = self._get_link_from_email()
self._validate_token(link)
@@ -143,7 +143,7 @@ class PasswordResetTestCase(unittest.HomeserverTestCase):
client_secret = "foobar"
session_id = self._request_token(email, client_secret, ip)
- self.assertEquals(len(self.email_attempts), 1)
+ self.assertEqual(len(self.email_attempts), 1)
link = self._get_link_from_email()
self._validate_token(link)
@@ -193,7 +193,7 @@ class PasswordResetTestCase(unittest.HomeserverTestCase):
client_secret = "foobar"
session_id = self._request_token(email_passwort_reset, client_secret)
- self.assertEquals(len(self.email_attempts), 1)
+ self.assertEqual(len(self.email_attempts), 1)
link = self._get_link_from_email()
self._validate_token(link)
@@ -230,7 +230,7 @@ class PasswordResetTestCase(unittest.HomeserverTestCase):
client_secret = "foobar"
session_id = self._request_token(email, client_secret)
- self.assertEquals(len(self.email_attempts), 1)
+ self.assertEqual(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)
@@ -322,7 +322,7 @@ class PasswordResetTestCase(unittest.HomeserverTestCase):
shorthand=False,
)
- self.assertEquals(200, channel.code, channel.result)
+ self.assertEqual(200, channel.code, channel.result)
# Now POST to the same endpoint, mimicking the same behaviour as clicking the
# password reset confirm button
@@ -337,7 +337,7 @@ class PasswordResetTestCase(unittest.HomeserverTestCase):
shorthand=False,
content_is_form=True,
)
- self.assertEquals(200, channel.code, channel.result)
+ self.assertEqual(200, channel.code, channel.result)
def _get_link_from_email(self):
assert self.email_attempts, "No emails have been sent"
@@ -376,7 +376,7 @@ class PasswordResetTestCase(unittest.HomeserverTestCase):
},
},
)
- self.assertEquals(expected_code, channel.code, channel.result)
+ self.assertEqual(expected_code, channel.code, channel.result)
class DeactivateTestCase(unittest.HomeserverTestCase):
@@ -676,7 +676,7 @@ class ThreepidEmailRestTestCase(unittest.HomeserverTestCase):
client_secret = "foobar"
session_id = self._request_token(self.email, client_secret)
- self.assertEquals(len(self.email_attempts), 1)
+ self.assertEqual(len(self.email_attempts), 1)
link = self._get_link_from_email()
self._validate_token(link)
@@ -780,7 +780,7 @@ class ThreepidEmailRestTestCase(unittest.HomeserverTestCase):
client_secret = "foobar"
session_id = self._request_token(self.email, client_secret)
- self.assertEquals(len(self.email_attempts), 1)
+ self.assertEqual(len(self.email_attempts), 1)
# Attempt to add email without clicking the link
channel = self.make_request(
@@ -981,7 +981,7 @@ class ThreepidEmailRestTestCase(unittest.HomeserverTestCase):
path = link.replace("https://example.com", "")
channel = self.make_request("GET", path, shorthand=False)
- self.assertEquals(200, channel.code, channel.result)
+ self.assertEqual(200, channel.code, channel.result)
def _get_link_from_email(self):
assert self.email_attempts, "No emails have been sent"
@@ -1010,7 +1010,7 @@ class ThreepidEmailRestTestCase(unittest.HomeserverTestCase):
client_secret = "foobar"
session_id = self._request_token(request_email, client_secret)
- self.assertEquals(len(self.email_attempts) - previous_email_attempts, 1)
+ self.assertEqual(len(self.email_attempts) - previous_email_attempts, 1)
link = self._get_link_from_email()
self._validate_token(link)
diff --git a/tests/rest/client/test_events.py b/tests/rest/client/test_events.py
index a90294003e..145f247836 100644
--- a/tests/rest/client/test_events.py
+++ b/tests/rest/client/test_events.py
@@ -65,13 +65,13 @@ class EventStreamPermissionsTestCase(unittest.HomeserverTestCase):
channel = self.make_request(
"GET", "/events?access_token=%s" % ("invalid" + self.token,)
)
- self.assertEquals(channel.code, 401, msg=channel.result)
+ self.assertEqual(channel.code, 401, msg=channel.result)
# valid token, expect content
channel = self.make_request(
"GET", "/events?access_token=%s&timeout=0" % (self.token,)
)
- self.assertEquals(channel.code, 200, msg=channel.result)
+ self.assertEqual(channel.code, 200, msg=channel.result)
self.assertTrue("chunk" in channel.json_body)
self.assertTrue("start" in channel.json_body)
self.assertTrue("end" in channel.json_body)
@@ -89,10 +89,10 @@ class EventStreamPermissionsTestCase(unittest.HomeserverTestCase):
channel = self.make_request(
"GET", "/events?access_token=%s&timeout=0" % (self.token,)
)
- self.assertEquals(channel.code, 200, msg=channel.result)
+ self.assertEqual(channel.code, 200, msg=channel.result)
# We may get a presence event for ourselves down
- self.assertEquals(
+ self.assertEqual(
0,
len(
[
@@ -153,4 +153,4 @@ class GetEventsTestCase(unittest.HomeserverTestCase):
"/events/" + event_id,
access_token=self.token,
)
- self.assertEquals(channel.code, 200, msg=channel.result)
+ self.assertEqual(channel.code, 200, msg=channel.result)
diff --git a/tests/rest/client/test_filter.py b/tests/rest/client/test_filter.py
index a573cc3c2e..5c31a54421 100644
--- a/tests/rest/client/test_filter.py
+++ b/tests/rest/client/test_filter.py
@@ -45,7 +45,7 @@ class FilterTestCase(unittest.HomeserverTestCase):
self.assertEqual(channel.json_body, {"filter_id": "0"})
filter = self.store.get_user_filter(user_localpart="apple", filter_id=0)
self.pump()
- self.assertEquals(filter.result, self.EXAMPLE_FILTER)
+ self.assertEqual(filter.result, self.EXAMPLE_FILTER)
def test_add_filter_for_other_user(self):
channel = self.make_request(
@@ -55,7 +55,7 @@ class FilterTestCase(unittest.HomeserverTestCase):
)
self.assertEqual(channel.result["code"], b"403")
- self.assertEquals(channel.json_body["errcode"], Codes.FORBIDDEN)
+ self.assertEqual(channel.json_body["errcode"], Codes.FORBIDDEN)
def test_add_filter_non_local_user(self):
_is_mine = self.hs.is_mine
@@ -68,7 +68,7 @@ class FilterTestCase(unittest.HomeserverTestCase):
self.hs.is_mine = _is_mine
self.assertEqual(channel.result["code"], b"403")
- self.assertEquals(channel.json_body["errcode"], Codes.FORBIDDEN)
+ self.assertEqual(channel.json_body["errcode"], Codes.FORBIDDEN)
def test_get_filter(self):
filter_id = defer.ensureDeferred(
@@ -83,7 +83,7 @@ class FilterTestCase(unittest.HomeserverTestCase):
)
self.assertEqual(channel.result["code"], b"200")
- self.assertEquals(channel.json_body, self.EXAMPLE_FILTER)
+ self.assertEqual(channel.json_body, self.EXAMPLE_FILTER)
def test_get_filter_non_existant(self):
channel = self.make_request(
@@ -91,7 +91,7 @@ class FilterTestCase(unittest.HomeserverTestCase):
)
self.assertEqual(channel.result["code"], b"404")
- self.assertEquals(channel.json_body["errcode"], Codes.NOT_FOUND)
+ self.assertEqual(channel.json_body["errcode"], Codes.NOT_FOUND)
# Currently invalid params do not have an appropriate errcode
# in errors.py
diff --git a/tests/rest/client/test_groups.py b/tests/rest/client/test_groups.py
index ad0425ae65..c99f54cf4f 100644
--- a/tests/rest/client/test_groups.py
+++ b/tests/rest/client/test_groups.py
@@ -30,8 +30,8 @@ class GroupsTestCase(unittest.HomeserverTestCase):
# Alice creates a group
channel = self.make_request("POST", "/create_group", {"localpart": "spqr"})
- self.assertEquals(channel.code, 200, msg=channel.text_body)
- self.assertEquals(channel.json_body, {"group_id": group_id})
+ self.assertEqual(channel.code, 200, msg=channel.text_body)
+ self.assertEqual(channel.json_body, {"group_id": group_id})
# Bob creates a private room
room_id = self.helper.create_room_as(self.room_creator_user_id, is_public=False)
@@ -45,12 +45,12 @@ class GroupsTestCase(unittest.HomeserverTestCase):
channel = self.make_request(
"PUT", f"/groups/{group_id}/admin/rooms/{room_id}", {}
)
- self.assertEquals(channel.code, 200, msg=channel.text_body)
- self.assertEquals(channel.json_body, {})
+ self.assertEqual(channel.code, 200, msg=channel.text_body)
+ self.assertEqual(channel.json_body, {})
# Alice now tries to retrieve the room list of the space.
channel = self.make_request("GET", f"/groups/{group_id}/rooms")
- self.assertEquals(channel.code, 200, msg=channel.text_body)
- self.assertEquals(
+ self.assertEqual(channel.code, 200, msg=channel.text_body)
+ self.assertEqual(
channel.json_body, {"chunk": [], "total_room_count_estimate": 0}
)
diff --git a/tests/rest/client/test_login.py b/tests/rest/client/test_login.py
index d48defda63..090d2d0a29 100644
--- a/tests/rest/client/test_login.py
+++ b/tests/rest/client/test_login.py
@@ -136,10 +136,10 @@ class LoginRestServletTestCase(unittest.HomeserverTestCase):
channel = self.make_request(b"POST", LOGIN_URL, params)
if i == 5:
- self.assertEquals(channel.result["code"], b"429", channel.result)
+ self.assertEqual(channel.result["code"], b"429", channel.result)
retry_after_ms = int(channel.json_body["retry_after_ms"])
else:
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
# Since we're ratelimiting at 1 request/min, retry_after_ms should be lower
# than 1min.
@@ -154,7 +154,7 @@ class LoginRestServletTestCase(unittest.HomeserverTestCase):
}
channel = self.make_request(b"POST", LOGIN_URL, params)
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
@override_config(
{
@@ -181,10 +181,10 @@ class LoginRestServletTestCase(unittest.HomeserverTestCase):
channel = self.make_request(b"POST", LOGIN_URL, params)
if i == 5:
- self.assertEquals(channel.result["code"], b"429", channel.result)
+ self.assertEqual(channel.result["code"], b"429", channel.result)
retry_after_ms = int(channel.json_body["retry_after_ms"])
else:
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
# Since we're ratelimiting at 1 request/min, retry_after_ms should be lower
# than 1min.
@@ -199,7 +199,7 @@ class LoginRestServletTestCase(unittest.HomeserverTestCase):
}
channel = self.make_request(b"POST", LOGIN_URL, params)
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
@override_config(
{
@@ -226,10 +226,10 @@ class LoginRestServletTestCase(unittest.HomeserverTestCase):
channel = self.make_request(b"POST", LOGIN_URL, params)
if i == 5:
- self.assertEquals(channel.result["code"], b"429", channel.result)
+ self.assertEqual(channel.result["code"], b"429", channel.result)
retry_after_ms = int(channel.json_body["retry_after_ms"])
else:
- self.assertEquals(channel.result["code"], b"403", channel.result)
+ self.assertEqual(channel.result["code"], b"403", channel.result)
# Since we're ratelimiting at 1 request/min, retry_after_ms should be lower
# than 1min.
@@ -244,7 +244,7 @@ class LoginRestServletTestCase(unittest.HomeserverTestCase):
}
channel = self.make_request(b"POST", LOGIN_URL, params)
- self.assertEquals(channel.result["code"], b"403", channel.result)
+ self.assertEqual(channel.result["code"], b"403", channel.result)
@override_config({"session_lifetime": "24h"})
def test_soft_logout(self) -> None:
@@ -252,8 +252,8 @@ class LoginRestServletTestCase(unittest.HomeserverTestCase):
# we shouldn't be able to make requests without an access token
channel = self.make_request(b"GET", TEST_URL)
- self.assertEquals(channel.result["code"], b"401", channel.result)
- self.assertEquals(channel.json_body["errcode"], "M_MISSING_TOKEN")
+ self.assertEqual(channel.result["code"], b"401", channel.result)
+ self.assertEqual(channel.json_body["errcode"], "M_MISSING_TOKEN")
# log in as normal
params = {
@@ -263,22 +263,22 @@ class LoginRestServletTestCase(unittest.HomeserverTestCase):
}
channel = self.make_request(b"POST", LOGIN_URL, params)
- self.assertEquals(channel.code, 200, channel.result)
+ self.assertEqual(channel.code, 200, channel.result)
access_token = channel.json_body["access_token"]
device_id = channel.json_body["device_id"]
# we should now be able to make requests with the access token
channel = self.make_request(b"GET", TEST_URL, access_token=access_token)
- self.assertEquals(channel.code, 200, channel.result)
+ self.assertEqual(channel.code, 200, channel.result)
# time passes
self.reactor.advance(24 * 3600)
# ... and we should be soft-logouted
channel = self.make_request(b"GET", TEST_URL, access_token=access_token)
- self.assertEquals(channel.code, 401, channel.result)
- self.assertEquals(channel.json_body["errcode"], "M_UNKNOWN_TOKEN")
- self.assertEquals(channel.json_body["soft_logout"], True)
+ self.assertEqual(channel.code, 401, channel.result)
+ self.assertEqual(channel.json_body["errcode"], "M_UNKNOWN_TOKEN")
+ self.assertEqual(channel.json_body["soft_logout"], True)
#
# test behaviour after deleting the expired device
@@ -290,17 +290,17 @@ class LoginRestServletTestCase(unittest.HomeserverTestCase):
# more requests with the expired token should still return a soft-logout
self.reactor.advance(3600)
channel = self.make_request(b"GET", TEST_URL, access_token=access_token)
- self.assertEquals(channel.code, 401, channel.result)
- self.assertEquals(channel.json_body["errcode"], "M_UNKNOWN_TOKEN")
- self.assertEquals(channel.json_body["soft_logout"], True)
+ self.assertEqual(channel.code, 401, channel.result)
+ self.assertEqual(channel.json_body["errcode"], "M_UNKNOWN_TOKEN")
+ self.assertEqual(channel.json_body["soft_logout"], True)
# ... but if we delete that device, it will be a proper logout
self._delete_device(access_token_2, "kermit", "monkey", device_id)
channel = self.make_request(b"GET", TEST_URL, access_token=access_token)
- self.assertEquals(channel.code, 401, channel.result)
- self.assertEquals(channel.json_body["errcode"], "M_UNKNOWN_TOKEN")
- self.assertEquals(channel.json_body["soft_logout"], False)
+ self.assertEqual(channel.code, 401, channel.result)
+ self.assertEqual(channel.json_body["errcode"], "M_UNKNOWN_TOKEN")
+ self.assertEqual(channel.json_body["soft_logout"], False)
def _delete_device(
self, access_token: str, user_id: str, password: str, device_id: str
@@ -309,7 +309,7 @@ class LoginRestServletTestCase(unittest.HomeserverTestCase):
channel = self.make_request(
b"DELETE", "devices/" + device_id, access_token=access_token
)
- self.assertEquals(channel.code, 401, channel.result)
+ self.assertEqual(channel.code, 401, channel.result)
# check it's a UI-Auth fail
self.assertEqual(
set(channel.json_body.keys()),
@@ -332,7 +332,7 @@ class LoginRestServletTestCase(unittest.HomeserverTestCase):
access_token=access_token,
content={"auth": auth},
)
- self.assertEquals(channel.code, 200, channel.result)
+ self.assertEqual(channel.code, 200, channel.result)
@override_config({"session_lifetime": "24h"})
def test_session_can_hard_logout_after_being_soft_logged_out(self) -> None:
@@ -343,20 +343,20 @@ class LoginRestServletTestCase(unittest.HomeserverTestCase):
# we should now be able to make requests with the access token
channel = self.make_request(b"GET", TEST_URL, access_token=access_token)
- self.assertEquals(channel.code, 200, channel.result)
+ self.assertEqual(channel.code, 200, channel.result)
# time passes
self.reactor.advance(24 * 3600)
# ... and we should be soft-logouted
channel = self.make_request(b"GET", TEST_URL, access_token=access_token)
- self.assertEquals(channel.code, 401, channel.result)
- self.assertEquals(channel.json_body["errcode"], "M_UNKNOWN_TOKEN")
- self.assertEquals(channel.json_body["soft_logout"], True)
+ self.assertEqual(channel.code, 401, channel.result)
+ self.assertEqual(channel.json_body["errcode"], "M_UNKNOWN_TOKEN")
+ self.assertEqual(channel.json_body["soft_logout"], True)
# Now try to hard logout this session
channel = self.make_request(b"POST", "/logout", access_token=access_token)
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
@override_config({"session_lifetime": "24h"})
def test_session_can_hard_logout_all_sessions_after_being_soft_logged_out(
@@ -369,20 +369,20 @@ class LoginRestServletTestCase(unittest.HomeserverTestCase):
# we should now be able to make requests with the access token
channel = self.make_request(b"GET", TEST_URL, access_token=access_token)
- self.assertEquals(channel.code, 200, channel.result)
+ self.assertEqual(channel.code, 200, channel.result)
# time passes
self.reactor.advance(24 * 3600)
# ... and we should be soft-logouted
channel = self.make_request(b"GET", TEST_URL, access_token=access_token)
- self.assertEquals(channel.code, 401, channel.result)
- self.assertEquals(channel.json_body["errcode"], "M_UNKNOWN_TOKEN")
- self.assertEquals(channel.json_body["soft_logout"], True)
+ self.assertEqual(channel.code, 401, channel.result)
+ self.assertEqual(channel.json_body["errcode"], "M_UNKNOWN_TOKEN")
+ self.assertEqual(channel.json_body["soft_logout"], True)
# Now try to hard log out all of the user's sessions
channel = self.make_request(b"POST", "/logout/all", access_token=access_token)
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
@skip_unless(has_saml2 and HAS_OIDC, "Requires SAML2 and OIDC")
@@ -1129,7 +1129,7 @@ class AppserviceLoginRestServletTestCase(unittest.HomeserverTestCase):
b"POST", LOGIN_URL, params, access_token=self.service.token
)
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
def test_login_appservice_user_bot(self) -> None:
"""Test that the appservice bot can use /login"""
@@ -1143,7 +1143,7 @@ class AppserviceLoginRestServletTestCase(unittest.HomeserverTestCase):
b"POST", LOGIN_URL, params, access_token=self.service.token
)
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
def test_login_appservice_wrong_user(self) -> None:
"""Test that non-as users cannot login with the as token"""
@@ -1157,7 +1157,7 @@ class AppserviceLoginRestServletTestCase(unittest.HomeserverTestCase):
b"POST", LOGIN_URL, params, access_token=self.service.token
)
- self.assertEquals(channel.result["code"], b"403", channel.result)
+ self.assertEqual(channel.result["code"], b"403", channel.result)
def test_login_appservice_wrong_as(self) -> None:
"""Test that as users cannot login with wrong as token"""
@@ -1171,7 +1171,7 @@ class AppserviceLoginRestServletTestCase(unittest.HomeserverTestCase):
b"POST", LOGIN_URL, params, access_token=self.another_service.token
)
- self.assertEquals(channel.result["code"], b"403", channel.result)
+ self.assertEqual(channel.result["code"], b"403", channel.result)
def test_login_appservice_no_token(self) -> None:
"""Test that users must provide a token when using the appservice
@@ -1185,7 +1185,7 @@ class AppserviceLoginRestServletTestCase(unittest.HomeserverTestCase):
}
channel = self.make_request(b"POST", LOGIN_URL, params)
- self.assertEquals(channel.result["code"], b"401", channel.result)
+ self.assertEqual(channel.result["code"], b"401", channel.result)
@skip_unless(HAS_OIDC, "requires OIDC")
diff --git a/tests/rest/client/test_profile.py b/tests/rest/client/test_profile.py
index b9647d5bd8..4239e1e610 100644
--- a/tests/rest/client/test_profile.py
+++ b/tests/rest/client/test_profile.py
@@ -80,7 +80,7 @@ class ProfileTestCase(unittest.HomeserverTestCase):
def test_get_displayname_other(self):
res = self._get_displayname(self.other)
- self.assertEquals(res, "Bob")
+ self.assertEqual(res, "Bob")
def test_set_displayname_other(self):
channel = self.make_request(
diff --git a/tests/rest/client/test_register.py b/tests/rest/client/test_register.py
index 2835d86e5b..4b95b8541c 100644
--- a/tests/rest/client/test_register.py
+++ b/tests/rest/client/test_register.py
@@ -65,7 +65,7 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
b"POST", self.url + b"?access_token=i_am_an_app_service", request_data
)
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
det_data = {"user_id": user_id, "home_server": self.hs.hostname}
self.assertDictContainsSubset(det_data, channel.json_body)
@@ -87,7 +87,7 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
b"POST", self.url + b"?access_token=i_am_an_app_service", request_data
)
- self.assertEquals(channel.result["code"], b"400", channel.result)
+ self.assertEqual(channel.result["code"], b"400", channel.result)
def test_POST_appservice_registration_invalid(self):
self.appservice = None # no application service exists
@@ -98,21 +98,21 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
b"POST", self.url + b"?access_token=i_am_an_app_service", request_data
)
- self.assertEquals(channel.result["code"], b"401", channel.result)
+ self.assertEqual(channel.result["code"], b"401", channel.result)
def test_POST_bad_password(self):
request_data = json.dumps({"username": "kermit", "password": 666})
channel = self.make_request(b"POST", self.url, request_data)
- self.assertEquals(channel.result["code"], b"400", channel.result)
- self.assertEquals(channel.json_body["error"], "Invalid password")
+ self.assertEqual(channel.result["code"], b"400", channel.result)
+ self.assertEqual(channel.json_body["error"], "Invalid password")
def test_POST_bad_username(self):
request_data = json.dumps({"username": 777, "password": "monkey"})
channel = self.make_request(b"POST", self.url, request_data)
- self.assertEquals(channel.result["code"], b"400", channel.result)
- self.assertEquals(channel.json_body["error"], "Invalid username")
+ self.assertEqual(channel.result["code"], b"400", channel.result)
+ self.assertEqual(channel.json_body["error"], "Invalid username")
def test_POST_user_valid(self):
user_id = "@kermit:test"
@@ -131,7 +131,7 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
"home_server": self.hs.hostname,
"device_id": device_id,
}
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
self.assertDictContainsSubset(det_data, channel.json_body)
@override_config({"enable_registration": False})
@@ -141,9 +141,9 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
channel = self.make_request(b"POST", self.url, request_data)
- self.assertEquals(channel.result["code"], b"403", channel.result)
- self.assertEquals(channel.json_body["error"], "Registration has been disabled")
- self.assertEquals(channel.json_body["errcode"], "M_FORBIDDEN")
+ self.assertEqual(channel.result["code"], b"403", channel.result)
+ self.assertEqual(channel.json_body["error"], "Registration has been disabled")
+ self.assertEqual(channel.json_body["errcode"], "M_FORBIDDEN")
def test_POST_guest_registration(self):
self.hs.config.key.macaroon_secret_key = "test"
@@ -152,7 +152,7 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
channel = self.make_request(b"POST", self.url + b"?kind=guest", b"{}")
det_data = {"home_server": self.hs.hostname, "device_id": "guest_device"}
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
self.assertDictContainsSubset(det_data, channel.json_body)
def test_POST_disabled_guest_registration(self):
@@ -160,8 +160,8 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
channel = self.make_request(b"POST", self.url + b"?kind=guest", b"{}")
- self.assertEquals(channel.result["code"], b"403", channel.result)
- self.assertEquals(channel.json_body["error"], "Guest access is disabled")
+ self.assertEqual(channel.result["code"], b"403", channel.result)
+ self.assertEqual(channel.json_body["error"], "Guest access is disabled")
@override_config({"rc_registration": {"per_second": 0.17, "burst_count": 5}})
def test_POST_ratelimiting_guest(self):
@@ -170,16 +170,16 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
channel = self.make_request(b"POST", url, b"{}")
if i == 5:
- self.assertEquals(channel.result["code"], b"429", channel.result)
+ self.assertEqual(channel.result["code"], b"429", channel.result)
retry_after_ms = int(channel.json_body["retry_after_ms"])
else:
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
self.reactor.advance(retry_after_ms / 1000.0 + 1.0)
channel = self.make_request(b"POST", self.url + b"?kind=guest", b"{}")
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
@override_config({"rc_registration": {"per_second": 0.17, "burst_count": 5}})
def test_POST_ratelimiting(self):
@@ -194,16 +194,16 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
channel = self.make_request(b"POST", self.url, request_data)
if i == 5:
- self.assertEquals(channel.result["code"], b"429", channel.result)
+ self.assertEqual(channel.result["code"], b"429", channel.result)
retry_after_ms = int(channel.json_body["retry_after_ms"])
else:
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
self.reactor.advance(retry_after_ms / 1000.0 + 1.0)
channel = self.make_request(b"POST", self.url + b"?kind=guest", b"{}")
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
@override_config({"registration_requires_token": True})
def test_POST_registration_requires_token(self):
@@ -231,7 +231,7 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
# Request without auth to get flows and session
channel = self.make_request(b"POST", self.url, json.dumps(params))
- self.assertEquals(channel.result["code"], b"401", channel.result)
+ self.assertEqual(channel.result["code"], b"401", channel.result)
flows = channel.json_body["flows"]
# Synapse adds a dummy stage to differentiate flows where otherwise one
# flow would be a subset of another flow.
@@ -249,7 +249,7 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
}
request_data = json.dumps(params)
channel = self.make_request(b"POST", self.url, request_data)
- self.assertEquals(channel.result["code"], b"401", channel.result)
+ self.assertEqual(channel.result["code"], b"401", channel.result)
completed = channel.json_body["completed"]
self.assertCountEqual([LoginType.REGISTRATION_TOKEN], completed)
@@ -265,7 +265,7 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
"home_server": self.hs.hostname,
"device_id": device_id,
}
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
self.assertDictContainsSubset(det_data, channel.json_body)
# Check the `completed` counter has been incremented and pending is 0
@@ -276,8 +276,8 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
retcols=["pending", "completed"],
)
)
- self.assertEquals(res["completed"], 1)
- self.assertEquals(res["pending"], 0)
+ self.assertEqual(res["completed"], 1)
+ self.assertEqual(res["pending"], 0)
@override_config({"registration_requires_token": True})
def test_POST_registration_token_invalid(self):
@@ -295,23 +295,23 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
"session": session,
}
channel = self.make_request(b"POST", self.url, json.dumps(params))
- self.assertEquals(channel.result["code"], b"401", channel.result)
- self.assertEquals(channel.json_body["errcode"], Codes.MISSING_PARAM)
- self.assertEquals(channel.json_body["completed"], [])
+ self.assertEqual(channel.result["code"], b"401", channel.result)
+ self.assertEqual(channel.json_body["errcode"], Codes.MISSING_PARAM)
+ self.assertEqual(channel.json_body["completed"], [])
# Test with non-string (invalid)
params["auth"]["token"] = 1234
channel = self.make_request(b"POST", self.url, json.dumps(params))
- self.assertEquals(channel.result["code"], b"401", channel.result)
- self.assertEquals(channel.json_body["errcode"], Codes.INVALID_PARAM)
- self.assertEquals(channel.json_body["completed"], [])
+ self.assertEqual(channel.result["code"], b"401", channel.result)
+ self.assertEqual(channel.json_body["errcode"], Codes.INVALID_PARAM)
+ self.assertEqual(channel.json_body["completed"], [])
# Test with unknown token (invalid)
params["auth"]["token"] = "1234"
channel = self.make_request(b"POST", self.url, json.dumps(params))
- self.assertEquals(channel.result["code"], b"401", channel.result)
- self.assertEquals(channel.json_body["errcode"], Codes.UNAUTHORIZED)
- self.assertEquals(channel.json_body["completed"], [])
+ self.assertEqual(channel.result["code"], b"401", channel.result)
+ self.assertEqual(channel.json_body["errcode"], Codes.UNAUTHORIZED)
+ self.assertEqual(channel.json_body["completed"], [])
@override_config({"registration_requires_token": True})
def test_POST_registration_token_limit_uses(self):
@@ -354,7 +354,7 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
retcol="pending",
)
)
- self.assertEquals(pending, 1)
+ self.assertEqual(pending, 1)
# Check auth fails when using token with session2
params2["auth"] = {
@@ -363,9 +363,9 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
"session": session2,
}
channel = self.make_request(b"POST", self.url, json.dumps(params2))
- self.assertEquals(channel.result["code"], b"401", channel.result)
- self.assertEquals(channel.json_body["errcode"], Codes.UNAUTHORIZED)
- self.assertEquals(channel.json_body["completed"], [])
+ self.assertEqual(channel.result["code"], b"401", channel.result)
+ self.assertEqual(channel.json_body["errcode"], Codes.UNAUTHORIZED)
+ self.assertEqual(channel.json_body["completed"], [])
# Complete registration with session1
params1["auth"]["type"] = LoginType.DUMMY
@@ -378,14 +378,14 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
retcols=["pending", "completed"],
)
)
- self.assertEquals(res["pending"], 0)
- self.assertEquals(res["completed"], 1)
+ self.assertEqual(res["pending"], 0)
+ self.assertEqual(res["completed"], 1)
# Check auth still fails when using token with session2
channel = self.make_request(b"POST", self.url, json.dumps(params2))
- self.assertEquals(channel.result["code"], b"401", channel.result)
- self.assertEquals(channel.json_body["errcode"], Codes.UNAUTHORIZED)
- self.assertEquals(channel.json_body["completed"], [])
+ self.assertEqual(channel.result["code"], b"401", channel.result)
+ self.assertEqual(channel.json_body["errcode"], Codes.UNAUTHORIZED)
+ self.assertEqual(channel.json_body["completed"], [])
@override_config({"registration_requires_token": True})
def test_POST_registration_token_expiry(self):
@@ -417,9 +417,9 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
"session": session,
}
channel = self.make_request(b"POST", self.url, json.dumps(params))
- self.assertEquals(channel.result["code"], b"401", channel.result)
- self.assertEquals(channel.json_body["errcode"], Codes.UNAUTHORIZED)
- self.assertEquals(channel.json_body["completed"], [])
+ self.assertEqual(channel.result["code"], b"401", channel.result)
+ self.assertEqual(channel.json_body["errcode"], Codes.UNAUTHORIZED)
+ self.assertEqual(channel.json_body["completed"], [])
# Update token so it expires tomorrow
self.get_success(
@@ -504,7 +504,7 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
retcol="result",
)
)
- self.assertEquals(db_to_json(result2), token)
+ self.assertEqual(db_to_json(result2), token)
# Delete both sessions (mimics expiry)
self.get_success(
@@ -519,7 +519,7 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
retcol="pending",
)
)
- self.assertEquals(pending, 0)
+ self.assertEqual(pending, 0)
@override_config({"registration_requires_token": True})
def test_POST_registration_token_session_expiry_deleted_token(self):
@@ -572,7 +572,7 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
def test_advertised_flows(self):
channel = self.make_request(b"POST", self.url, b"{}")
- self.assertEquals(channel.result["code"], b"401", channel.result)
+ self.assertEqual(channel.result["code"], b"401", channel.result)
flows = channel.json_body["flows"]
# with the stock config, we only expect the dummy flow
@@ -595,7 +595,7 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
)
def test_advertised_flows_captcha_and_terms_and_3pids(self):
channel = self.make_request(b"POST", self.url, b"{}")
- self.assertEquals(channel.result["code"], b"401", channel.result)
+ self.assertEqual(channel.result["code"], b"401", channel.result)
flows = channel.json_body["flows"]
self.assertCountEqual(
@@ -627,7 +627,7 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
)
def test_advertised_flows_no_msisdn_email_required(self):
channel = self.make_request(b"POST", self.url, b"{}")
- self.assertEquals(channel.result["code"], b"401", channel.result)
+ self.assertEqual(channel.result["code"], b"401", channel.result)
flows = channel.json_body["flows"]
# with the stock config, we expect all four combinations of 3pid
@@ -671,7 +671,7 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
b"register/email/requestToken",
{"client_secret": "foobar", "email": email, "send_attempt": 1},
)
- self.assertEquals(200, channel.code, channel.result)
+ self.assertEqual(200, channel.code, channel.result)
self.assertIsNotNone(channel.json_body.get("sid"))
@@ -694,9 +694,9 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
b"register/email/requestToken",
{"client_secret": "foobar", "email": "email@@email", "send_attempt": 1},
)
- self.assertEquals(400, channel.code, channel.result)
+ self.assertEqual(400, channel.code, channel.result)
# Check error to ensure that we're not erroring due to a bug in the test.
- self.assertEquals(
+ self.assertEqual(
channel.json_body,
{"errcode": "M_UNKNOWN", "error": "Unable to parse email address"},
)
@@ -707,8 +707,8 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
b"register/email/requestToken",
{"client_secret": "foobar", "email": "email", "send_attempt": 1},
)
- self.assertEquals(400, channel.code, channel.result)
- self.assertEquals(
+ self.assertEqual(400, channel.code, channel.result)
+ self.assertEqual(
channel.json_body,
{"errcode": "M_UNKNOWN", "error": "Unable to parse email address"},
)
@@ -720,8 +720,8 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
b"register/email/requestToken",
{"client_secret": "foobar", "email": email, "send_attempt": 1},
)
- self.assertEquals(400, channel.code, channel.result)
- self.assertEquals(
+ self.assertEqual(400, channel.code, channel.result)
+ self.assertEqual(
channel.json_body,
{"errcode": "M_UNKNOWN", "error": "Unable to parse email address"},
)
@@ -745,7 +745,7 @@ class RegisterRestServletTestCase(unittest.HomeserverTestCase):
# Check that /available correctly ignores the username provided despite the
# username being already registered.
channel = self.make_request("GET", "register/available?username=" + username)
- self.assertEquals(200, channel.code, channel.result)
+ self.assertEqual(200, channel.code, channel.result)
# Test that when starting a UIA registration flow the request doesn't fail because
# of a conflicting username
@@ -799,14 +799,14 @@ class AccountValidityTestCase(unittest.HomeserverTestCase):
# endpoint.
channel = self.make_request(b"GET", "/sync", access_token=tok)
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
self.reactor.advance(datetime.timedelta(weeks=1).total_seconds())
channel = self.make_request(b"GET", "/sync", access_token=tok)
- self.assertEquals(channel.result["code"], b"403", channel.result)
- self.assertEquals(
+ self.assertEqual(channel.result["code"], b"403", channel.result)
+ self.assertEqual(
channel.json_body["errcode"], Codes.EXPIRED_ACCOUNT, channel.result
)
@@ -826,12 +826,12 @@ class AccountValidityTestCase(unittest.HomeserverTestCase):
params = {"user_id": user_id}
request_data = json.dumps(params)
channel = self.make_request(b"POST", url, request_data, access_token=admin_tok)
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
# The specific endpoint doesn't matter, all we need is an authenticated
# endpoint.
channel = self.make_request(b"GET", "/sync", access_token=tok)
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
def test_manual_expire(self):
user_id = self.register_user("kermit", "monkey")
@@ -848,13 +848,13 @@ class AccountValidityTestCase(unittest.HomeserverTestCase):
}
request_data = json.dumps(params)
channel = self.make_request(b"POST", url, request_data, access_token=admin_tok)
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
# The specific endpoint doesn't matter, all we need is an authenticated
# endpoint.
channel = self.make_request(b"GET", "/sync", access_token=tok)
- self.assertEquals(channel.result["code"], b"403", channel.result)
- self.assertEquals(
+ self.assertEqual(channel.result["code"], b"403", channel.result)
+ self.assertEqual(
channel.json_body["errcode"], Codes.EXPIRED_ACCOUNT, channel.result
)
@@ -873,18 +873,18 @@ class AccountValidityTestCase(unittest.HomeserverTestCase):
}
request_data = json.dumps(params)
channel = self.make_request(b"POST", url, request_data, access_token=admin_tok)
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
# Try to log the user out
channel = self.make_request(b"POST", "/logout", access_token=tok)
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
# Log the user in again (allowed for expired accounts)
tok = self.login("kermit", "monkey")
# Try to log out all of the user's sessions
channel = self.make_request(b"POST", "/logout/all", access_token=tok)
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
class AccountValidityRenewalByEmailTestCase(unittest.HomeserverTestCase):
@@ -959,7 +959,7 @@ class AccountValidityRenewalByEmailTestCase(unittest.HomeserverTestCase):
renewal_token = self.get_success(self.store.get_renewal_token_for_user(user_id))
url = "/_matrix/client/unstable/account_validity/renew?token=%s" % renewal_token
channel = self.make_request(b"GET", url)
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
# Check that we're getting HTML back.
content_type = channel.headers.getRawHeaders(b"Content-Type")
@@ -977,7 +977,7 @@ class AccountValidityRenewalByEmailTestCase(unittest.HomeserverTestCase):
# Move 1 day forward. Try to renew with the same token again.
url = "/_matrix/client/unstable/account_validity/renew?token=%s" % renewal_token
channel = self.make_request(b"GET", url)
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
# Check that we're getting HTML back.
content_type = channel.headers.getRawHeaders(b"Content-Type")
@@ -997,14 +997,14 @@ class AccountValidityRenewalByEmailTestCase(unittest.HomeserverTestCase):
# succeed.
self.reactor.advance(datetime.timedelta(days=3).total_seconds())
channel = self.make_request(b"GET", "/sync", access_token=tok)
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
def test_renewal_invalid_token(self):
# Hit the renewal endpoint with an invalid token and check that it behaves as
# expected, i.e. that it responds with 404 Not Found and the correct HTML.
url = "/_matrix/client/unstable/account_validity/renew?token=123"
channel = self.make_request(b"GET", url)
- self.assertEquals(channel.result["code"], b"404", channel.result)
+ self.assertEqual(channel.result["code"], b"404", channel.result)
# Check that we're getting HTML back.
content_type = channel.headers.getRawHeaders(b"Content-Type")
@@ -1028,7 +1028,7 @@ class AccountValidityRenewalByEmailTestCase(unittest.HomeserverTestCase):
"/_matrix/client/unstable/account_validity/send_mail",
access_token=tok,
)
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
self.assertEqual(len(self.email_attempts), 1)
@@ -1103,7 +1103,7 @@ class AccountValidityRenewalByEmailTestCase(unittest.HomeserverTestCase):
"/_matrix/client/unstable/account_validity/send_mail",
access_token=tok,
)
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
self.assertEqual(len(self.email_attempts), 1)
@@ -1183,8 +1183,8 @@ class RegistrationTokenValidityRestServletTestCase(unittest.HomeserverTestCase):
b"GET",
f"{self.url}?token={token}",
)
- self.assertEquals(channel.result["code"], b"200", channel.result)
- self.assertEquals(channel.json_body["valid"], True)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.json_body["valid"], True)
def test_GET_token_invalid(self):
token = "1234"
@@ -1192,8 +1192,8 @@ class RegistrationTokenValidityRestServletTestCase(unittest.HomeserverTestCase):
b"GET",
f"{self.url}?token={token}",
)
- self.assertEquals(channel.result["code"], b"200", channel.result)
- self.assertEquals(channel.json_body["valid"], False)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.json_body["valid"], False)
@override_config(
{"rc_registration_token_validity": {"per_second": 0.1, "burst_count": 5}}
@@ -1208,10 +1208,10 @@ class RegistrationTokenValidityRestServletTestCase(unittest.HomeserverTestCase):
)
if i == 5:
- self.assertEquals(channel.result["code"], b"429", channel.result)
+ self.assertEqual(channel.result["code"], b"429", channel.result)
retry_after_ms = int(channel.json_body["retry_after_ms"])
else:
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
self.reactor.advance(retry_after_ms / 1000.0 + 1.0)
@@ -1219,4 +1219,4 @@ class RegistrationTokenValidityRestServletTestCase(unittest.HomeserverTestCase):
b"GET",
f"{self.url}?token={token}",
)
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
diff --git a/tests/rest/client/test_relations.py b/tests/rest/client/test_relations.py
index 5687dea48d..8f7181103b 100644
--- a/tests/rest/client/test_relations.py
+++ b/tests/rest/client/test_relations.py
@@ -69,7 +69,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
"""
channel = self._send_relation(RelationTypes.ANNOTATION, "m.reaction", key="👍")
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
event_id = channel.json_body["event_id"]
@@ -78,7 +78,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
"/rooms/%s/event/%s" % (self.room, event_id),
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
self.assert_dict(
{
@@ -103,7 +103,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
parent_id="foo",
content={"body": "foo", "msgtype": "m.text"},
)
- self.assertEquals(400, channel.code, channel.json_body)
+ self.assertEqual(400, channel.code, channel.json_body)
# Unless that event is referenced from another event!
self.get_success(
@@ -123,7 +123,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
parent_id="foo",
content={"body": "foo", "msgtype": "m.text"},
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
def test_deny_invalid_room(self):
"""Test that we deny relations on non-existant events"""
@@ -136,15 +136,15 @@ class RelationsTestCase(unittest.HomeserverTestCase):
channel = self._send_relation(
RelationTypes.ANNOTATION, "m.reaction", parent_id=parent_id, key="A"
)
- self.assertEquals(400, channel.code, channel.json_body)
+ self.assertEqual(400, channel.code, channel.json_body)
def test_deny_double_react(self):
"""Test that we deny relations on membership events"""
channel = self._send_relation(RelationTypes.ANNOTATION, "m.reaction", key="a")
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
channel = self._send_relation(RelationTypes.ANNOTATION, "m.reaction", "a")
- self.assertEquals(400, channel.code, channel.json_body)
+ self.assertEqual(400, channel.code, channel.json_body)
def test_deny_forked_thread(self):
"""It is invalid to start a thread off a thread."""
@@ -154,7 +154,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
content={"msgtype": "m.text", "body": "foo"},
parent_id=self.parent_id,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
parent_id = channel.json_body["event_id"]
channel = self._send_relation(
@@ -163,16 +163,16 @@ class RelationsTestCase(unittest.HomeserverTestCase):
content={"msgtype": "m.text", "body": "foo"},
parent_id=parent_id,
)
- self.assertEquals(400, channel.code, channel.json_body)
+ self.assertEqual(400, channel.code, channel.json_body)
def test_basic_paginate_relations(self):
"""Tests that calling pagination API correctly the latest relations."""
channel = self._send_relation(RelationTypes.ANNOTATION, "m.reaction", "a")
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
first_annotation_id = channel.json_body["event_id"]
channel = self._send_relation(RelationTypes.ANNOTATION, "m.reaction", "b")
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
second_annotation_id = channel.json_body["event_id"]
channel = self.make_request(
@@ -180,11 +180,11 @@ class RelationsTestCase(unittest.HomeserverTestCase):
f"/_matrix/client/unstable/rooms/{self.room}/relations/{self.parent_id}?limit=1",
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
# We expect to get back a single pagination result, which is the latest
# full relation event we sent above.
- self.assertEquals(len(channel.json_body["chunk"]), 1, channel.json_body)
+ self.assertEqual(len(channel.json_body["chunk"]), 1, channel.json_body)
self.assert_dict(
{
"event_id": second_annotation_id,
@@ -195,7 +195,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
)
# We also expect to get the original event (the id of which is self.parent_id)
- self.assertEquals(
+ self.assertEqual(
channel.json_body["original_event"]["event_id"], self.parent_id
)
@@ -212,11 +212,11 @@ class RelationsTestCase(unittest.HomeserverTestCase):
f"/{self.parent_id}?limit=1&org.matrix.msc3715.dir=f",
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
# We expect to get back a single pagination result, which is the earliest
# full relation event we sent above.
- self.assertEquals(len(channel.json_body["chunk"]), 1, channel.json_body)
+ self.assertEqual(len(channel.json_body["chunk"]), 1, channel.json_body)
self.assert_dict(
{
"event_id": first_annotation_id,
@@ -245,7 +245,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
channel = self._send_relation(
RelationTypes.ANNOTATION, "m.reaction", chr(ord("a") + idx)
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
expected_event_ids.append(channel.json_body["event_id"])
prev_token = ""
@@ -260,12 +260,12 @@ class RelationsTestCase(unittest.HomeserverTestCase):
f"/_matrix/client/unstable/rooms/{self.room}/relations/{self.parent_id}?limit=1{from_token}",
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
found_event_ids.extend(e["event_id"] for e in channel.json_body["chunk"])
next_batch = channel.json_body.get("next_batch")
- self.assertNotEquals(prev_token, next_batch)
+ self.assertNotEqual(prev_token, next_batch)
prev_token = next_batch
if not prev_token:
@@ -273,7 +273,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
# We paginated backwards, so reverse
found_event_ids.reverse()
- self.assertEquals(found_event_ids, expected_event_ids)
+ self.assertEqual(found_event_ids, expected_event_ids)
# Reset and try again, but convert the tokens to the legacy format.
prev_token = ""
@@ -288,12 +288,12 @@ class RelationsTestCase(unittest.HomeserverTestCase):
f"/_matrix/client/unstable/rooms/{self.room}/relations/{self.parent_id}?limit=1{from_token}",
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
found_event_ids.extend(e["event_id"] for e in channel.json_body["chunk"])
next_batch = channel.json_body.get("next_batch")
- self.assertNotEquals(prev_token, next_batch)
+ self.assertNotEqual(prev_token, next_batch)
prev_token = next_batch
if not prev_token:
@@ -301,12 +301,12 @@ class RelationsTestCase(unittest.HomeserverTestCase):
# We paginated backwards, so reverse
found_event_ids.reverse()
- self.assertEquals(found_event_ids, expected_event_ids)
+ self.assertEqual(found_event_ids, expected_event_ids)
def test_pagination_from_sync_and_messages(self):
"""Pagination tokens from /sync and /messages can be used to paginate /relations."""
channel = self._send_relation(RelationTypes.ANNOTATION, "m.reaction", "A")
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
annotation_id = channel.json_body["event_id"]
# Send an event after the relation events.
self.helper.send(self.room, body="Latest event", tok=self.user_token)
@@ -319,7 +319,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
channel = self.make_request(
"GET", f"/sync?filter={filter}", access_token=self.user_token
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
room_timeline = channel.json_body["rooms"]["join"][self.room]["timeline"]
sync_prev_batch = room_timeline["prev_batch"]
self.assertIsNotNone(sync_prev_batch)
@@ -335,7 +335,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
f"/rooms/{self.room}/messages?dir=b&limit=1",
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
messages_end = channel.json_body["end"]
self.assertIsNotNone(messages_end)
# Ensure the relation event is not in the chunk returned from /messages.
@@ -355,7 +355,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
f"/_matrix/client/unstable/rooms/{self.room}/relations/{self.parent_id}?from={from_token}",
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
# The relation should be in the returned chunk.
self.assertIn(
@@ -386,7 +386,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
key=key,
access_token=access_tokens[idx],
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
idx += 1
idx %= len(access_tokens)
@@ -404,7 +404,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
% (self.room, self.parent_id, from_token),
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
self.assertEqual(len(channel.json_body["chunk"]), 1, channel.json_body)
@@ -419,13 +419,13 @@ class RelationsTestCase(unittest.HomeserverTestCase):
next_batch = channel.json_body.get("next_batch")
- self.assertNotEquals(prev_token, next_batch)
+ self.assertNotEqual(prev_token, next_batch)
prev_token = next_batch
if not prev_token:
break
- self.assertEquals(sent_groups, found_groups)
+ self.assertEqual(sent_groups, found_groups)
def test_aggregation_pagination_within_group(self):
"""Test that we can paginate within an annotation group."""
@@ -449,14 +449,14 @@ class RelationsTestCase(unittest.HomeserverTestCase):
key="👍",
access_token=access_tokens[idx],
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
expected_event_ids.append(channel.json_body["event_id"])
idx += 1
# Also send a different type of reaction so that we test we don't see it
channel = self._send_relation(RelationTypes.ANNOTATION, "m.reaction", key="a")
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
prev_token = ""
found_event_ids: List[str] = []
@@ -473,7 +473,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
f"/m.reaction/{encoded_key}?limit=1{from_token}",
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
self.assertEqual(len(channel.json_body["chunk"]), 1, channel.json_body)
@@ -481,7 +481,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
next_batch = channel.json_body.get("next_batch")
- self.assertNotEquals(prev_token, next_batch)
+ self.assertNotEqual(prev_token, next_batch)
prev_token = next_batch
if not prev_token:
@@ -489,7 +489,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
# We paginated backwards, so reverse
found_event_ids.reverse()
- self.assertEquals(found_event_ids, expected_event_ids)
+ self.assertEqual(found_event_ids, expected_event_ids)
# Reset and try again, but convert the tokens to the legacy format.
prev_token = ""
@@ -506,7 +506,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
f"/m.reaction/{encoded_key}?limit=1{from_token}",
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
self.assertEqual(len(channel.json_body["chunk"]), 1, channel.json_body)
@@ -514,7 +514,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
next_batch = channel.json_body.get("next_batch")
- self.assertNotEquals(prev_token, next_batch)
+ self.assertNotEqual(prev_token, next_batch)
prev_token = next_batch
if not prev_token:
@@ -522,21 +522,21 @@ class RelationsTestCase(unittest.HomeserverTestCase):
# We paginated backwards, so reverse
found_event_ids.reverse()
- self.assertEquals(found_event_ids, expected_event_ids)
+ self.assertEqual(found_event_ids, expected_event_ids)
def test_aggregation(self):
"""Test that annotations get correctly aggregated."""
channel = self._send_relation(RelationTypes.ANNOTATION, "m.reaction", "a")
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
channel = self._send_relation(
RelationTypes.ANNOTATION, "m.reaction", "a", access_token=self.user2_token
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
channel = self._send_relation(RelationTypes.ANNOTATION, "m.reaction", "b")
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
channel = self.make_request(
"GET",
@@ -544,9 +544,9 @@ class RelationsTestCase(unittest.HomeserverTestCase):
% (self.room, self.parent_id),
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
- self.assertEquals(
+ self.assertEqual(
channel.json_body,
{
"chunk": [
@@ -560,13 +560,13 @@ class RelationsTestCase(unittest.HomeserverTestCase):
"""Test that annotations get correctly aggregated after a redaction."""
channel = self._send_relation(RelationTypes.ANNOTATION, "m.reaction", "a")
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
to_redact_event_id = channel.json_body["event_id"]
channel = self._send_relation(
RelationTypes.ANNOTATION, "m.reaction", "a", access_token=self.user2_token
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
# Now lets redact one of the 'a' reactions
channel = self.make_request(
@@ -575,7 +575,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
access_token=self.user_token,
content={},
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
channel = self.make_request(
"GET",
@@ -583,9 +583,9 @@ class RelationsTestCase(unittest.HomeserverTestCase):
% (self.room, self.parent_id),
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
- self.assertEquals(
+ self.assertEqual(
channel.json_body,
{"chunk": [{"type": "m.reaction", "key": "a", "count": 1}]},
)
@@ -599,7 +599,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
% (self.room, self.parent_id, RelationTypes.REPLACE),
access_token=self.user_token,
)
- self.assertEquals(400, channel.code, channel.json_body)
+ self.assertEqual(400, channel.code, channel.json_body)
@unittest.override_config(
{"experimental_features": {"msc3440_enabled": True, "msc3666_enabled": True}}
@@ -615,29 +615,29 @@ class RelationsTestCase(unittest.HomeserverTestCase):
"""
# Setup by sending a variety of relations.
channel = self._send_relation(RelationTypes.ANNOTATION, "m.reaction", "a")
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
channel = self._send_relation(
RelationTypes.ANNOTATION, "m.reaction", "a", access_token=self.user2_token
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
channel = self._send_relation(RelationTypes.ANNOTATION, "m.reaction", "b")
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
channel = self._send_relation(RelationTypes.REFERENCE, "m.room.test")
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
reply_1 = channel.json_body["event_id"]
channel = self._send_relation(RelationTypes.REFERENCE, "m.room.test")
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
reply_2 = channel.json_body["event_id"]
channel = self._send_relation(RelationTypes.THREAD, "m.room.test")
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
channel = self._send_relation(RelationTypes.THREAD, "m.room.test")
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
thread_2 = channel.json_body["event_id"]
def assert_bundle(event_json: JsonDict) -> None:
@@ -655,7 +655,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
)
# Check the values of each field.
- self.assertEquals(
+ self.assertEqual(
{
"chunk": [
{"type": "m.reaction", "key": "a", "count": 2},
@@ -665,12 +665,12 @@ class RelationsTestCase(unittest.HomeserverTestCase):
relations_dict[RelationTypes.ANNOTATION],
)
- self.assertEquals(
+ self.assertEqual(
{"chunk": [{"event_id": reply_1}, {"event_id": reply_2}]},
relations_dict[RelationTypes.REFERENCE],
)
- self.assertEquals(
+ self.assertEqual(
2,
relations_dict[RelationTypes.THREAD].get("count"),
)
@@ -701,7 +701,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
f"/rooms/{self.room}/event/{self.parent_id}",
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
assert_bundle(channel.json_body)
# Request the room messages.
@@ -710,7 +710,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
f"/rooms/{self.room}/messages?dir=b",
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
assert_bundle(self._find_event_in_chunk(channel.json_body["chunk"]))
# Request the room context.
@@ -719,12 +719,12 @@ class RelationsTestCase(unittest.HomeserverTestCase):
f"/rooms/{self.room}/context/{self.parent_id}",
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
assert_bundle(channel.json_body["event"])
# Request sync.
channel = self.make_request("GET", "/sync", access_token=self.user_token)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
room_timeline = channel.json_body["rooms"]["join"][self.room]["timeline"]
self.assertTrue(room_timeline["limited"])
assert_bundle(self._find_event_in_chunk(room_timeline["events"]))
@@ -737,7 +737,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
content={"search_categories": {"room_events": {"search_term": "Hi"}}},
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
chunk = [
result["result"]
for result in channel.json_body["search_categories"]["room_events"][
@@ -751,42 +751,42 @@ class RelationsTestCase(unittest.HomeserverTestCase):
when directly requested.
"""
channel = self._send_relation(RelationTypes.ANNOTATION, "m.reaction", "a")
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
annotation_id = channel.json_body["event_id"]
# Annotate the annotation.
channel = self._send_relation(
RelationTypes.ANNOTATION, "m.reaction", "a", parent_id=annotation_id
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
channel = self.make_request(
"GET",
f"/rooms/{self.room}/event/{annotation_id}",
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
self.assertIsNone(channel.json_body["unsigned"].get("m.relations"))
def test_aggregation_get_event_for_thread(self):
"""Test that threads get bundled aggregations included when directly requested."""
channel = self._send_relation(RelationTypes.THREAD, "m.room.test")
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
thread_id = channel.json_body["event_id"]
# Annotate the annotation.
channel = self._send_relation(
RelationTypes.ANNOTATION, "m.reaction", "a", parent_id=thread_id
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
channel = self.make_request(
"GET",
f"/rooms/{self.room}/event/{thread_id}",
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
- self.assertEquals(
+ self.assertEqual(200, channel.code, channel.json_body)
+ self.assertEqual(
channel.json_body["unsigned"].get("m.relations"),
{
RelationTypes.ANNOTATION: {
@@ -801,11 +801,11 @@ class RelationsTestCase(unittest.HomeserverTestCase):
f"/_matrix/client/unstable/rooms/{self.room}/relations/{self.parent_id}?limit=1",
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
self.assertEqual(len(channel.json_body["chunk"]), 1)
thread_message = channel.json_body["chunk"][0]
- self.assertEquals(
+ self.assertEqual(
thread_message["unsigned"].get("m.relations"),
{
RelationTypes.ANNOTATION: {
@@ -905,7 +905,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
f"/_matrix/client/unstable/rooms/{room2}/relations/{parent_id}",
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
self.assertEqual(channel.json_body["chunk"], [])
# And when fetching aggregations.
@@ -914,7 +914,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
f"/_matrix/client/unstable/rooms/{room2}/aggregations/{parent_id}",
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
self.assertEqual(channel.json_body["chunk"], [])
# And for bundled aggregations.
@@ -923,7 +923,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
f"/rooms/{room2}/event/{parent_id}",
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
self.assertNotIn("m.relations", channel.json_body["unsigned"])
@unittest.override_config({"experimental_features": {"msc3666_enabled": True}})
@@ -936,7 +936,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
"m.room.message",
content={"msgtype": "m.text", "body": "foo", "m.new_content": new_body},
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
edit_event_id = channel.json_body["event_id"]
@@ -958,8 +958,8 @@ class RelationsTestCase(unittest.HomeserverTestCase):
f"/rooms/{self.room}/event/{self.parent_id}",
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
- self.assertEquals(channel.json_body["content"], new_body)
+ self.assertEqual(200, channel.code, channel.json_body)
+ self.assertEqual(channel.json_body["content"], new_body)
assert_bundle(channel.json_body)
# Request the room messages.
@@ -968,7 +968,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
f"/rooms/{self.room}/messages?dir=b",
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
assert_bundle(self._find_event_in_chunk(channel.json_body["chunk"]))
# Request the room context.
@@ -977,7 +977,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
f"/rooms/{self.room}/context/{self.parent_id}",
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
assert_bundle(channel.json_body["event"])
# Request sync, but limit the timeline so it becomes limited (and includes
@@ -988,7 +988,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
channel = self.make_request(
"GET", f"/sync?filter={filter}", access_token=self.user_token
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
room_timeline = channel.json_body["rooms"]["join"][self.room]["timeline"]
self.assertTrue(room_timeline["limited"])
assert_bundle(self._find_event_in_chunk(room_timeline["events"]))
@@ -1001,7 +1001,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
content={"search_categories": {"room_events": {"search_term": "Hi"}}},
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
chunk = [
result["result"]
for result in channel.json_body["search_categories"]["room_events"][
@@ -1024,7 +1024,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
"m.new_content": {"msgtype": "m.text", "body": "First edit"},
},
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
new_body = {"msgtype": "m.text", "body": "I've been edited!"}
channel = self._send_relation(
@@ -1032,7 +1032,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
"m.room.message",
content={"msgtype": "m.text", "body": "foo", "m.new_content": new_body},
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
edit_event_id = channel.json_body["event_id"]
@@ -1045,16 +1045,16 @@ class RelationsTestCase(unittest.HomeserverTestCase):
"m.new_content": {"msgtype": "m.text", "body": "Edit, but wrong type"},
},
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
channel = self.make_request(
"GET",
"/rooms/%s/event/%s" % (self.room, self.parent_id),
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
- self.assertEquals(channel.json_body["content"], new_body)
+ self.assertEqual(channel.json_body["content"], new_body)
relations_dict = channel.json_body["unsigned"].get("m.relations")
self.assertIn(RelationTypes.REPLACE, relations_dict)
@@ -1076,7 +1076,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
"m.room.message",
content={"msgtype": "m.text", "body": "A reply!"},
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
reply = channel.json_body["event_id"]
new_body = {"msgtype": "m.text", "body": "I've been edited!"}
@@ -1086,7 +1086,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
content={"msgtype": "m.text", "body": "foo", "m.new_content": new_body},
parent_id=reply,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
edit_event_id = channel.json_body["event_id"]
@@ -1095,7 +1095,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
"/rooms/%s/event/%s" % (self.room, reply),
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
# We expect to see the new body in the dict, as well as the reference
# metadata sill intact.
@@ -1133,7 +1133,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
"m.room.message",
content={"msgtype": "m.text", "body": "A threaded reply!"},
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
threaded_event_id = channel.json_body["event_id"]
new_body = {"msgtype": "m.text", "body": "I've been edited!"}
@@ -1143,7 +1143,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
content={"msgtype": "m.text", "body": "foo", "m.new_content": new_body},
parent_id=threaded_event_id,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
# Fetch the thread root, to get the bundled aggregation for the thread.
channel = self.make_request(
@@ -1151,7 +1151,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
f"/rooms/{self.room}/event/{self.parent_id}",
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
# We expect that the edit message appears in the thread summary in the
# unsigned relations section.
@@ -1161,9 +1161,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
thread_summary = relations_dict[RelationTypes.THREAD]
self.assertIn("latest_event", thread_summary)
latest_event_in_thread = thread_summary["latest_event"]
- self.assertEquals(
- latest_event_in_thread["content"]["body"], "I've been edited!"
- )
+ self.assertEqual(latest_event_in_thread["content"]["body"], "I've been edited!")
def test_edit_edit(self):
"""Test that an edit cannot be edited."""
@@ -1177,7 +1175,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
"m.new_content": new_body,
},
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
edit_event_id = channel.json_body["event_id"]
# Edit the edit event.
@@ -1191,7 +1189,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
},
parent_id=edit_event_id,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
# Request the original event.
channel = self.make_request(
@@ -1199,9 +1197,9 @@ class RelationsTestCase(unittest.HomeserverTestCase):
"/rooms/%s/event/%s" % (self.room, self.parent_id),
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
# The edit to the edit should be ignored.
- self.assertEquals(channel.json_body["content"], new_body)
+ self.assertEqual(channel.json_body["content"], new_body)
# The relations information should not include the edit to the edit.
relations_dict = channel.json_body["unsigned"].get("m.relations")
@@ -1234,7 +1232,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
"m.new_content": {"msgtype": "m.text", "body": "First edit"},
},
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
# Check the relation is returned
channel = self.make_request(
@@ -1243,10 +1241,10 @@ class RelationsTestCase(unittest.HomeserverTestCase):
% (self.room, original_event_id),
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
self.assertIn("chunk", channel.json_body)
- self.assertEquals(len(channel.json_body["chunk"]), 1)
+ self.assertEqual(len(channel.json_body["chunk"]), 1)
# Redact the original event
channel = self.make_request(
@@ -1256,7 +1254,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
access_token=self.user_token,
content="{}",
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
# Try to check for remaining m.replace relations
channel = self.make_request(
@@ -1265,11 +1263,11 @@ class RelationsTestCase(unittest.HomeserverTestCase):
% (self.room, original_event_id),
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
# Check that no relations are returned
self.assertIn("chunk", channel.json_body)
- self.assertEquals(channel.json_body["chunk"], [])
+ self.assertEqual(channel.json_body["chunk"], [])
def test_aggregations_redaction_prevents_access_to_aggregations(self):
"""Test that annotations of an event are redacted when the original event
@@ -1283,7 +1281,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
channel = self._send_relation(
RelationTypes.ANNOTATION, "m.reaction", key="👍", parent_id=original_event_id
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
# Redact the original
channel = self.make_request(
@@ -1297,7 +1295,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
access_token=self.user_token,
content="{}",
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
# Check that aggregations returns zero
channel = self.make_request(
@@ -1306,15 +1304,15 @@ class RelationsTestCase(unittest.HomeserverTestCase):
% (self.room, original_event_id),
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
self.assertIn("chunk", channel.json_body)
- self.assertEquals(channel.json_body["chunk"], [])
+ self.assertEqual(channel.json_body["chunk"], [])
def test_unknown_relations(self):
"""Unknown relations should be accepted."""
channel = self._send_relation("m.relation.test", "m.room.test")
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
event_id = channel.json_body["event_id"]
channel = self.make_request(
@@ -1323,18 +1321,18 @@ class RelationsTestCase(unittest.HomeserverTestCase):
% (self.room, self.parent_id),
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
# We expect to get back a single pagination result, which is the full
# relation event we sent above.
- self.assertEquals(len(channel.json_body["chunk"]), 1, channel.json_body)
+ self.assertEqual(len(channel.json_body["chunk"]), 1, channel.json_body)
self.assert_dict(
{"event_id": event_id, "sender": self.user_id, "type": "m.room.test"},
channel.json_body["chunk"][0],
)
# We also expect to get the original event (the id of which is self.parent_id)
- self.assertEquals(
+ self.assertEqual(
channel.json_body["original_event"]["event_id"], self.parent_id
)
@@ -1344,7 +1342,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
"/rooms/%s/event/%s" % (self.room, self.parent_id),
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
self.assertNotIn("m.relations", channel.json_body["unsigned"])
# But unknown relations can be directly queried.
@@ -1354,8 +1352,8 @@ class RelationsTestCase(unittest.HomeserverTestCase):
% (self.room, self.parent_id),
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
- self.assertEquals(channel.json_body["chunk"], [])
+ self.assertEqual(200, channel.code, channel.json_body)
+ self.assertEqual(channel.json_body["chunk"], [])
def _find_event_in_chunk(self, events: List[JsonDict]) -> JsonDict:
"""
@@ -1422,15 +1420,15 @@ class RelationsTestCase(unittest.HomeserverTestCase):
def test_background_update(self):
"""Test the event_arbitrary_relations background update."""
channel = self._send_relation(RelationTypes.ANNOTATION, "m.reaction", key="👍")
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
annotation_event_id_good = channel.json_body["event_id"]
channel = self._send_relation(RelationTypes.ANNOTATION, "m.reaction", key="A")
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
annotation_event_id_bad = channel.json_body["event_id"]
channel = self._send_relation(RelationTypes.THREAD, "m.room.test")
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
thread_event_id = channel.json_body["event_id"]
# Clean-up the table as if the inserts did not happen during event creation.
@@ -1450,8 +1448,8 @@ class RelationsTestCase(unittest.HomeserverTestCase):
f"/_matrix/client/unstable/rooms/{self.room}/relations/{self.parent_id}?limit=10",
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
- self.assertEquals(
+ self.assertEqual(200, channel.code, channel.json_body)
+ self.assertEqual(
[ev["event_id"] for ev in channel.json_body["chunk"]],
[annotation_event_id_good],
)
@@ -1475,7 +1473,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
f"/_matrix/client/unstable/rooms/{self.room}/relations/{self.parent_id}?limit=10",
access_token=self.user_token,
)
- self.assertEquals(200, channel.code, channel.json_body)
+ self.assertEqual(200, channel.code, channel.json_body)
self.assertCountEqual(
[ev["event_id"] for ev in channel.json_body["chunk"]],
[annotation_event_id_good, thread_event_id],
diff --git a/tests/rest/client/test_rooms.py b/tests/rest/client/test_rooms.py
index 1afd96b8f5..e0b11e7264 100644
--- a/tests/rest/client/test_rooms.py
+++ b/tests/rest/client/test_rooms.py
@@ -95,7 +95,7 @@ class RoomPermissionsTestCase(RoomBase):
channel = self.make_request(
"PUT", self.created_rmid_msg_path, b'{"msgtype":"m.text","body":"test msg"}'
)
- self.assertEquals(200, channel.code, channel.result)
+ self.assertEqual(200, channel.code, channel.result)
# set topic for public room
channel = self.make_request(
@@ -103,7 +103,7 @@ class RoomPermissionsTestCase(RoomBase):
("rooms/%s/state/m.room.topic" % self.created_public_rmid).encode("ascii"),
b'{"topic":"Public Room Topic"}',
)
- self.assertEquals(200, channel.code, channel.result)
+ self.assertEqual(200, channel.code, channel.result)
# auth as user_id now
self.helper.auth_user_id = self.user_id
@@ -125,28 +125,28 @@ class RoomPermissionsTestCase(RoomBase):
"/rooms/%s/send/m.room.message/mid2" % (self.uncreated_rmid,),
msg_content,
)
- self.assertEquals(403, channel.code, msg=channel.result["body"])
+ self.assertEqual(403, channel.code, msg=channel.result["body"])
# send message in created room not joined (no state), expect 403
channel = self.make_request("PUT", send_msg_path(), msg_content)
- self.assertEquals(403, channel.code, msg=channel.result["body"])
+ self.assertEqual(403, channel.code, msg=channel.result["body"])
# send message in created room and invited, expect 403
self.helper.invite(
room=self.created_rmid, src=self.rmcreator_id, targ=self.user_id
)
channel = self.make_request("PUT", send_msg_path(), msg_content)
- self.assertEquals(403, channel.code, msg=channel.result["body"])
+ self.assertEqual(403, channel.code, msg=channel.result["body"])
# send message in created room and joined, expect 200
self.helper.join(room=self.created_rmid, user=self.user_id)
channel = self.make_request("PUT", send_msg_path(), msg_content)
- self.assertEquals(200, channel.code, msg=channel.result["body"])
+ self.assertEqual(200, channel.code, msg=channel.result["body"])
# send message in created room and left, expect 403
self.helper.leave(room=self.created_rmid, user=self.user_id)
channel = self.make_request("PUT", send_msg_path(), msg_content)
- self.assertEquals(403, channel.code, msg=channel.result["body"])
+ self.assertEqual(403, channel.code, msg=channel.result["body"])
def test_topic_perms(self):
topic_content = b'{"topic":"My Topic Name"}'
@@ -156,28 +156,28 @@ class RoomPermissionsTestCase(RoomBase):
channel = self.make_request(
"PUT", "/rooms/%s/state/m.room.topic" % self.uncreated_rmid, topic_content
)
- self.assertEquals(403, channel.code, msg=channel.result["body"])
+ self.assertEqual(403, channel.code, msg=channel.result["body"])
channel = self.make_request(
"GET", "/rooms/%s/state/m.room.topic" % self.uncreated_rmid
)
- self.assertEquals(403, channel.code, msg=channel.result["body"])
+ self.assertEqual(403, channel.code, msg=channel.result["body"])
# set/get topic in created PRIVATE room not joined, expect 403
channel = self.make_request("PUT", topic_path, topic_content)
- self.assertEquals(403, channel.code, msg=channel.result["body"])
+ self.assertEqual(403, channel.code, msg=channel.result["body"])
channel = self.make_request("GET", topic_path)
- self.assertEquals(403, channel.code, msg=channel.result["body"])
+ self.assertEqual(403, channel.code, msg=channel.result["body"])
# set topic in created PRIVATE room and invited, expect 403
self.helper.invite(
room=self.created_rmid, src=self.rmcreator_id, targ=self.user_id
)
channel = self.make_request("PUT", topic_path, topic_content)
- self.assertEquals(403, channel.code, msg=channel.result["body"])
+ self.assertEqual(403, channel.code, msg=channel.result["body"])
# get topic in created PRIVATE room and invited, expect 403
channel = self.make_request("GET", topic_path)
- self.assertEquals(403, channel.code, msg=channel.result["body"])
+ self.assertEqual(403, channel.code, msg=channel.result["body"])
# set/get topic in created PRIVATE room and joined, expect 200
self.helper.join(room=self.created_rmid, user=self.user_id)
@@ -185,25 +185,25 @@ class RoomPermissionsTestCase(RoomBase):
# Only room ops can set topic by default
self.helper.auth_user_id = self.rmcreator_id
channel = self.make_request("PUT", topic_path, topic_content)
- self.assertEquals(200, channel.code, msg=channel.result["body"])
+ self.assertEqual(200, channel.code, msg=channel.result["body"])
self.helper.auth_user_id = self.user_id
channel = self.make_request("GET", topic_path)
- self.assertEquals(200, channel.code, msg=channel.result["body"])
+ self.assertEqual(200, channel.code, msg=channel.result["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)
channel = self.make_request("PUT", topic_path, topic_content)
- self.assertEquals(403, channel.code, msg=channel.result["body"])
+ self.assertEqual(403, channel.code, msg=channel.result["body"])
channel = self.make_request("GET", topic_path)
- self.assertEquals(200, channel.code, msg=channel.result["body"])
+ self.assertEqual(200, channel.code, msg=channel.result["body"])
# get topic in PUBLIC room, not joined, expect 403
channel = self.make_request(
"GET", "/rooms/%s/state/m.room.topic" % self.created_public_rmid
)
- self.assertEquals(403, channel.code, msg=channel.result["body"])
+ self.assertEqual(403, channel.code, msg=channel.result["body"])
# set topic in PUBLIC room, not joined, expect 403
channel = self.make_request(
@@ -211,7 +211,7 @@ class RoomPermissionsTestCase(RoomBase):
"/rooms/%s/state/m.room.topic" % self.created_public_rmid,
topic_content,
)
- self.assertEquals(403, channel.code, msg=channel.result["body"])
+ self.assertEqual(403, channel.code, msg=channel.result["body"])
def _test_get_membership(
self, room=None, members: Iterable = frozenset(), expect_code=None
@@ -219,7 +219,7 @@ class RoomPermissionsTestCase(RoomBase):
for member in members:
path = "/rooms/%s/state/m.room.member/%s" % (room, member)
channel = self.make_request("GET", path)
- self.assertEquals(expect_code, channel.code)
+ self.assertEqual(expect_code, channel.code)
def test_membership_basic_room_perms(self):
# === room does not exist ===
@@ -478,16 +478,16 @@ class RoomsMemberListTestCase(RoomBase):
def test_get_member_list(self):
room_id = self.helper.create_room_as(self.user_id)
channel = self.make_request("GET", "/rooms/%s/members" % room_id)
- self.assertEquals(200, channel.code, msg=channel.result["body"])
+ self.assertEqual(200, channel.code, msg=channel.result["body"])
def test_get_member_list_no_room(self):
channel = self.make_request("GET", "/rooms/roomdoesnotexist/members")
- self.assertEquals(403, channel.code, msg=channel.result["body"])
+ self.assertEqual(403, channel.code, msg=channel.result["body"])
def test_get_member_list_no_permission(self):
room_id = self.helper.create_room_as("@some_other_guy:red")
channel = self.make_request("GET", "/rooms/%s/members" % room_id)
- self.assertEquals(403, channel.code, msg=channel.result["body"])
+ self.assertEqual(403, channel.code, msg=channel.result["body"])
def test_get_member_list_no_permission_with_at_token(self):
"""
@@ -498,7 +498,7 @@ class RoomsMemberListTestCase(RoomBase):
# first sync to get an at token
channel = self.make_request("GET", "/sync")
- self.assertEquals(200, channel.code)
+ self.assertEqual(200, channel.code)
sync_token = channel.json_body["next_batch"]
# check that permission is denied for @sid1:red to get the
@@ -507,7 +507,7 @@ class RoomsMemberListTestCase(RoomBase):
"GET",
f"/rooms/{room_id}/members?at={sync_token}",
)
- self.assertEquals(403, channel.code, msg=channel.result["body"])
+ self.assertEqual(403, channel.code, msg=channel.result["body"])
def test_get_member_list_no_permission_former_member(self):
"""
@@ -520,14 +520,14 @@ class RoomsMemberListTestCase(RoomBase):
# check that the user can see the member list to start with
channel = self.make_request("GET", "/rooms/%s/members" % room_id)
- self.assertEquals(200, channel.code, msg=channel.result["body"])
+ self.assertEqual(200, channel.code, msg=channel.result["body"])
# ban the user
self.helper.change_membership(room_id, "@alice:red", self.user_id, "ban")
# check the user can no longer see the member list
channel = self.make_request("GET", "/rooms/%s/members" % room_id)
- self.assertEquals(403, channel.code, msg=channel.result["body"])
+ self.assertEqual(403, channel.code, msg=channel.result["body"])
def test_get_member_list_no_permission_former_member_with_at_token(self):
"""
@@ -541,14 +541,14 @@ class RoomsMemberListTestCase(RoomBase):
# sync to get an at token
channel = self.make_request("GET", "/sync")
- self.assertEquals(200, channel.code)
+ self.assertEqual(200, channel.code)
sync_token = channel.json_body["next_batch"]
# check that the user can see the member list to start with
channel = self.make_request(
"GET", "/rooms/%s/members?at=%s" % (room_id, sync_token)
)
- self.assertEquals(200, channel.code, msg=channel.result["body"])
+ self.assertEqual(200, channel.code, msg=channel.result["body"])
# ban the user (Note: the user is actually allowed to see this event and
# state so that they know they're banned!)
@@ -560,14 +560,14 @@ class RoomsMemberListTestCase(RoomBase):
# now, with the original user, sync again to get a new at token
channel = self.make_request("GET", "/sync")
- self.assertEquals(200, channel.code)
+ self.assertEqual(200, channel.code)
sync_token = channel.json_body["next_batch"]
# check the user can no longer see the updated member list
channel = self.make_request(
"GET", "/rooms/%s/members?at=%s" % (room_id, sync_token)
)
- self.assertEquals(403, channel.code, msg=channel.result["body"])
+ self.assertEqual(403, channel.code, msg=channel.result["body"])
def test_get_member_list_mixed_memberships(self):
room_creator = "@some_other_guy:red"
@@ -576,17 +576,17 @@ class RoomsMemberListTestCase(RoomBase):
self.helper.invite(room=room_id, src=room_creator, targ=self.user_id)
# can't see list if you're just invited.
channel = self.make_request("GET", room_path)
- self.assertEquals(403, channel.code, msg=channel.result["body"])
+ self.assertEqual(403, channel.code, msg=channel.result["body"])
self.helper.join(room=room_id, user=self.user_id)
# can see list now joined
channel = self.make_request("GET", room_path)
- self.assertEquals(200, channel.code, msg=channel.result["body"])
+ self.assertEqual(200, channel.code, msg=channel.result["body"])
self.helper.leave(room=room_id, user=self.user_id)
# can see old list once left
channel = self.make_request("GET", room_path)
- self.assertEquals(200, channel.code, msg=channel.result["body"])
+ self.assertEqual(200, channel.code, msg=channel.result["body"])
class RoomsCreateTestCase(RoomBase):
@@ -598,19 +598,19 @@ class RoomsCreateTestCase(RoomBase):
# POST with no config keys, expect new room id
channel = self.make_request("POST", "/createRoom", "{}")
- self.assertEquals(200, channel.code, channel.result)
+ self.assertEqual(200, channel.code, channel.result)
self.assertTrue("room_id" in channel.json_body)
def test_post_room_visibility_key(self):
# POST with visibility config key, expect new room id
channel = self.make_request("POST", "/createRoom", b'{"visibility":"private"}')
- self.assertEquals(200, channel.code)
+ self.assertEqual(200, channel.code)
self.assertTrue("room_id" in channel.json_body)
def test_post_room_custom_key(self):
# POST with custom config keys, expect new room id
channel = self.make_request("POST", "/createRoom", b'{"custom":"stuff"}')
- self.assertEquals(200, channel.code)
+ self.assertEqual(200, channel.code)
self.assertTrue("room_id" in channel.json_body)
def test_post_room_known_and_unknown_keys(self):
@@ -618,16 +618,16 @@ class RoomsCreateTestCase(RoomBase):
channel = self.make_request(
"POST", "/createRoom", b'{"visibility":"private","custom":"things"}'
)
- self.assertEquals(200, channel.code)
+ self.assertEqual(200, channel.code)
self.assertTrue("room_id" in channel.json_body)
def test_post_room_invalid_content(self):
# POST with invalid content / paths, expect 400
channel = self.make_request("POST", "/createRoom", b'{"visibili')
- self.assertEquals(400, channel.code)
+ self.assertEqual(400, channel.code)
channel = self.make_request("POST", "/createRoom", b'["hello"]')
- self.assertEquals(400, channel.code)
+ self.assertEqual(400, channel.code)
def test_post_room_invitees_invalid_mxid(self):
# POST with invalid invitee, see https://github.com/matrix-org/synapse/issues/4088
@@ -635,7 +635,7 @@ class RoomsCreateTestCase(RoomBase):
channel = self.make_request(
"POST", "/createRoom", b'{"invite":["@alice:example.com "]}'
)
- self.assertEquals(400, channel.code)
+ self.assertEqual(400, channel.code)
@unittest.override_config({"rc_invites": {"per_room": {"burst_count": 3}}})
def test_post_room_invitees_ratelimit(self):
@@ -694,9 +694,9 @@ class RoomsCreateTestCase(RoomBase):
"/createRoom",
{},
)
- self.assertEquals(channel.code, 200, channel.json_body)
+ self.assertEqual(channel.code, 200, channel.json_body)
- self.assertEquals(join_mock.call_count, 0)
+ self.assertEqual(join_mock.call_count, 0)
class RoomTopicTestCase(RoomBase):
@@ -712,54 +712,54 @@ class RoomTopicTestCase(RoomBase):
def test_invalid_puts(self):
# missing keys or invalid json
channel = self.make_request("PUT", self.path, "{}")
- self.assertEquals(400, channel.code, msg=channel.result["body"])
+ self.assertEqual(400, channel.code, msg=channel.result["body"])
channel = self.make_request("PUT", self.path, '{"_name":"bo"}')
- self.assertEquals(400, channel.code, msg=channel.result["body"])
+ self.assertEqual(400, channel.code, msg=channel.result["body"])
channel = self.make_request("PUT", self.path, '{"nao')
- self.assertEquals(400, channel.code, msg=channel.result["body"])
+ self.assertEqual(400, channel.code, msg=channel.result["body"])
channel = self.make_request(
"PUT", self.path, '[{"_name":"bo"},{"_name":"jill"}]'
)
- self.assertEquals(400, channel.code, msg=channel.result["body"])
+ self.assertEqual(400, channel.code, msg=channel.result["body"])
channel = self.make_request("PUT", self.path, "text only")
- self.assertEquals(400, channel.code, msg=channel.result["body"])
+ self.assertEqual(400, channel.code, msg=channel.result["body"])
channel = self.make_request("PUT", self.path, "")
- self.assertEquals(400, channel.code, msg=channel.result["body"])
+ self.assertEqual(400, channel.code, msg=channel.result["body"])
# valid key, wrong type
content = '{"topic":["Topic name"]}'
channel = self.make_request("PUT", self.path, content)
- self.assertEquals(400, channel.code, msg=channel.result["body"])
+ self.assertEqual(400, channel.code, msg=channel.result["body"])
def test_rooms_topic(self):
# nothing should be there
channel = self.make_request("GET", self.path)
- self.assertEquals(404, channel.code, msg=channel.result["body"])
+ self.assertEqual(404, channel.code, msg=channel.result["body"])
# valid put
content = '{"topic":"Topic name"}'
channel = self.make_request("PUT", self.path, content)
- self.assertEquals(200, channel.code, msg=channel.result["body"])
+ self.assertEqual(200, channel.code, msg=channel.result["body"])
# valid get
channel = self.make_request("GET", self.path)
- self.assertEquals(200, channel.code, msg=channel.result["body"])
+ self.assertEqual(200, channel.code, msg=channel.result["body"])
self.assert_dict(json.loads(content), channel.json_body)
def test_rooms_topic_with_extra_keys(self):
# valid put with extra keys
content = '{"topic":"Seasons","subtopic":"Summer"}'
channel = self.make_request("PUT", self.path, content)
- self.assertEquals(200, channel.code, msg=channel.result["body"])
+ self.assertEqual(200, channel.code, msg=channel.result["body"])
# valid get
channel = self.make_request("GET", self.path)
- self.assertEquals(200, channel.code, msg=channel.result["body"])
+ self.assertEqual(200, channel.code, msg=channel.result["body"])
self.assert_dict(json.loads(content), channel.json_body)
@@ -775,22 +775,22 @@ class RoomMemberStateTestCase(RoomBase):
path = "/rooms/%s/state/m.room.member/%s" % (self.room_id, self.user_id)
# missing keys or invalid json
channel = self.make_request("PUT", path, "{}")
- self.assertEquals(400, channel.code, msg=channel.result["body"])
+ self.assertEqual(400, channel.code, msg=channel.result["body"])
channel = self.make_request("PUT", path, '{"_name":"bo"}')
- self.assertEquals(400, channel.code, msg=channel.result["body"])
+ self.assertEqual(400, channel.code, msg=channel.result["body"])
channel = self.make_request("PUT", path, '{"nao')
- self.assertEquals(400, channel.code, msg=channel.result["body"])
+ self.assertEqual(400, channel.code, msg=channel.result["body"])
channel = self.make_request("PUT", path, b'[{"_name":"bo"},{"_name":"jill"}]')
- self.assertEquals(400, channel.code, msg=channel.result["body"])
+ self.assertEqual(400, channel.code, msg=channel.result["body"])
channel = self.make_request("PUT", path, "text only")
- self.assertEquals(400, channel.code, msg=channel.result["body"])
+ self.assertEqual(400, channel.code, msg=channel.result["body"])
channel = self.make_request("PUT", path, "")
- self.assertEquals(400, channel.code, msg=channel.result["body"])
+ self.assertEqual(400, channel.code, msg=channel.result["body"])
# valid keys, wrong types
content = '{"membership":["%s","%s","%s"]}' % (
@@ -799,7 +799,7 @@ class RoomMemberStateTestCase(RoomBase):
Membership.LEAVE,
)
channel = self.make_request("PUT", path, content.encode("ascii"))
- self.assertEquals(400, channel.code, msg=channel.result["body"])
+ self.assertEqual(400, channel.code, msg=channel.result["body"])
def test_rooms_members_self(self):
path = "/rooms/%s/state/m.room.member/%s" % (
@@ -810,13 +810,13 @@ class RoomMemberStateTestCase(RoomBase):
# valid join message (NOOP since we made the room)
content = '{"membership":"%s"}' % Membership.JOIN
channel = self.make_request("PUT", path, content.encode("ascii"))
- self.assertEquals(200, channel.code, msg=channel.result["body"])
+ self.assertEqual(200, channel.code, msg=channel.result["body"])
channel = self.make_request("GET", path, None)
- self.assertEquals(200, channel.code, msg=channel.result["body"])
+ self.assertEqual(200, channel.code, msg=channel.result["body"])
expected_response = {"membership": Membership.JOIN}
- self.assertEquals(expected_response, channel.json_body)
+ self.assertEqual(expected_response, channel.json_body)
def test_rooms_members_other(self):
self.other_id = "@zzsid1:red"
@@ -828,11 +828,11 @@ class RoomMemberStateTestCase(RoomBase):
# valid invite message
content = '{"membership":"%s"}' % Membership.INVITE
channel = self.make_request("PUT", path, content)
- self.assertEquals(200, channel.code, msg=channel.result["body"])
+ self.assertEqual(200, channel.code, msg=channel.result["body"])
channel = self.make_request("GET", path, None)
- self.assertEquals(200, channel.code, msg=channel.result["body"])
- self.assertEquals(json.loads(content), channel.json_body)
+ self.assertEqual(200, channel.code, msg=channel.result["body"])
+ self.assertEqual(json.loads(content), channel.json_body)
def test_rooms_members_other_custom_keys(self):
self.other_id = "@zzsid1:red"
@@ -847,11 +847,11 @@ class RoomMemberStateTestCase(RoomBase):
"Join us!",
)
channel = self.make_request("PUT", path, content)
- self.assertEquals(200, channel.code, msg=channel.result["body"])
+ self.assertEqual(200, channel.code, msg=channel.result["body"])
channel = self.make_request("GET", path, None)
- self.assertEquals(200, channel.code, msg=channel.result["body"])
- self.assertEquals(json.loads(content), channel.json_body)
+ self.assertEqual(200, channel.code, msg=channel.result["body"])
+ self.assertEqual(json.loads(content), channel.json_body)
class RoomInviteRatelimitTestCase(RoomBase):
@@ -937,7 +937,7 @@ class RoomJoinTestCase(RoomBase):
False,
),
)
- self.assertEquals(
+ self.assertEqual(
callback_mock.call_args,
expected_call_args,
callback_mock.call_args,
@@ -955,7 +955,7 @@ class RoomJoinTestCase(RoomBase):
True,
),
)
- self.assertEquals(
+ self.assertEqual(
callback_mock.call_args,
expected_call_args,
callback_mock.call_args,
@@ -1013,7 +1013,7 @@ class RoomJoinRatelimitTestCase(RoomBase):
# Update the display name for the user.
path = "/_matrix/client/r0/profile/%s/displayname" % self.user_id
channel = self.make_request("PUT", path, {"displayname": "John Doe"})
- self.assertEquals(channel.code, 200, channel.json_body)
+ self.assertEqual(channel.code, 200, channel.json_body)
# Check that all the rooms have been sent a profile update into.
for room_id in room_ids:
@@ -1023,10 +1023,10 @@ class RoomJoinRatelimitTestCase(RoomBase):
)
channel = self.make_request("GET", path)
- self.assertEquals(channel.code, 200)
+ self.assertEqual(channel.code, 200)
self.assertIn("displayname", channel.json_body)
- self.assertEquals(channel.json_body["displayname"], "John Doe")
+ self.assertEqual(channel.json_body["displayname"], "John Doe")
@unittest.override_config(
{"rc_joins": {"local": {"per_second": 0.5, "burst_count": 3}}}
@@ -1047,7 +1047,7 @@ class RoomJoinRatelimitTestCase(RoomBase):
# if all of these requests ended up joining the user to a room.
for _ in range(4):
channel = self.make_request("POST", path % room_id, {})
- self.assertEquals(channel.code, 200)
+ self.assertEqual(channel.code, 200)
@unittest.override_config(
{
@@ -1078,40 +1078,40 @@ class RoomMessagesTestCase(RoomBase):
path = "/rooms/%s/send/m.room.message/mid1" % (urlparse.quote(self.room_id))
# missing keys or invalid json
channel = self.make_request("PUT", path, b"{}")
- self.assertEquals(400, channel.code, msg=channel.result["body"])
+ self.assertEqual(400, channel.code, msg=channel.result["body"])
channel = self.make_request("PUT", path, b'{"_name":"bo"}')
- self.assertEquals(400, channel.code, msg=channel.result["body"])
+ self.assertEqual(400, channel.code, msg=channel.result["body"])
channel = self.make_request("PUT", path, b'{"nao')
- self.assertEquals(400, channel.code, msg=channel.result["body"])
+ self.assertEqual(400, channel.code, msg=channel.result["body"])
channel = self.make_request("PUT", path, b'[{"_name":"bo"},{"_name":"jill"}]')
- self.assertEquals(400, channel.code, msg=channel.result["body"])
+ self.assertEqual(400, channel.code, msg=channel.result["body"])
channel = self.make_request("PUT", path, b"text only")
- self.assertEquals(400, channel.code, msg=channel.result["body"])
+ self.assertEqual(400, channel.code, msg=channel.result["body"])
channel = self.make_request("PUT", path, b"")
- self.assertEquals(400, channel.code, msg=channel.result["body"])
+ self.assertEqual(400, channel.code, msg=channel.result["body"])
def test_rooms_messages_sent(self):
path = "/rooms/%s/send/m.room.message/mid1" % (urlparse.quote(self.room_id))
content = b'{"body":"test","msgtype":{"type":"a"}}'
channel = self.make_request("PUT", path, content)
- self.assertEquals(400, channel.code, msg=channel.result["body"])
+ self.assertEqual(400, channel.code, msg=channel.result["body"])
# custom message types
content = b'{"body":"test","msgtype":"test.custom.text"}'
channel = self.make_request("PUT", path, content)
- self.assertEquals(200, channel.code, msg=channel.result["body"])
+ self.assertEqual(200, channel.code, msg=channel.result["body"])
# m.text message type
path = "/rooms/%s/send/m.room.message/mid2" % (urlparse.quote(self.room_id))
content = b'{"body":"test2","msgtype":"m.text"}'
channel = self.make_request("PUT", path, content)
- self.assertEquals(200, channel.code, msg=channel.result["body"])
+ self.assertEqual(200, channel.code, msg=channel.result["body"])
class RoomInitialSyncTestCase(RoomBase):
@@ -1125,10 +1125,10 @@ class RoomInitialSyncTestCase(RoomBase):
def test_initial_sync(self):
channel = self.make_request("GET", "/rooms/%s/initialSync" % self.room_id)
- self.assertEquals(200, channel.code)
+ self.assertEqual(200, channel.code)
- self.assertEquals(self.room_id, channel.json_body["room_id"])
- self.assertEquals("join", channel.json_body["membership"])
+ self.assertEqual(self.room_id, channel.json_body["room_id"])
+ self.assertEqual("join", channel.json_body["membership"])
# Room state is easier to assert on if we unpack it into a dict
state = {}
@@ -1152,7 +1152,7 @@ class RoomInitialSyncTestCase(RoomBase):
e["content"]["user_id"]: e for e in channel.json_body["presence"]
}
self.assertTrue(self.user_id in presence_by_user)
- self.assertEquals("m.presence", presence_by_user[self.user_id]["type"])
+ self.assertEqual("m.presence", presence_by_user[self.user_id]["type"])
class RoomMessageListTestCase(RoomBase):
@@ -1168,9 +1168,9 @@ class RoomMessageListTestCase(RoomBase):
channel = self.make_request(
"GET", "/rooms/%s/messages?access_token=x&from=%s" % (self.room_id, token)
)
- self.assertEquals(200, channel.code)
+ self.assertEqual(200, channel.code)
self.assertTrue("start" in channel.json_body)
- self.assertEquals(token, channel.json_body["start"])
+ self.assertEqual(token, channel.json_body["start"])
self.assertTrue("chunk" in channel.json_body)
self.assertTrue("end" in channel.json_body)
@@ -1179,9 +1179,9 @@ class RoomMessageListTestCase(RoomBase):
channel = self.make_request(
"GET", "/rooms/%s/messages?access_token=x&from=%s" % (self.room_id, token)
)
- self.assertEquals(200, channel.code)
+ self.assertEqual(200, channel.code)
self.assertTrue("start" in channel.json_body)
- self.assertEquals(token, channel.json_body["start"])
+ self.assertEqual(token, channel.json_body["start"])
self.assertTrue("chunk" in channel.json_body)
self.assertTrue("end" in channel.json_body)
@@ -2614,7 +2614,7 @@ class ThreepidInviteTestCase(unittest.HomeserverTestCase):
},
access_token=self.tok,
)
- self.assertEquals(channel.code, 200)
+ self.assertEqual(channel.code, 200)
# Check that the callback was called with the right params.
mock.assert_called_with(self.user_id, "email", email_to_invite, self.room_id)
@@ -2636,7 +2636,7 @@ class ThreepidInviteTestCase(unittest.HomeserverTestCase):
},
access_token=self.tok,
)
- self.assertEquals(channel.code, 403)
+ self.assertEqual(channel.code, 403)
# Also check that it stopped before calling _make_and_store_3pid_invite.
make_invite_mock.assert_called_once()
diff --git a/tests/rest/client/test_shadow_banned.py b/tests/rest/client/test_shadow_banned.py
index 7d0e66b534..2634c98dde 100644
--- a/tests/rest/client/test_shadow_banned.py
+++ b/tests/rest/client/test_shadow_banned.py
@@ -96,7 +96,7 @@ class RoomTestCase(_ShadowBannedBase):
{"id_server": "test", "medium": "email", "address": "test@test.test"},
access_token=self.banned_access_token,
)
- self.assertEquals(200, channel.code, channel.result)
+ self.assertEqual(200, channel.code, channel.result)
# This should have raised an error earlier, but double check this wasn't called.
identity_handler.lookup_3pid.assert_not_called()
@@ -110,7 +110,7 @@ class RoomTestCase(_ShadowBannedBase):
{"visibility": "public", "invite": [self.other_user_id]},
access_token=self.banned_access_token,
)
- self.assertEquals(200, channel.code, channel.result)
+ self.assertEqual(200, channel.code, channel.result)
room_id = channel.json_body["room_id"]
# But the user wasn't actually invited.
@@ -165,7 +165,7 @@ class RoomTestCase(_ShadowBannedBase):
{"new_version": "6"},
access_token=self.banned_access_token,
)
- self.assertEquals(200, channel.code, channel.result)
+ self.assertEqual(200, channel.code, channel.result)
# A new room_id should be returned.
self.assertIn("replacement_room", channel.json_body)
@@ -190,11 +190,11 @@ class RoomTestCase(_ShadowBannedBase):
{"typing": True, "timeout": 30000},
access_token=self.banned_access_token,
)
- self.assertEquals(200, channel.code)
+ self.assertEqual(200, channel.code)
# There should be no typing events.
event_source = self.hs.get_event_sources().sources.typing
- self.assertEquals(event_source.get_current_key(), 0)
+ self.assertEqual(event_source.get_current_key(), 0)
# The other user can join and send typing events.
self.helper.join(room_id, self.other_user_id, tok=self.other_access_token)
@@ -205,10 +205,10 @@ class RoomTestCase(_ShadowBannedBase):
{"typing": True, "timeout": 30000},
access_token=self.other_access_token,
)
- self.assertEquals(200, channel.code)
+ self.assertEqual(200, channel.code)
# These appear in the room.
- self.assertEquals(event_source.get_current_key(), 1)
+ self.assertEqual(event_source.get_current_key(), 1)
events = self.get_success(
event_source.get_new_events(
user=UserID.from_string(self.other_user_id),
@@ -218,7 +218,7 @@ class RoomTestCase(_ShadowBannedBase):
is_guest=False,
)
)
- self.assertEquals(
+ self.assertEqual(
events[0],
[
{
@@ -257,7 +257,7 @@ class ProfileTestCase(_ShadowBannedBase):
{"displayname": new_display_name},
access_token=self.banned_access_token,
)
- self.assertEquals(200, channel.code, channel.result)
+ self.assertEqual(200, channel.code, channel.result)
self.assertEqual(channel.json_body, {})
# The user's display name should be updated.
@@ -299,7 +299,7 @@ class ProfileTestCase(_ShadowBannedBase):
{"membership": "join", "displayname": new_display_name},
access_token=self.banned_access_token,
)
- self.assertEquals(200, channel.code, channel.result)
+ self.assertEqual(200, channel.code, channel.result)
self.assertIn("event_id", channel.json_body)
# The display name in the room should not be changed.
diff --git a/tests/rest/client/test_shared_rooms.py b/tests/rest/client/test_shared_rooms.py
index c42c8aff6c..294f46fb95 100644
--- a/tests/rest/client/test_shared_rooms.py
+++ b/tests/rest/client/test_shared_rooms.py
@@ -91,9 +91,9 @@ class UserSharedRoomsTest(unittest.HomeserverTestCase):
# Check shared rooms from user1's perspective.
# We should see the one room in common
channel = self._get_shared_rooms(u1_token, u2)
- self.assertEquals(200, channel.code, channel.result)
- self.assertEquals(len(channel.json_body["joined"]), 1)
- self.assertEquals(channel.json_body["joined"][0], room_id_one)
+ self.assertEqual(200, channel.code, channel.result)
+ self.assertEqual(len(channel.json_body["joined"]), 1)
+ self.assertEqual(channel.json_body["joined"][0], room_id_one)
# Create another room and invite user2 to it
room_id_two = self.helper.create_room_as(
@@ -104,8 +104,8 @@ class UserSharedRoomsTest(unittest.HomeserverTestCase):
# Check shared rooms again. We should now see both rooms.
channel = self._get_shared_rooms(u1_token, u2)
- self.assertEquals(200, channel.code, channel.result)
- self.assertEquals(len(channel.json_body["joined"]), 2)
+ self.assertEqual(200, channel.code, channel.result)
+ self.assertEqual(len(channel.json_body["joined"]), 2)
for room_id_id in channel.json_body["joined"]:
self.assertIn(room_id_id, [room_id_one, room_id_two])
@@ -125,18 +125,18 @@ class UserSharedRoomsTest(unittest.HomeserverTestCase):
# Assert user directory is not empty
channel = self._get_shared_rooms(u1_token, u2)
- self.assertEquals(200, channel.code, channel.result)
- self.assertEquals(len(channel.json_body["joined"]), 1)
- self.assertEquals(channel.json_body["joined"][0], room)
+ self.assertEqual(200, channel.code, channel.result)
+ self.assertEqual(len(channel.json_body["joined"]), 1)
+ self.assertEqual(channel.json_body["joined"][0], room)
self.helper.leave(room, user=u1, tok=u1_token)
# Check user1's view of shared rooms with user2
channel = self._get_shared_rooms(u1_token, u2)
- self.assertEquals(200, channel.code, channel.result)
- self.assertEquals(len(channel.json_body["joined"]), 0)
+ self.assertEqual(200, channel.code, channel.result)
+ self.assertEqual(len(channel.json_body["joined"]), 0)
# Check user2's view of shared rooms with user1
channel = self._get_shared_rooms(u2_token, u1)
- self.assertEquals(200, channel.code, channel.result)
- self.assertEquals(len(channel.json_body["joined"]), 0)
+ self.assertEqual(200, channel.code, channel.result)
+ self.assertEqual(len(channel.json_body["joined"]), 0)
diff --git a/tests/rest/client/test_sync.py b/tests/rest/client/test_sync.py
index 69b4ef5378..4351013952 100644
--- a/tests/rest/client/test_sync.py
+++ b/tests/rest/client/test_sync.py
@@ -237,10 +237,10 @@ class SyncTypingTests(unittest.HomeserverTestCase):
typing_url % (room, other_user_id, other_access_token),
b'{"typing": true, "timeout": 30000}',
)
- self.assertEquals(200, channel.code)
+ self.assertEqual(200, channel.code)
channel = self.make_request("GET", "/sync?access_token=%s" % (access_token,))
- self.assertEquals(200, channel.code)
+ self.assertEqual(200, channel.code)
next_batch = channel.json_body["next_batch"]
# Stop typing.
@@ -249,7 +249,7 @@ class SyncTypingTests(unittest.HomeserverTestCase):
typing_url % (room, other_user_id, other_access_token),
b'{"typing": false}',
)
- self.assertEquals(200, channel.code)
+ self.assertEqual(200, channel.code)
# Start typing.
channel = self.make_request(
@@ -257,11 +257,11 @@ class SyncTypingTests(unittest.HomeserverTestCase):
typing_url % (room, other_user_id, other_access_token),
b'{"typing": true, "timeout": 30000}',
)
- self.assertEquals(200, channel.code)
+ self.assertEqual(200, channel.code)
# Should return immediately
channel = self.make_request("GET", sync_url % (access_token, next_batch))
- self.assertEquals(200, channel.code)
+ self.assertEqual(200, channel.code)
next_batch = channel.json_body["next_batch"]
# Reset typing serial back to 0, as if the master had.
@@ -273,7 +273,7 @@ class SyncTypingTests(unittest.HomeserverTestCase):
self.helper.send(room, body="There!", tok=other_access_token)
channel = self.make_request("GET", sync_url % (access_token, next_batch))
- self.assertEquals(200, channel.code)
+ self.assertEqual(200, channel.code)
next_batch = channel.json_body["next_batch"]
# This should time out! But it does not, because our stream token is
@@ -281,7 +281,7 @@ class SyncTypingTests(unittest.HomeserverTestCase):
# already seen) is new, since it's got a token above our new, now-reset
# stream token.
channel = self.make_request("GET", sync_url % (access_token, next_batch))
- self.assertEquals(200, channel.code)
+ self.assertEqual(200, channel.code)
next_batch = channel.json_body["next_batch"]
# Clear the typing information, so that it doesn't think everything is
@@ -351,7 +351,7 @@ class SyncKnockTestCase(
b"{}",
self.knocker_tok,
)
- self.assertEquals(200, channel.code, channel.result)
+ self.assertEqual(200, channel.code, channel.result)
# We expect to see the knock event in the stripped room state later
self.expected_room_state[EventTypes.Member] = {
diff --git a/tests/rest/client/test_third_party_rules.py b/tests/rest/client/test_third_party_rules.py
index ac6b86ff6b..9cca9edd30 100644
--- a/tests/rest/client/test_third_party_rules.py
+++ b/tests/rest/client/test_third_party_rules.py
@@ -139,7 +139,7 @@ class ThirdPartyRulesTestCase(unittest.FederatingHomeserverTestCase):
{},
access_token=self.tok,
)
- self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertEqual(channel.result["code"], b"200", channel.result)
callback.assert_called_once()
@@ -157,7 +157,7 @@ class ThirdPartyRulesTestCase(unittest.FederatingHomeserverTestCase):
{},
access_token=self.tok,
)
- self.assertEquals(channel.result["code"], b"403", channel.result)
+ self.assertEqual(channel.result["code"], b"403", channel.result)
def test_third_party_rules_workaround_synapse_errors_pass_through(self):
"""
@@ -193,7 +193,7 @@ class ThirdPartyRulesTestCase(unittest.FederatingHomeserverTestCase):
access_token=self.tok,
)
# Check the error code
- self.assertEquals(channel.result["code"], b"429", channel.result)
+ self.assertEqual(channel.result["code"], b"429", channel.result)
# Check the JSON body has had the `nasty` key injected
self.assertEqual(
channel.json_body,
@@ -329,10 +329,10 @@ class ThirdPartyRulesTestCase(unittest.FederatingHomeserverTestCase):
self.hs.get_module_api().create_and_send_event_into_room(event_dict)
)
- self.assertEquals(event.sender, self.user_id)
- self.assertEquals(event.room_id, self.room_id)
- self.assertEquals(event.type, "m.room.message")
- self.assertEquals(event.content, content)
+ self.assertEqual(event.sender, self.user_id)
+ self.assertEqual(event.room_id, self.room_id)
+ self.assertEqual(event.type, "m.room.message")
+ self.assertEqual(event.content, content)
@unittest.override_config(
{
diff --git a/tests/rest/client/test_typing.py b/tests/rest/client/test_typing.py
index de312cb63c..8b2da88e8a 100644
--- a/tests/rest/client/test_typing.py
+++ b/tests/rest/client/test_typing.py
@@ -72,9 +72,9 @@ class RoomTypingTestCase(unittest.HomeserverTestCase):
"/rooms/%s/typing/%s" % (self.room_id, self.user_id),
b'{"typing": true, "timeout": 30000}',
)
- self.assertEquals(200, channel.code)
+ self.assertEqual(200, channel.code)
- self.assertEquals(self.event_source.get_current_key(), 1)
+ self.assertEqual(self.event_source.get_current_key(), 1)
events = self.get_success(
self.event_source.get_new_events(
user=UserID.from_string(self.user_id),
@@ -84,7 +84,7 @@ class RoomTypingTestCase(unittest.HomeserverTestCase):
is_guest=False,
)
)
- self.assertEquals(
+ self.assertEqual(
events[0],
[
{
@@ -101,7 +101,7 @@ class RoomTypingTestCase(unittest.HomeserverTestCase):
"/rooms/%s/typing/%s" % (self.room_id, self.user_id),
b'{"typing": false}',
)
- self.assertEquals(200, channel.code)
+ self.assertEqual(200, channel.code)
def test_typing_timeout(self):
channel = self.make_request(
@@ -109,19 +109,19 @@ class RoomTypingTestCase(unittest.HomeserverTestCase):
"/rooms/%s/typing/%s" % (self.room_id, self.user_id),
b'{"typing": true, "timeout": 30000}',
)
- self.assertEquals(200, channel.code)
+ self.assertEqual(200, channel.code)
- self.assertEquals(self.event_source.get_current_key(), 1)
+ self.assertEqual(self.event_source.get_current_key(), 1)
self.reactor.advance(36)
- self.assertEquals(self.event_source.get_current_key(), 2)
+ self.assertEqual(self.event_source.get_current_key(), 2)
channel = self.make_request(
"PUT",
"/rooms/%s/typing/%s" % (self.room_id, self.user_id),
b'{"typing": true, "timeout": 30000}',
)
- self.assertEquals(200, channel.code)
+ self.assertEqual(200, channel.code)
- self.assertEquals(self.event_source.get_current_key(), 3)
+ self.assertEqual(self.event_source.get_current_key(), 3)
diff --git a/tests/rest/client/test_upgrade_room.py b/tests/rest/client/test_upgrade_room.py
index 7f79336abc..658c21b2a1 100644
--- a/tests/rest/client/test_upgrade_room.py
+++ b/tests/rest/client/test_upgrade_room.py
@@ -65,7 +65,7 @@ class UpgradeRoomTest(unittest.HomeserverTestCase):
Upgrading a room should work fine.
"""
channel = self._upgrade_room()
- self.assertEquals(200, channel.code, channel.result)
+ self.assertEqual(200, channel.code, channel.result)
self.assertIn("replacement_room", channel.json_body)
def test_not_in_room(self):
@@ -77,7 +77,7 @@ class UpgradeRoomTest(unittest.HomeserverTestCase):
roomless_token = self.login(roomless, "pass")
channel = self._upgrade_room(roomless_token)
- self.assertEquals(403, channel.code, channel.result)
+ self.assertEqual(403, channel.code, channel.result)
def test_power_levels(self):
"""
@@ -85,7 +85,7 @@ class UpgradeRoomTest(unittest.HomeserverTestCase):
"""
# The other user doesn't have the proper power level.
channel = self._upgrade_room(self.other_token)
- self.assertEquals(403, channel.code, channel.result)
+ self.assertEqual(403, channel.code, channel.result)
# Increase the power levels so that this user can upgrade.
power_levels = self.helper.get_state(
@@ -103,7 +103,7 @@ class UpgradeRoomTest(unittest.HomeserverTestCase):
# The upgrade should succeed!
channel = self._upgrade_room(self.other_token)
- self.assertEquals(200, channel.code, channel.result)
+ self.assertEqual(200, channel.code, channel.result)
def test_power_levels_user_default(self):
"""
@@ -111,7 +111,7 @@ class UpgradeRoomTest(unittest.HomeserverTestCase):
"""
# The other user doesn't have the proper power level.
channel = self._upgrade_room(self.other_token)
- self.assertEquals(403, channel.code, channel.result)
+ self.assertEqual(403, channel.code, channel.result)
# Increase the power levels so that this user can upgrade.
power_levels = self.helper.get_state(
@@ -129,7 +129,7 @@ class UpgradeRoomTest(unittest.HomeserverTestCase):
# The upgrade should succeed!
channel = self._upgrade_room(self.other_token)
- self.assertEquals(200, channel.code, channel.result)
+ self.assertEqual(200, channel.code, channel.result)
def test_power_levels_tombstone(self):
"""
@@ -137,7 +137,7 @@ class UpgradeRoomTest(unittest.HomeserverTestCase):
"""
# The other user doesn't have the proper power level.
channel = self._upgrade_room(self.other_token)
- self.assertEquals(403, channel.code, channel.result)
+ self.assertEqual(403, channel.code, channel.result)
# Increase the power levels so that this user can upgrade.
power_levels = self.helper.get_state(
@@ -155,7 +155,7 @@ class UpgradeRoomTest(unittest.HomeserverTestCase):
# The upgrade should succeed!
channel = self._upgrade_room(self.other_token)
- self.assertEquals(200, channel.code, channel.result)
+ self.assertEqual(200, channel.code, channel.result)
power_levels = self.helper.get_state(
self.room_id,
@@ -197,7 +197,7 @@ class UpgradeRoomTest(unittest.HomeserverTestCase):
# Upgrade the room!
channel = self._upgrade_room(room_id=space_id)
- self.assertEquals(200, channel.code, channel.result)
+ self.assertEqual(200, channel.code, channel.result)
self.assertIn("replacement_room", channel.json_body)
new_space_id = channel.json_body["replacement_room"]
diff --git a/tests/rest/media/v1/test_media_storage.py b/tests/rest/media/v1/test_media_storage.py
index 6878ccddbf..cba9be17c4 100644
--- a/tests/rest/media/v1/test_media_storage.py
+++ b/tests/rest/media/v1/test_media_storage.py
@@ -94,7 +94,7 @@ class MediaStorageTests(unittest.HomeserverTestCase):
self.assertTrue(os.path.exists(local_path))
# Asserts the file is under the expected local cache directory
- self.assertEquals(
+ self.assertEqual(
os.path.commonprefix([self.primary_base_path, local_path]),
self.primary_base_path,
)
|
