Matrix-Mirrors/anonymousland-synapse
1
0
Fork 0
mirror of https://git.anonymousland.org/anonymousland/synapse.git synced 2025-09-19 19:04:39 -04:00
Code Issues Projects Releases Packages Wiki Activity

Update black, and run auto formatting over the codebase (#9381)

Browse source 
- Update black version to the latest
 - Run black auto formatting over the codebase
    - Run autoformatting according to [`docs/code_style.md
`](80d6dc9783/docs/code_style.md)
 - Update `code_style.md` docs around installing black to use the correct version
This commit is contained in:
Eric Eastwood 2021-02-16 16:32:34 -06:00 • committed by GitHub
parent 5636e597c3
commit 0a00b7ff14
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
271 changed files with 2802 additions and 1713 deletions
Download patch file Download diff file Expand all files Collapse all files

34
tests/rest/admin/test_admin.py
View file

@ -130,8 +130,7 @@ class DeleteGroupTestCase(unittest.HomeserverTestCase):
)
def _get_groups_user_is_in(self, access_token):
"""Returns the list of groups the user is in (given their access token)
"""
"""Returns the list of groups the user is in (given their access token)"""
channel = self.make_request(
"GET", "/joined_groups".encode("ascii"), access_token=access_token
)
@ -142,8 +141,7 @@ class DeleteGroupTestCase(unittest.HomeserverTestCase):
class QuarantineMediaTestCase(unittest.HomeserverTestCase):
"""Test /quarantine_media admin API.
"""
"""Test /quarantine_media admin API."""
servlets = [
synapse.rest.admin.register_servlets,
@ -237,7 +235,9 @@ class QuarantineMediaTestCase(unittest.HomeserverTestCase):
# Attempt quarantine media APIs as non-admin
url = "/_synapse/admin/v1/media/quarantine/example.org/abcde12345"
channel = self.make_request(
"POST", url.encode("ascii"), access_token=non_admin_user_tok,
"POST",
url.encode("ascii"),
access_token=non_admin_user_tok,
)
# Expect a forbidden error
@ -250,7 +250,9 @@ class QuarantineMediaTestCase(unittest.HomeserverTestCase):
# And the roomID/userID endpoint
url = "/_synapse/admin/v1/room/!room%3Aexample.com/media/quarantine"
channel = self.make_request(
"POST", url.encode("ascii"), access_token=non_admin_user_tok,
"POST",
url.encode("ascii"),
access_token=non_admin_user_tok,
)
# Expect a forbidden error
@ -294,7 +296,11 @@ class QuarantineMediaTestCase(unittest.HomeserverTestCase):
urllib.parse.quote(server_name),
urllib.parse.quote(media_id),
)
channel = self.make_request("POST", url, access_token=admin_user_tok,)
channel = self.make_request(
"POST",
url,
access_token=admin_user_tok,
)
self.pump(1.0)
self.assertEqual(200, int(channel.code), msg=channel.result["body"])
@ -346,7 +352,11 @@ class QuarantineMediaTestCase(unittest.HomeserverTestCase):
url = "/_synapse/admin/v1/room/%s/media/quarantine" % urllib.parse.quote(
room_id
)
channel = self.make_request("POST", url, access_token=admin_user_tok,)
channel = self.make_request(
"POST",
url,
access_token=admin_user_tok,
)
self.pump(1.0)
self.assertEqual(200, int(channel.code), msg=channel.result["body"])
self.assertEqual(
@ -391,7 +401,9 @@ class QuarantineMediaTestCase(unittest.HomeserverTestCase):
non_admin_user
)
channel = self.make_request(
"POST", url.encode("ascii"), access_token=admin_user_tok,
"POST",
url.encode("ascii"),
access_token=admin_user_tok,
)
self.pump(1.0)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -437,7 +449,9 @@ class QuarantineMediaTestCase(unittest.HomeserverTestCase):
non_admin_user
)
channel = self.make_request(
"POST", url.encode("ascii"), access_token=admin_user_tok,
"POST",
url.encode("ascii"),
access_token=admin_user_tok,
)
self.pump(1.0)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])

148
tests/rest/admin/test_device.py
View file

@ -70,21 +70,27 @@ class DeviceRestTestCase(unittest.HomeserverTestCase):
If the user is not a server admin, an error is returned.
"""
channel = self.make_request(
"GET", self.url, access_token=self.other_user_token,
"GET",
self.url,
access_token=self.other_user_token,
)
self.assertEqual(403, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(Codes.FORBIDDEN, channel.json_body["errcode"])
channel = self.make_request(
"PUT", self.url, access_token=self.other_user_token,
"PUT",
self.url,
access_token=self.other_user_token,
)
self.assertEqual(403, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(Codes.FORBIDDEN, channel.json_body["errcode"])
channel = self.make_request(
"DELETE", self.url, access_token=self.other_user_token,
"DELETE",
self.url,
access_token=self.other_user_token,
)
self.assertEqual(403, int(channel.result["code"]), msg=channel.result["body"])
@ -99,17 +105,29 @@ class DeviceRestTestCase(unittest.HomeserverTestCase):
% self.other_user_device_id
)
channel = self.make_request("GET", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(404, channel.code, msg=channel.json_body)
self.assertEqual(Codes.NOT_FOUND, channel.json_body["errcode"])
channel = self.make_request("PUT", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"PUT",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(404, channel.code, msg=channel.json_body)
self.assertEqual(Codes.NOT_FOUND, channel.json_body["errcode"])
channel = self.make_request("DELETE", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"DELETE",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(404, channel.code, msg=channel.json_body)
self.assertEqual(Codes.NOT_FOUND, channel.json_body["errcode"])
@ -123,17 +141,29 @@ class DeviceRestTestCase(unittest.HomeserverTestCase):
% self.other_user_device_id
)
channel = self.make_request("GET", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(400, channel.code, msg=channel.json_body)
self.assertEqual("Can only lookup local users", channel.json_body["error"])
channel = self.make_request("PUT", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"PUT",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(400, channel.code, msg=channel.json_body)
self.assertEqual("Can only lookup local users", channel.json_body["error"])
channel = self.make_request("DELETE", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"DELETE",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(400, channel.code, msg=channel.json_body)
self.assertEqual("Can only lookup local users", channel.json_body["error"])
@ -146,16 +176,28 @@ class DeviceRestTestCase(unittest.HomeserverTestCase):
self.other_user
)
channel = self.make_request("GET", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(404, channel.code, msg=channel.json_body)
self.assertEqual(Codes.NOT_FOUND, channel.json_body["errcode"])
channel = self.make_request("PUT", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"PUT",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
channel = self.make_request("DELETE", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"DELETE",
url,
access_token=self.admin_user_tok,
)
# Delete unknown device returns status 200
self.assertEqual(200, channel.code, msg=channel.json_body)
@ -190,7 +232,11 @@ class DeviceRestTestCase(unittest.HomeserverTestCase):
self.assertEqual(Codes.TOO_LARGE, channel.json_body["errcode"])
# Ensure the display name was not updated.
channel = self.make_request("GET", self.url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
self.url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual("new display", channel.json_body["display_name"])
@ -207,12 +253,20 @@ class DeviceRestTestCase(unittest.HomeserverTestCase):
)
)
channel = self.make_request("PUT", self.url, access_token=self.admin_user_tok,)
channel = self.make_request(
"PUT",
self.url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
# Ensure the display name was not updated.
channel = self.make_request("GET", self.url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
self.url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual("new display", channel.json_body["display_name"])
@ -233,7 +287,11 @@ class DeviceRestTestCase(unittest.HomeserverTestCase):
self.assertEqual(200, channel.code, msg=channel.json_body)
# Check new display_name
channel = self.make_request("GET", self.url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
self.url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual("new displayname", channel.json_body["display_name"])
@ -242,7 +300,11 @@ class DeviceRestTestCase(unittest.HomeserverTestCase):
"""
Tests that a normal lookup for a device is successfully
"""
channel = self.make_request("GET", self.url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
self.url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(self.other_user, channel.json_body["user_id"])
@ -264,7 +326,9 @@ class DeviceRestTestCase(unittest.HomeserverTestCase):
# Delete device
channel = self.make_request(
"DELETE", self.url, access_token=self.admin_user_tok,
"DELETE",
self.url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
@ -306,7 +370,11 @@ class DevicesRestTestCase(unittest.HomeserverTestCase):
"""
other_user_token = self.login("user", "pass")
channel = self.make_request("GET", self.url, access_token=other_user_token,)
channel = self.make_request(
"GET",
self.url,
access_token=other_user_token,
)
self.assertEqual(403, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(Codes.FORBIDDEN, channel.json_body["errcode"])
@ -316,7 +384,11 @@ class DevicesRestTestCase(unittest.HomeserverTestCase):
Tests that a lookup for a user that does not exist returns a 404
"""
url = "/_synapse/admin/v2/users/@unknown_person:test/devices"
channel = self.make_request("GET", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(404, channel.code, msg=channel.json_body)
self.assertEqual(Codes.NOT_FOUND, channel.json_body["errcode"])
@ -327,7 +399,11 @@ class DevicesRestTestCase(unittest.HomeserverTestCase):
"""
url = "/_synapse/admin/v2/users/@unknown_person:unknown_domain/devices"
channel = self.make_request("GET", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(400, channel.code, msg=channel.json_body)
self.assertEqual("Can only lookup local users", channel.json_body["error"])
@ -339,7 +415,11 @@ class DevicesRestTestCase(unittest.HomeserverTestCase):
"""
# Get devices
channel = self.make_request("GET", self.url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
self.url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(0, channel.json_body["total"])
@ -355,7 +435,11 @@ class DevicesRestTestCase(unittest.HomeserverTestCase):
self.login("user", "pass")
# Get devices
channel = self.make_request("GET", self.url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
self.url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(number_devices, channel.json_body["total"])
@ -404,7 +488,11 @@ class DeleteDevicesRestTestCase(unittest.HomeserverTestCase):
"""
other_user_token = self.login("user", "pass")
channel = self.make_request("POST", self.url, access_token=other_user_token,)
channel = self.make_request(
"POST",
self.url,
access_token=other_user_token,
)
self.assertEqual(403, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(Codes.FORBIDDEN, channel.json_body["errcode"])
@ -414,7 +502,11 @@ class DeleteDevicesRestTestCase(unittest.HomeserverTestCase):
Tests that a lookup for a user that does not exist returns a 404
"""
url = "/_synapse/admin/v2/users/@unknown_person:test/delete_devices"
channel = self.make_request("POST", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"POST",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(404, channel.code, msg=channel.json_body)
self.assertEqual(Codes.NOT_FOUND, channel.json_body["errcode"])
@ -425,7 +517,11 @@ class DeleteDevicesRestTestCase(unittest.HomeserverTestCase):
"""
url = "/_synapse/admin/v2/users/@unknown_person:unknown_domain/delete_devices"
channel = self.make_request("POST", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"POST",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(400, channel.code, msg=channel.json_body)
self.assertEqual("Can only lookup local users", channel.json_body["error"])

99
tests/rest/admin/test_event_reports.py
View file

@ -51,19 +51,23 @@ class EventReportsTestCase(unittest.HomeserverTestCase):
# Two rooms and two users. Every user sends and reports every room event
for i in range(5):
self._create_event_and_report(
room_id=self.room_id1, user_tok=self.other_user_tok,
room_id=self.room_id1,
user_tok=self.other_user_tok,
)
for i in range(5):
self._create_event_and_report(
room_id=self.room_id2, user_tok=self.other_user_tok,
room_id=self.room_id2,
user_tok=self.other_user_tok,
)
for i in range(5):
self._create_event_and_report(
room_id=self.room_id1, user_tok=self.admin_user_tok,
room_id=self.room_id1,
user_tok=self.admin_user_tok,
)
for i in range(5):
self._create_event_and_report(
room_id=self.room_id2, user_tok=self.admin_user_tok,
room_id=self.room_id2,
user_tok=self.admin_user_tok,
)
self.url = "/_synapse/admin/v1/event_reports"
@ -82,7 +86,11 @@ class EventReportsTestCase(unittest.HomeserverTestCase):
If the user is not a server admin, an error 403 is returned.
"""
channel = self.make_request("GET", self.url, access_token=self.other_user_tok,)
channel = self.make_request(
"GET",
self.url,
access_token=self.other_user_tok,
)
self.assertEqual(403, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(Codes.FORBIDDEN, channel.json_body["errcode"])
@ -92,7 +100,11 @@ class EventReportsTestCase(unittest.HomeserverTestCase):
Testing list of reported events
"""
channel = self.make_request("GET", self.url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
self.url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(channel.json_body["total"], 20)
@ -106,7 +118,9 @@ class EventReportsTestCase(unittest.HomeserverTestCase):
"""
channel = self.make_request(
"GET", self.url + "?limit=5", access_token=self.admin_user_tok,
"GET",
self.url + "?limit=5",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -121,7 +135,9 @@ class EventReportsTestCase(unittest.HomeserverTestCase):
"""
channel = self.make_request(
"GET", self.url + "?from=5", access_token=self.admin_user_tok,
"GET",
self.url + "?from=5",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -136,7 +152,9 @@ class EventReportsTestCase(unittest.HomeserverTestCase):
"""
channel = self.make_request(
"GET", self.url + "?from=5&limit=10", access_token=self.admin_user_tok,
"GET",
self.url + "?from=5&limit=10",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -213,7 +231,9 @@ class EventReportsTestCase(unittest.HomeserverTestCase):
# fetch the most recent first, largest timestamp
channel = self.make_request(
"GET", self.url + "?dir=b", access_token=self.admin_user_tok,
"GET",
self.url + "?dir=b",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -229,7 +249,9 @@ class EventReportsTestCase(unittest.HomeserverTestCase):
# fetch the oldest first, smallest timestamp
channel = self.make_request(
"GET", self.url + "?dir=f", access_token=self.admin_user_tok,
"GET",
self.url + "?dir=f",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -249,7 +271,9 @@ class EventReportsTestCase(unittest.HomeserverTestCase):
"""
channel = self.make_request(
"GET", self.url + "?dir=bar", access_token=self.admin_user_tok,
"GET",
self.url + "?dir=bar",
access_token=self.admin_user_tok,
)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
@ -262,7 +286,9 @@ class EventReportsTestCase(unittest.HomeserverTestCase):
"""
channel = self.make_request(
"GET", self.url + "?limit=-5", access_token=self.admin_user_tok,
"GET",
self.url + "?limit=-5",
access_token=self.admin_user_tok,
)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
@ -274,7 +300,9 @@ class EventReportsTestCase(unittest.HomeserverTestCase):
"""
channel = self.make_request(
"GET", self.url + "?from=-5", access_token=self.admin_user_tok,
"GET",
self.url + "?from=-5",
access_token=self.admin_user_tok,
)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
@ -288,7 +316,9 @@ class EventReportsTestCase(unittest.HomeserverTestCase):
# `next_token` does not appear
# Number of results is the number of entries
channel = self.make_request(
"GET", self.url + "?limit=20", access_token=self.admin_user_tok,
"GET",
self.url + "?limit=20",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -299,7 +329,9 @@ class EventReportsTestCase(unittest.HomeserverTestCase):
# `next_token` does not appear
# Number of max results is larger than the number of entries
channel = self.make_request(
"GET", self.url + "?limit=21", access_token=self.admin_user_tok,
"GET",
self.url + "?limit=21",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -310,7 +342,9 @@ class EventReportsTestCase(unittest.HomeserverTestCase):
# `next_token` does appear
# Number of max results is smaller than the number of entries
channel = self.make_request(
"GET", self.url + "?limit=19", access_token=self.admin_user_tok,
"GET",
self.url + "?limit=19",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -322,7 +356,9 @@ class EventReportsTestCase(unittest.HomeserverTestCase):
# Set `from` to value of `next_token` for request remaining entries
# `next_token` does not appear
channel = self.make_request(
"GET", self.url + "?from=19", access_token=self.admin_user_tok,
"GET",
self.url + "?from=19",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -331,8 +367,7 @@ class EventReportsTestCase(unittest.HomeserverTestCase):
self.assertNotIn("next_token", channel.json_body)
def _create_event_and_report(self, room_id, user_tok):
"""Create and report events
"""
"""Create and report events"""
resp = self.helper.send(room_id, tok=user_tok)
event_id = resp["event_id"]
@ -345,8 +380,7 @@ class EventReportsTestCase(unittest.HomeserverTestCase):
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
def _check_fields(self, content):
"""Checks that all attributes are present in an event report
"""
"""Checks that all attributes are present in an event report"""
for c in content:
self.assertIn("id", c)
self.assertIn("received_ts", c)
@ -381,7 +415,8 @@ class EventReportDetailTestCase(unittest.HomeserverTestCase):
self.helper.join(self.room_id1, user=self.admin_user, tok=self.admin_user_tok)
self._create_event_and_report(
room_id=self.room_id1, user_tok=self.other_user_tok,
room_id=self.room_id1,
user_tok=self.other_user_tok,
)
# first created event report gets `id`=2
@ -401,7 +436,11 @@ class EventReportDetailTestCase(unittest.HomeserverTestCase):
If the user is not a server admin, an error 403 is returned.
"""
channel = self.make_request("GET", self.url, access_token=self.other_user_tok,)
channel = self.make_request(
"GET",
self.url,
access_token=self.other_user_tok,
)
self.assertEqual(403, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(Codes.FORBIDDEN, channel.json_body["errcode"])
@ -411,7 +450,11 @@ class EventReportDetailTestCase(unittest.HomeserverTestCase):
Testing get a reported event
"""
channel = self.make_request("GET", self.url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
self.url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
self._check_fields(channel.json_body)
@ -479,8 +522,7 @@ class EventReportDetailTestCase(unittest.HomeserverTestCase):
self.assertEqual("Event report not found", channel.json_body["error"])
def _create_event_and_report(self, room_id, user_tok):
"""Create and report events
"""
"""Create and report events"""
resp = self.helper.send(room_id, tok=user_tok)
event_id = resp["event_id"]
@ -493,8 +535,7 @@ class EventReportDetailTestCase(unittest.HomeserverTestCase):
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
def _check_fields(self, content):
"""Checks that all attributes are present in a event report
"""
"""Checks that all attributes are present in a event report"""
self.assertIn("id", content)
self.assertIn("received_ts", content)
self.assertIn("room_id", content)

60
tests/rest/admin/test_media.py
View file

@ -63,7 +63,11 @@ class DeleteMediaByIDTestCase(unittest.HomeserverTestCase):
url = "/_synapse/admin/v1/media/%s/%s" % (self.server_name, "12345")
channel = self.make_request("DELETE", url, access_token=self.other_user_token,)
channel = self.make_request(
"DELETE",
url,
access_token=self.other_user_token,
)
self.assertEqual(403, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(Codes.FORBIDDEN, channel.json_body["errcode"])
@ -74,7 +78,11 @@ class DeleteMediaByIDTestCase(unittest.HomeserverTestCase):
"""
url = "/_synapse/admin/v1/media/%s/%s" % (self.server_name, "12345")
channel = self.make_request("DELETE", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"DELETE",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(404, channel.code, msg=channel.json_body)
self.assertEqual(Codes.NOT_FOUND, channel.json_body["errcode"])
@ -85,7 +93,11 @@ class DeleteMediaByIDTestCase(unittest.HomeserverTestCase):
"""
url = "/_synapse/admin/v1/media/%s/%s" % ("unknown_domain", "12345")
channel = self.make_request("DELETE", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"DELETE",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(400, channel.code, msg=channel.json_body)
self.assertEqual("Can only delete local media", channel.json_body["error"])
@ -139,12 +151,17 @@ class DeleteMediaByIDTestCase(unittest.HomeserverTestCase):
url = "/_synapse/admin/v1/media/%s/%s" % (self.server_name, media_id)
# Delete media
channel = self.make_request("DELETE", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"DELETE",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(1, channel.json_body["total"])
self.assertEqual(
media_id, channel.json_body["deleted_media"][0],
media_id,
channel.json_body["deleted_media"][0],
)
# Attempt to access media
@ -207,7 +224,9 @@ class DeleteMediaByDateSizeTestCase(unittest.HomeserverTestCase):
self.other_user_token = self.login("user", "pass")
channel = self.make_request(
"POST", self.url, access_token=self.other_user_token,
"POST",
self.url,
access_token=self.other_user_token,
)
self.assertEqual(403, int(channel.result["code"]), msg=channel.result["body"])
@ -220,7 +239,9 @@ class DeleteMediaByDateSizeTestCase(unittest.HomeserverTestCase):
url = "/_synapse/admin/v1/media/%s/delete" % "unknown_domain"
channel = self.make_request(
"POST", url + "?before_ts=1234", access_token=self.admin_user_tok,
"POST",
url + "?before_ts=1234",
access_token=self.admin_user_tok,
)
self.assertEqual(400, channel.code, msg=channel.json_body)
@ -230,7 +251,11 @@ class DeleteMediaByDateSizeTestCase(unittest.HomeserverTestCase):
"""
If the parameter `before_ts` is missing, an error is returned.
"""
channel = self.make_request("POST", self.url, access_token=self.admin_user_tok,)
channel = self.make_request(
"POST",
self.url,
access_token=self.admin_user_tok,
)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(Codes.MISSING_PARAM, channel.json_body["errcode"])
@ -243,7 +268,9 @@ class DeleteMediaByDateSizeTestCase(unittest.HomeserverTestCase):
If parameters are invalid, an error is returned.
"""
channel = self.make_request(
"POST", self.url + "?before_ts=-1234", access_token=self.admin_user_tok,
"POST",
self.url + "?before_ts=-1234",
access_token=self.admin_user_tok,
)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
@ -304,7 +331,8 @@ class DeleteMediaByDateSizeTestCase(unittest.HomeserverTestCase):
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(1, channel.json_body["total"])
self.assertEqual(
media_id, channel.json_body["deleted_media"][0],
media_id,
channel.json_body["deleted_media"][0],
)
self._access_media(server_and_media_id, False)
@ -340,7 +368,8 @@ class DeleteMediaByDateSizeTestCase(unittest.HomeserverTestCase):
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(1, channel.json_body["total"])
self.assertEqual(
server_and_media_id.split("/")[1], channel.json_body["deleted_media"][0],
server_and_media_id.split("/")[1],
channel.json_body["deleted_media"][0],
)
self._access_media(server_and_media_id, False)
@ -374,7 +403,8 @@ class DeleteMediaByDateSizeTestCase(unittest.HomeserverTestCase):
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(1, channel.json_body["total"])
self.assertEqual(
server_and_media_id.split("/")[1], channel.json_body["deleted_media"][0],
server_and_media_id.split("/")[1],
channel.json_body["deleted_media"][0],
)
self._access_media(server_and_media_id, False)
@ -417,7 +447,8 @@ class DeleteMediaByDateSizeTestCase(unittest.HomeserverTestCase):
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(1, channel.json_body["total"])
self.assertEqual(
server_and_media_id.split("/")[1], channel.json_body["deleted_media"][0],
server_and_media_id.split("/")[1],
channel.json_body["deleted_media"][0],
)
self._access_media(server_and_media_id, False)
@ -461,7 +492,8 @@ class DeleteMediaByDateSizeTestCase(unittest.HomeserverTestCase):
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(1, channel.json_body["total"])
self.assertEqual(
server_and_media_id.split("/")[1], channel.json_body["deleted_media"][0],
server_and_media_id.split("/")[1],
channel.json_body["deleted_media"][0],
)
self._access_media(server_and_media_id, False)

178
tests/rest/admin/test_room.py
View file

@ -127,8 +127,7 @@ class ShutdownRoomTestCase(unittest.HomeserverTestCase):
self._assert_peek(room_id, expect_code=403)
def _assert_peek(self, room_id, expect_code):
"""Assert that the admin user can (or cannot) peek into the room.
"""
"""Assert that the admin user can (or cannot) peek into the room."""
url = "rooms/%s/initialSync" % (room_id,)
channel = self.make_request(
@ -186,7 +185,10 @@ class DeleteRoomTestCase(unittest.HomeserverTestCase):
"""
channel = self.make_request(
"POST", self.url, json.dumps({}), access_token=self.other_user_tok,
"POST",
self.url,
json.dumps({}),
access_token=self.other_user_tok,
)
self.assertEqual(403, int(channel.result["code"]), msg=channel.result["body"])
@ -199,7 +201,10 @@ class DeleteRoomTestCase(unittest.HomeserverTestCase):
url = "/_synapse/admin/v1/rooms/!unknown:test/delete"
channel = self.make_request(
"POST", url, json.dumps({}), access_token=self.admin_user_tok,
"POST",
url,
json.dumps({}),
access_token=self.admin_user_tok,
)
self.assertEqual(404, int(channel.result["code"]), msg=channel.result["body"])
@ -212,12 +217,16 @@ class DeleteRoomTestCase(unittest.HomeserverTestCase):
url = "/_synapse/admin/v1/rooms/invalidroom/delete"
channel = self.make_request(
"POST", url, json.dumps({}), access_token=self.admin_user_tok,
"POST",
url,
json.dumps({}),
access_token=self.admin_user_tok,
)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(
"invalidroom is not a legal room ID", channel.json_body["error"],
"invalidroom is not a legal room ID",
channel.json_body["error"],
)
def test_new_room_user_does_not_exist(self):
@ -254,7 +263,8 @@ class DeleteRoomTestCase(unittest.HomeserverTestCase):
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(
"User must be our own: @not:exist.bla", channel.json_body["error"],
"User must be our own: @not:exist.bla",
channel.json_body["error"],
)
def test_block_is_not_bool(self):
@ -491,8 +501,7 @@ class DeleteRoomTestCase(unittest.HomeserverTestCase):
self._assert_peek(self.room_id, expect_code=403)
def _is_blocked(self, room_id, expect=True):
"""Assert that the room is blocked or not
"""
"""Assert that the room is blocked or not"""
d = self.store.is_room_blocked(room_id)
if expect:
self.assertTrue(self.get_success(d))
@ -500,20 +509,17 @@ class DeleteRoomTestCase(unittest.HomeserverTestCase):
self.assertIsNone(self.get_success(d))
def _has_no_members(self, room_id):
"""Assert there is now no longer anyone in the room
"""
"""Assert there is now no longer anyone in the room"""
users_in_room = self.get_success(self.store.get_users_in_room(room_id))
self.assertEqual([], users_in_room)
def _is_member(self, room_id, user_id):
"""Test that user is member of the room
"""
"""Test that user is member of the room"""
users_in_room = self.get_success(self.store.get_users_in_room(room_id))
self.assertIn(user_id, users_in_room)
def _is_purged(self, room_id):
"""Test that the following tables have been purged of all rows related to the room.
"""
"""Test that the following tables have been purged of all rows related to the room."""
for table in PURGE_TABLES:
count = self.get_success(
self.store.db_pool.simple_select_one_onecol(
@ -527,8 +533,7 @@ class DeleteRoomTestCase(unittest.HomeserverTestCase):
self.assertEqual(count, 0, msg="Rows not purged in {}".format(table))
def _assert_peek(self, room_id, expect_code):
"""Assert that the admin user can (or cannot) peek into the room.
"""
"""Assert that the admin user can (or cannot) peek into the room."""
url = "rooms/%s/initialSync" % (room_id,)
channel = self.make_request(
@ -548,8 +553,7 @@ class DeleteRoomTestCase(unittest.HomeserverTestCase):
class PurgeRoomTestCase(unittest.HomeserverTestCase):
"""Test /purge_room admin API.
"""
"""Test /purge_room admin API."""
servlets = [
synapse.rest.admin.register_servlets,
@ -594,8 +598,7 @@ class PurgeRoomTestCase(unittest.HomeserverTestCase):
class RoomTestCase(unittest.HomeserverTestCase):
"""Test /room admin API.
"""
"""Test /room admin API."""
servlets = [
synapse.rest.admin.register_servlets,
@ -623,7 +626,9 @@ class RoomTestCase(unittest.HomeserverTestCase):
# Request the list of rooms
url = "/_synapse/admin/v1/rooms"
channel = self.make_request(
"GET", url.encode("ascii"), access_token=self.admin_user_tok,
"GET",
url.encode("ascii"),
access_token=self.admin_user_tok,
)
# Check request completed successfully
@ -685,7 +690,10 @@ class RoomTestCase(unittest.HomeserverTestCase):
# Set the name of the rooms so we get a consistent returned ordering
for idx, room_id in enumerate(room_ids):
self.helper.send_state(
room_id, "m.room.name", {"name": str(idx)}, tok=self.admin_user_tok,
room_id,
"m.room.name",
{"name": str(idx)},
tok=self.admin_user_tok,
)
# Request the list of rooms
@ -704,7 +712,9 @@ class RoomTestCase(unittest.HomeserverTestCase):
"name",
)
channel = self.make_request(
"GET", url.encode("ascii"), access_token=self.admin_user_tok,
"GET",
url.encode("ascii"),
access_token=self.admin_user_tok,
)
self.assertEqual(
200, int(channel.result["code"]), msg=channel.result["body"]
@ -744,7 +754,9 @@ class RoomTestCase(unittest.HomeserverTestCase):
url = "/_synapse/admin/v1/rooms?from=%d&limit=%d" % (start, limit)
channel = self.make_request(
"GET", url.encode("ascii"), access_token=self.admin_user_tok,
"GET",
url.encode("ascii"),
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -788,13 +800,18 @@ class RoomTestCase(unittest.HomeserverTestCase):
# Set a name for the room
self.helper.send_state(
room_id, "m.room.name", {"name": test_room_name}, tok=self.admin_user_tok,
room_id,
"m.room.name",
{"name": test_room_name},
tok=self.admin_user_tok,
)
# Request the list of rooms
url = "/_synapse/admin/v1/rooms"
channel = self.make_request(
"GET", url.encode("ascii"), access_token=self.admin_user_tok,
"GET",
url.encode("ascii"),
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -860,7 +877,9 @@ class RoomTestCase(unittest.HomeserverTestCase):
)
def _order_test(
order_type: str, expected_room_list: List[str], reverse: bool = False,
order_type: str,
expected_room_list: List[str],
reverse: bool = False,
):
"""Request the list of rooms in a certain order. Assert that order is what
we expect
@ -875,7 +894,9 @@ class RoomTestCase(unittest.HomeserverTestCase):
if reverse:
url += "&dir=b"
channel = self.make_request(
"GET", url.encode("ascii"), access_token=self.admin_user_tok,
"GET",
url.encode("ascii"),
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
@ -907,13 +928,22 @@ class RoomTestCase(unittest.HomeserverTestCase):
# Set room names in alphabetical order. room 1 -> A, 2 -> B, 3 -> C
self.helper.send_state(
room_id_1, "m.room.name", {"name": "A"}, tok=self.admin_user_tok,
room_id_1,
"m.room.name",
{"name": "A"},
tok=self.admin_user_tok,
)
self.helper.send_state(
room_id_2, "m.room.name", {"name": "B"}, tok=self.admin_user_tok,
room_id_2,
"m.room.name",
{"name": "B"},
tok=self.admin_user_tok,
)
self.helper.send_state(
room_id_3, "m.room.name", {"name": "C"}, tok=self.admin_user_tok,
room_id_3,
"m.room.name",
{"name": "C"},
tok=self.admin_user_tok,
)
# Set room canonical room aliases
@ -990,10 +1020,16 @@ class RoomTestCase(unittest.HomeserverTestCase):
# Set the name for each room
self.helper.send_state(
room_id_1, "m.room.name", {"name": room_name_1}, tok=self.admin_user_tok,
room_id_1,
"m.room.name",
{"name": room_name_1},
tok=self.admin_user_tok,
)
self.helper.send_state(
room_id_2, "m.room.name", {"name": room_name_2}, tok=self.admin_user_tok,
room_id_2,
"m.room.name",
{"name": room_name_2},
tok=self.admin_user_tok,
)
def _search_test(
@ -1011,7 +1047,9 @@ class RoomTestCase(unittest.HomeserverTestCase):
"""
url = "/_synapse/admin/v1/rooms?search_term=%s" % (search_term,)
channel = self.make_request(
"GET", url.encode("ascii"), access_token=self.admin_user_tok,
"GET",
url.encode("ascii"),
access_token=self.admin_user_tok,
)
self.assertEqual(expected_http_code, channel.code, msg=channel.json_body)
@ -1071,15 +1109,23 @@ class RoomTestCase(unittest.HomeserverTestCase):
# Set the name for each room
self.helper.send_state(
room_id_1, "m.room.name", {"name": room_name_1}, tok=self.admin_user_tok,
room_id_1,
"m.room.name",
{"name": room_name_1},
tok=self.admin_user_tok,
)
self.helper.send_state(
room_id_2, "m.room.name", {"name": room_name_2}, tok=self.admin_user_tok,
room_id_2,
"m.room.name",
{"name": room_name_2},
tok=self.admin_user_tok,
)
url = "/_synapse/admin/v1/rooms/%s" % (room_id_1,)
channel = self.make_request(
"GET", url.encode("ascii"), access_token=self.admin_user_tok,
"GET",
url.encode("ascii"),
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
@ -1109,7 +1155,9 @@ class RoomTestCase(unittest.HomeserverTestCase):
url = "/_synapse/admin/v1/rooms/%s" % (room_id_1,)
channel = self.make_request(
"GET", url.encode("ascii"), access_token=self.admin_user_tok,
"GET",
url.encode("ascii"),
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(1, channel.json_body["joined_local_devices"])
@ -1121,7 +1169,9 @@ class RoomTestCase(unittest.HomeserverTestCase):
url = "/_synapse/admin/v1/rooms/%s" % (room_id_1,)
channel = self.make_request(
"GET", url.encode("ascii"), access_token=self.admin_user_tok,
"GET",
url.encode("ascii"),
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(2, channel.json_body["joined_local_devices"])
@ -1131,7 +1181,9 @@ class RoomTestCase(unittest.HomeserverTestCase):
self.helper.leave(room_id_1, user_1, tok=user_tok_1)
url = "/_synapse/admin/v1/rooms/%s" % (room_id_1,)
channel = self.make_request(
"GET", url.encode("ascii"), access_token=self.admin_user_tok,
"GET",
url.encode("ascii"),
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(0, channel.json_body["joined_local_devices"])
@ -1160,7 +1212,9 @@ class RoomTestCase(unittest.HomeserverTestCase):
url = "/_synapse/admin/v1/rooms/%s/members" % (room_id_1,)
channel = self.make_request(
"GET", url.encode("ascii"), access_token=self.admin_user_tok,
"GET",
url.encode("ascii"),
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
@ -1171,7 +1225,9 @@ class RoomTestCase(unittest.HomeserverTestCase):
url = "/_synapse/admin/v1/rooms/%s/members" % (room_id_2,)
channel = self.make_request(
"GET", url.encode("ascii"), access_token=self.admin_user_tok,
"GET",
url.encode("ascii"),
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
@ -1187,7 +1243,9 @@ class RoomTestCase(unittest.HomeserverTestCase):
url = "/_synapse/admin/v1/rooms/%s/state" % (room_id,)
channel = self.make_request(
"GET", url.encode("ascii"), access_token=self.admin_user_tok,
"GET",
url.encode("ascii"),
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertIn("state", channel.json_body)
@ -1342,7 +1400,9 @@ class JoinAliasRoomTestCase(unittest.HomeserverTestCase):
# Validate if user is a member of the room
channel = self.make_request(
"GET", "/_matrix/client/r0/joined_rooms", access_token=self.second_tok,
"GET",
"/_matrix/client/r0/joined_rooms",
access_token=self.second_tok,
)
self.assertEquals(200, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(self.public_room_id, channel.json_body["joined_rooms"][0])
@ -1389,7 +1449,9 @@ class JoinAliasRoomTestCase(unittest.HomeserverTestCase):
# Validate if server admin is a member of the room
channel = self.make_request(
"GET", "/_matrix/client/r0/joined_rooms", access_token=self.admin_user_tok,
"GET",
"/_matrix/client/r0/joined_rooms",
access_token=self.admin_user_tok,
)
self.assertEquals(200, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(private_room_id, channel.json_body["joined_rooms"][0])
@ -1411,7 +1473,9 @@ class JoinAliasRoomTestCase(unittest.HomeserverTestCase):
# Validate if user is a member of the room
channel = self.make_request(
"GET", "/_matrix/client/r0/joined_rooms", access_token=self.second_tok,
"GET",
"/_matrix/client/r0/joined_rooms",
access_token=self.second_tok,
)
self.assertEquals(200, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(private_room_id, channel.json_body["joined_rooms"][0])
@ -1440,7 +1504,9 @@ class JoinAliasRoomTestCase(unittest.HomeserverTestCase):
# Validate if user is a member of the room
channel = self.make_request(
"GET", "/_matrix/client/r0/joined_rooms", access_token=self.second_tok,
"GET",
"/_matrix/client/r0/joined_rooms",
access_token=self.second_tok,
)
self.assertEquals(200, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(private_room_id, channel.json_body["joined_rooms"][0])
@ -1555,8 +1621,7 @@ class MakeRoomAdminTestCase(unittest.HomeserverTestCase):
)
def test_public_room(self):
"""Test that getting admin in a public room works.
"""
"""Test that getting admin in a public room works."""
room_id = self.helper.create_room_as(
self.creator, tok=self.creator_tok, is_public=True
)
@ -1581,10 +1646,11 @@ class MakeRoomAdminTestCase(unittest.HomeserverTestCase):
)
def test_private_room(self):
"""Test that getting admin in a private room works and we get invited.
"""
"""Test that getting admin in a private room works and we get invited."""
room_id = self.helper.create_room_as(
self.creator, tok=self.creator_tok, is_public=False,
self.creator,
tok=self.creator_tok,
is_public=False,
)
channel = self.make_request(
@ -1608,8 +1674,7 @@ class MakeRoomAdminTestCase(unittest.HomeserverTestCase):
)
def test_other_user(self):
"""Test that giving admin in a public room works to a non-admin user works.
"""
"""Test that giving admin in a public room works to a non-admin user works."""
room_id = self.helper.create_room_as(
self.creator, tok=self.creator_tok, is_public=True
)
@ -1634,8 +1699,7 @@ class MakeRoomAdminTestCase(unittest.HomeserverTestCase):
)
def test_not_enough_power(self):
"""Test that we get a sensible error if there are no local room admins.
"""
"""Test that we get a sensible error if there are no local room admins."""
room_id = self.helper.create_room_as(
self.creator, tok=self.creator_tok, is_public=True
)

133
tests/rest/admin/test_statistics.py
View file

@ -55,7 +55,10 @@ class UserMediaStatisticsTestCase(unittest.HomeserverTestCase):
If the user is not a server admin, an error 403 is returned.
"""
channel = self.make_request(
"GET", self.url, json.dumps({}), access_token=self.other_user_tok,
"GET",
self.url,
json.dumps({}),
access_token=self.other_user_tok,
)
self.assertEqual(403, int(channel.result["code"]), msg=channel.result["body"])
@ -67,7 +70,9 @@ class UserMediaStatisticsTestCase(unittest.HomeserverTestCase):
"""
# unkown order_by
channel = self.make_request(
"GET", self.url + "?order_by=bar", access_token=self.admin_user_tok,
"GET",
self.url + "?order_by=bar",
access_token=self.admin_user_tok,
)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
@ -75,7 +80,9 @@ class UserMediaStatisticsTestCase(unittest.HomeserverTestCase):
# negative from
channel = self.make_request(
"GET", self.url + "?from=-5", access_token=self.admin_user_tok,
"GET",
self.url + "?from=-5",
access_token=self.admin_user_tok,
)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
@ -83,7 +90,9 @@ class UserMediaStatisticsTestCase(unittest.HomeserverTestCase):
# negative limit
channel = self.make_request(
"GET", self.url + "?limit=-5", access_token=self.admin_user_tok,
"GET",
self.url + "?limit=-5",
access_token=self.admin_user_tok,
)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
@ -91,7 +100,9 @@ class UserMediaStatisticsTestCase(unittest.HomeserverTestCase):
# negative from_ts
channel = self.make_request(
"GET", self.url + "?from_ts=-1234", access_token=self.admin_user_tok,
"GET",
self.url + "?from_ts=-1234",
access_token=self.admin_user_tok,
)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
@ -99,7 +110,9 @@ class UserMediaStatisticsTestCase(unittest.HomeserverTestCase):
# negative until_ts
channel = self.make_request(
"GET", self.url + "?until_ts=-1234", access_token=self.admin_user_tok,
"GET",
self.url + "?until_ts=-1234",
access_token=self.admin_user_tok,
)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
@ -117,7 +130,9 @@ class UserMediaStatisticsTestCase(unittest.HomeserverTestCase):
# empty search term
channel = self.make_request(
"GET", self.url + "?search_term=", access_token=self.admin_user_tok,
"GET",
self.url + "?search_term=",
access_token=self.admin_user_tok,
)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
@ -125,7 +140,9 @@ class UserMediaStatisticsTestCase(unittest.HomeserverTestCase):
# invalid search order
channel = self.make_request(
"GET", self.url + "?dir=bar", access_token=self.admin_user_tok,
"GET",
self.url + "?dir=bar",
access_token=self.admin_user_tok,
)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
@ -138,7 +155,9 @@ class UserMediaStatisticsTestCase(unittest.HomeserverTestCase):
self._create_users_with_media(10, 2)
channel = self.make_request(
"GET", self.url + "?limit=5", access_token=self.admin_user_tok,
"GET",
self.url + "?limit=5",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -154,7 +173,9 @@ class UserMediaStatisticsTestCase(unittest.HomeserverTestCase):
self._create_users_with_media(20, 2)
channel = self.make_request(
"GET", self.url + "?from=5", access_token=self.admin_user_tok,
"GET",
self.url + "?from=5",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -170,7 +191,9 @@ class UserMediaStatisticsTestCase(unittest.HomeserverTestCase):
self._create_users_with_media(20, 2)
channel = self.make_request(
"GET", self.url + "?from=5&limit=10", access_token=self.admin_user_tok,
"GET",
self.url + "?from=5&limit=10",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -190,7 +213,9 @@ class UserMediaStatisticsTestCase(unittest.HomeserverTestCase):
# `next_token` does not appear
# Number of results is the number of entries
channel = self.make_request(
"GET", self.url + "?limit=20", access_token=self.admin_user_tok,
"GET",
self.url + "?limit=20",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -201,7 +226,9 @@ class UserMediaStatisticsTestCase(unittest.HomeserverTestCase):
# `next_token` does not appear
# Number of max results is larger than the number of entries
channel = self.make_request(
"GET", self.url + "?limit=21", access_token=self.admin_user_tok,
"GET",
self.url + "?limit=21",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -212,7 +239,9 @@ class UserMediaStatisticsTestCase(unittest.HomeserverTestCase):
# `next_token` does appear
# Number of max results is smaller than the number of entries
channel = self.make_request(
"GET", self.url + "?limit=19", access_token=self.admin_user_tok,
"GET",
self.url + "?limit=19",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -223,7 +252,9 @@ class UserMediaStatisticsTestCase(unittest.HomeserverTestCase):
# Set `from` to value of `next_token` for request remaining entries
# Check `next_token` does not appear
channel = self.make_request(
"GET", self.url + "?from=19", access_token=self.admin_user_tok,
"GET",
self.url + "?from=19",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -237,7 +268,11 @@ class UserMediaStatisticsTestCase(unittest.HomeserverTestCase):
if users have no media created
"""
channel = self.make_request("GET", self.url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
self.url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(0, channel.json_body["total"])
@ -264,10 +299,14 @@ class UserMediaStatisticsTestCase(unittest.HomeserverTestCase):
# order by user_id
self._order_test("user_id", ["@user_a:test", "@user_b:test", "@user_c:test"])
self._order_test(
"user_id", ["@user_a:test", "@user_b:test", "@user_c:test"], "f",
"user_id",
["@user_a:test", "@user_b:test", "@user_c:test"],
"f",
)
self._order_test(
"user_id", ["@user_c:test", "@user_b:test", "@user_a:test"], "b",
"user_id",
["@user_c:test", "@user_b:test", "@user_a:test"],
"b",
)
# order by displayname
@ -275,32 +314,46 @@ class UserMediaStatisticsTestCase(unittest.HomeserverTestCase):
"displayname", ["@user_c:test", "@user_b:test", "@user_a:test"]
)
self._order_test(
"displayname", ["@user_c:test", "@user_b:test", "@user_a:test"], "f",
"displayname",
["@user_c:test", "@user_b:test", "@user_a:test"],
"f",
)
self._order_test(
"displayname", ["@user_a:test", "@user_b:test", "@user_c:test"], "b",
"displayname",
["@user_a:test", "@user_b:test", "@user_c:test"],
"b",
)
# order by media_length
self._order_test(
"media_length", ["@user_a:test", "@user_c:test", "@user_b:test"],
"media_length",
["@user_a:test", "@user_c:test", "@user_b:test"],
)
self._order_test(
"media_length", ["@user_a:test", "@user_c:test", "@user_b:test"], "f",
"media_length",
["@user_a:test", "@user_c:test", "@user_b:test"],
"f",
)
self._order_test(
"media_length", ["@user_b:test", "@user_c:test", "@user_a:test"], "b",
"media_length",
["@user_b:test", "@user_c:test", "@user_a:test"],
"b",
)
# order by media_count
self._order_test(
"media_count", ["@user_a:test", "@user_c:test", "@user_b:test"],
"media_count",
["@user_a:test", "@user_c:test", "@user_b:test"],
)
self._order_test(
"media_count", ["@user_a:test", "@user_c:test", "@user_b:test"], "f",
"media_count",
["@user_a:test", "@user_c:test", "@user_b:test"],
"f",
)
self._order_test(
"media_count", ["@user_b:test", "@user_c:test", "@user_a:test"], "b",
"media_count",
["@user_b:test", "@user_c:test", "@user_a:test"],
"b",
)
def test_from_until_ts(self):
@ -313,14 +366,20 @@ class UserMediaStatisticsTestCase(unittest.HomeserverTestCase):
ts1 = self.clock.time_msec()
# list all media when filter is not set
channel = self.make_request("GET", self.url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
self.url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(channel.json_body["users"][0]["media_count"], 3)
# filter media starting at `ts1` after creating first media
# result is 0
channel = self.make_request(
"GET", self.url + "?from_ts=%s" % (ts1,), access_token=self.admin_user_tok,
"GET",
self.url + "?from_ts=%s" % (ts1,),
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(channel.json_body["total"], 0)
@ -342,7 +401,9 @@ class UserMediaStatisticsTestCase(unittest.HomeserverTestCase):
# filter media until `ts2` and earlier
channel = self.make_request(
"GET", self.url + "?until_ts=%s" % (ts2,), access_token=self.admin_user_tok,
"GET",
self.url + "?until_ts=%s" % (ts2,),
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(channel.json_body["users"][0]["media_count"], 6)
@ -351,7 +412,11 @@ class UserMediaStatisticsTestCase(unittest.HomeserverTestCase):
self._create_users_with_media(20, 1)
# check without filter get all users
channel = self.make_request("GET", self.url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
self.url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(channel.json_body["total"], 20)
@ -376,7 +441,9 @@ class UserMediaStatisticsTestCase(unittest.HomeserverTestCase):
# filter and get empty result
channel = self.make_request(
"GET", self.url + "?search_term=foobar", access_token=self.admin_user_tok,
"GET",
self.url + "?search_term=foobar",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(channel.json_body["total"], 0)
@ -441,7 +508,9 @@ class UserMediaStatisticsTestCase(unittest.HomeserverTestCase):
if dir is not None and dir in ("b", "f"):
url += "&dir=%s" % (dir,)
channel = self.make_request(
"GET", url.encode("ascii"), access_token=self.admin_user_tok,
"GET",
url.encode("ascii"),
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(channel.json_body["total"], len(expected_user_list))

348
tests/rest/admin/test_user.py
View file

@ -528,9 +528,14 @@ class UsersListTestCase(unittest.HomeserverTestCase):
search_field: Field which is to request: `name` or `user_id`
expected_http_code: The expected http code for the request
"""
url = self.url + "?%s=%s" % (search_field, search_term,)
url = self.url + "?%s=%s" % (
search_field,
search_term,
)
channel = self.make_request(
"GET", url.encode("ascii"), access_token=self.admin_user_tok,
"GET",
url.encode("ascii"),
access_token=self.admin_user_tok,
)
self.assertEqual(expected_http_code, channel.code, msg=channel.json_body)
@ -590,7 +595,9 @@ class UsersListTestCase(unittest.HomeserverTestCase):
# negative limit
channel = self.make_request(
"GET", self.url + "?limit=-5", access_token=self.admin_user_tok,
"GET",
self.url + "?limit=-5",
access_token=self.admin_user_tok,
)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
@ -598,7 +605,9 @@ class UsersListTestCase(unittest.HomeserverTestCase):
# negative from
channel = self.make_request(
"GET", self.url + "?from=-5", access_token=self.admin_user_tok,
"GET",
self.url + "?from=-5",
access_token=self.admin_user_tok,
)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
@ -606,7 +615,9 @@ class UsersListTestCase(unittest.HomeserverTestCase):
# invalid guests
channel = self.make_request(
"GET", self.url + "?guests=not_bool", access_token=self.admin_user_tok,
"GET",
self.url + "?guests=not_bool",
access_token=self.admin_user_tok,
)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
@ -614,7 +625,9 @@ class UsersListTestCase(unittest.HomeserverTestCase):
# invalid deactivated
channel = self.make_request(
"GET", self.url + "?deactivated=not_bool", access_token=self.admin_user_tok,
"GET",
self.url + "?deactivated=not_bool",
access_token=self.admin_user_tok,
)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
@ -630,7 +643,9 @@ class UsersListTestCase(unittest.HomeserverTestCase):
self._create_users(number_users - 1)
channel = self.make_request(
"GET", self.url + "?limit=5", access_token=self.admin_user_tok,
"GET",
self.url + "?limit=5",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -649,7 +664,9 @@ class UsersListTestCase(unittest.HomeserverTestCase):
self._create_users(number_users - 1)
channel = self.make_request(
"GET", self.url + "?from=5", access_token=self.admin_user_tok,
"GET",
self.url + "?from=5",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -668,7 +685,9 @@ class UsersListTestCase(unittest.HomeserverTestCase):
self._create_users(number_users - 1)
channel = self.make_request(
"GET", self.url + "?from=5&limit=10", access_token=self.admin_user_tok,
"GET",
self.url + "?from=5&limit=10",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -689,7 +708,9 @@ class UsersListTestCase(unittest.HomeserverTestCase):
# `next_token` does not appear
# Number of results is the number of entries
channel = self.make_request(
"GET", self.url + "?limit=20", access_token=self.admin_user_tok,
"GET",
self.url + "?limit=20",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -700,7 +721,9 @@ class UsersListTestCase(unittest.HomeserverTestCase):
# `next_token` does not appear
# Number of max results is larger than the number of entries
channel = self.make_request(
"GET", self.url + "?limit=21", access_token=self.admin_user_tok,
"GET",
self.url + "?limit=21",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -711,7 +734,9 @@ class UsersListTestCase(unittest.HomeserverTestCase):
# `next_token` does appear
# Number of max results is smaller than the number of entries
channel = self.make_request(
"GET", self.url + "?limit=19", access_token=self.admin_user_tok,
"GET",
self.url + "?limit=19",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -723,7 +748,9 @@ class UsersListTestCase(unittest.HomeserverTestCase):
# Set `from` to value of `next_token` for request remaining entries
# `next_token` does not appear
channel = self.make_request(
"GET", self.url + "?from=19", access_token=self.admin_user_tok,
"GET",
self.url + "?from=19",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -753,7 +780,10 @@ class UsersListTestCase(unittest.HomeserverTestCase):
"""
for i in range(1, number_users + 1):
self.register_user(
"user%d" % i, "pass%d" % i, admin=False, displayname="Name %d" % i,
"user%d" % i,
"pass%d" % i,
admin=False,
displayname="Name %d" % i,
)
@ -808,7 +838,10 @@ class DeactivateAccountTestCase(unittest.HomeserverTestCase):
self.assertEqual("You are not a server admin", channel.json_body["error"])
channel = self.make_request(
"POST", url, access_token=self.other_user_token, content=b"{}",
"POST",
url,
access_token=self.other_user_token,
content=b"{}",
)
self.assertEqual(403, int(channel.result["code"]), msg=channel.result["body"])
@ -862,7 +895,9 @@ class DeactivateAccountTestCase(unittest.HomeserverTestCase):
# Get user
channel = self.make_request(
"GET", self.url_other_user, access_token=self.admin_user_tok,
"GET",
self.url_other_user,
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -886,7 +921,9 @@ class DeactivateAccountTestCase(unittest.HomeserverTestCase):
# Get user
channel = self.make_request(
"GET", self.url_other_user, access_token=self.admin_user_tok,
"GET",
self.url_other_user,
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -905,7 +942,9 @@ class DeactivateAccountTestCase(unittest.HomeserverTestCase):
# Get user
channel = self.make_request(
"GET", self.url_other_user, access_token=self.admin_user_tok,
"GET",
self.url_other_user,
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -929,7 +968,9 @@ class DeactivateAccountTestCase(unittest.HomeserverTestCase):
# Get user
channel = self.make_request(
"GET", self.url_other_user, access_token=self.admin_user_tok,
"GET",
self.url_other_user,
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -942,8 +983,7 @@ class DeactivateAccountTestCase(unittest.HomeserverTestCase):
self._is_erased("@user:test", False)
def _is_erased(self, user_id: str, expect: bool) -> None:
"""Assert that the user is erased or not
"""
"""Assert that the user is erased or not"""
d = self.store.is_user_erased(user_id)
if expect:
self.assertTrue(self.get_success(d))
@ -977,13 +1017,20 @@ class UserRestTestCase(unittest.HomeserverTestCase):
"""
url = "/_synapse/admin/v2/users/@bob:test"
channel = self.make_request("GET", url, access_token=self.other_user_token,)
channel = self.make_request(
"GET",
url,
access_token=self.other_user_token,
)
self.assertEqual(403, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual("You are not a server admin", channel.json_body["error"])
channel = self.make_request(
"PUT", url, access_token=self.other_user_token, content=b"{}",
"PUT",
url,
access_token=self.other_user_token,
content=b"{}",
)
self.assertEqual(403, int(channel.result["code"]), msg=channel.result["body"])
@ -1036,7 +1083,11 @@ class UserRestTestCase(unittest.HomeserverTestCase):
self.assertEqual("mxc://fibble/wibble", channel.json_body["avatar_url"])
# Get user
channel = self.make_request("GET", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual("@bob:test", channel.json_body["name"])
@ -1081,7 +1132,11 @@ class UserRestTestCase(unittest.HomeserverTestCase):
self.assertEqual("mxc://fibble/wibble", channel.json_body["avatar_url"])
# Get user
channel = self.make_request("GET", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual("@bob:test", channel.json_body["name"])
@ -1306,7 +1361,9 @@ class UserRestTestCase(unittest.HomeserverTestCase):
# Get user
channel = self.make_request(
"GET", self.url_other_user, access_token=self.admin_user_tok,
"GET",
self.url_other_user,
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -1337,7 +1394,9 @@ class UserRestTestCase(unittest.HomeserverTestCase):
# Get user
channel = self.make_request(
"GET", self.url_other_user, access_token=self.admin_user_tok,
"GET",
self.url_other_user,
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -1360,7 +1419,9 @@ class UserRestTestCase(unittest.HomeserverTestCase):
# Get user
channel = self.make_request(
"GET", self.url_other_user, access_token=self.admin_user_tok,
"GET",
self.url_other_user,
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -1390,7 +1451,9 @@ class UserRestTestCase(unittest.HomeserverTestCase):
# Get user
channel = self.make_request(
"GET", self.url_other_user, access_token=self.admin_user_tok,
"GET",
self.url_other_user,
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -1488,7 +1551,9 @@ class UserRestTestCase(unittest.HomeserverTestCase):
# Get user
channel = self.make_request(
"GET", self.url_other_user, access_token=self.admin_user_tok,
"GET",
self.url_other_user,
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -1517,7 +1582,9 @@ class UserRestTestCase(unittest.HomeserverTestCase):
# Get user
channel = self.make_request(
"GET", self.url_other_user, access_token=self.admin_user_tok,
"GET",
self.url_other_user,
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -1546,7 +1613,11 @@ class UserRestTestCase(unittest.HomeserverTestCase):
self.assertEqual("bob", channel.json_body["displayname"])
# Get user
channel = self.make_request("GET", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual("@bob:test", channel.json_body["name"])
@ -1566,7 +1637,11 @@ class UserRestTestCase(unittest.HomeserverTestCase):
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
# Check user is not deactivated
channel = self.make_request("GET", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual("@bob:test", channel.json_body["name"])
@ -1576,8 +1651,7 @@ class UserRestTestCase(unittest.HomeserverTestCase):
self.assertEqual(0, channel.json_body["deactivated"])
def _is_erased(self, user_id, expect):
"""Assert that the user is erased or not
"""
"""Assert that the user is erased or not"""
d = self.store.is_user_erased(user_id)
if expect:
self.assertTrue(self.get_success(d))
@ -1617,7 +1691,11 @@ class UserMembershipRestTestCase(unittest.HomeserverTestCase):
"""
other_user_token = self.login("user", "pass")
channel = self.make_request("GET", self.url, access_token=other_user_token,)
channel = self.make_request(
"GET",
self.url,
access_token=other_user_token,
)
self.assertEqual(403, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(Codes.FORBIDDEN, channel.json_body["errcode"])
@ -1627,7 +1705,11 @@ class UserMembershipRestTestCase(unittest.HomeserverTestCase):
Tests that a lookup for a user that does not exist returns an empty list
"""
url = "/_synapse/admin/v1/users/@unknown_person:test/joined_rooms"
channel = self.make_request("GET", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(0, channel.json_body["total"])
@ -1639,7 +1721,11 @@ class UserMembershipRestTestCase(unittest.HomeserverTestCase):
"""
url = "/_synapse/admin/v1/users/@unknown_person:unknown_domain/joined_rooms"
channel = self.make_request("GET", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(0, channel.json_body["total"])
@ -1651,7 +1737,11 @@ class UserMembershipRestTestCase(unittest.HomeserverTestCase):
if user has no memberships
"""
# Get rooms
channel = self.make_request("GET", self.url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
self.url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(0, channel.json_body["total"])
@ -1668,7 +1758,11 @@ class UserMembershipRestTestCase(unittest.HomeserverTestCase):
self.helper.create_room_as(self.other_user, tok=other_user_tok)
# Get rooms
channel = self.make_request("GET", self.url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
self.url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(number_rooms, channel.json_body["total"])
@ -1711,7 +1805,11 @@ class UserMembershipRestTestCase(unittest.HomeserverTestCase):
# Now get rooms
url = "/_synapse/admin/v1/users/@joiner:remote_hs/joined_rooms"
channel = self.make_request("GET", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(1, channel.json_body["total"])
@ -1751,7 +1849,11 @@ class PushersRestTestCase(unittest.HomeserverTestCase):
"""
other_user_token = self.login("user", "pass")
channel = self.make_request("GET", self.url, access_token=other_user_token,)
channel = self.make_request(
"GET",
self.url,
access_token=other_user_token,
)
self.assertEqual(403, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(Codes.FORBIDDEN, channel.json_body["errcode"])
@ -1761,7 +1863,11 @@ class PushersRestTestCase(unittest.HomeserverTestCase):
Tests that a lookup for a user that does not exist returns a 404
"""
url = "/_synapse/admin/v1/users/@unknown_person:test/pushers"
channel = self.make_request("GET", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(404, channel.code, msg=channel.json_body)
self.assertEqual(Codes.NOT_FOUND, channel.json_body["errcode"])
@ -1772,7 +1878,11 @@ class PushersRestTestCase(unittest.HomeserverTestCase):
"""
url = "/_synapse/admin/v1/users/@unknown_person:unknown_domain/pushers"
channel = self.make_request("GET", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(400, channel.code, msg=channel.json_body)
self.assertEqual("Can only lookup local users", channel.json_body["error"])
@ -1783,7 +1893,11 @@ class PushersRestTestCase(unittest.HomeserverTestCase):
"""
# Get pushers
channel = self.make_request("GET", self.url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
self.url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(0, channel.json_body["total"])
@ -1810,7 +1924,11 @@ class PushersRestTestCase(unittest.HomeserverTestCase):
)
# Get pushers
channel = self.make_request("GET", self.url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
self.url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(1, channel.json_body["total"])
@ -1859,7 +1977,11 @@ class UserMediaRestTestCase(unittest.HomeserverTestCase):
"""
other_user_token = self.login("user", "pass")
channel = self.make_request("GET", self.url, access_token=other_user_token,)
channel = self.make_request(
"GET",
self.url,
access_token=other_user_token,
)
self.assertEqual(403, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(Codes.FORBIDDEN, channel.json_body["errcode"])
@ -1869,7 +1991,11 @@ class UserMediaRestTestCase(unittest.HomeserverTestCase):
Tests that a lookup for a user that does not exist returns a 404
"""
url = "/_synapse/admin/v1/users/@unknown_person:test/media"
channel = self.make_request("GET", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(404, channel.code, msg=channel.json_body)
self.assertEqual(Codes.NOT_FOUND, channel.json_body["errcode"])
@ -1880,7 +2006,11 @@ class UserMediaRestTestCase(unittest.HomeserverTestCase):
"""
url = "/_synapse/admin/v1/users/@unknown_person:unknown_domain/media"
channel = self.make_request("GET", url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
url,
access_token=self.admin_user_tok,
)
self.assertEqual(400, channel.code, msg=channel.json_body)
self.assertEqual("Can only lookup local users", channel.json_body["error"])
@ -1895,7 +2025,9 @@ class UserMediaRestTestCase(unittest.HomeserverTestCase):
self._create_media(other_user_tok, number_media)
channel = self.make_request(
"GET", self.url + "?limit=5", access_token=self.admin_user_tok,
"GET",
self.url + "?limit=5",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -1914,7 +2046,9 @@ class UserMediaRestTestCase(unittest.HomeserverTestCase):
self._create_media(other_user_tok, number_media)
channel = self.make_request(
"GET", self.url + "?from=5", access_token=self.admin_user_tok,
"GET",
self.url + "?from=5",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -1933,7 +2067,9 @@ class UserMediaRestTestCase(unittest.HomeserverTestCase):
self._create_media(other_user_tok, number_media)
channel = self.make_request(
"GET", self.url + "?from=5&limit=10", access_token=self.admin_user_tok,
"GET",
self.url + "?from=5&limit=10",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -1948,7 +2084,9 @@ class UserMediaRestTestCase(unittest.HomeserverTestCase):
"""
channel = self.make_request(
"GET", self.url + "?limit=-5", access_token=self.admin_user_tok,
"GET",
self.url + "?limit=-5",
access_token=self.admin_user_tok,
)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
@ -1960,7 +2098,9 @@ class UserMediaRestTestCase(unittest.HomeserverTestCase):
"""
channel = self.make_request(
"GET", self.url + "?from=-5", access_token=self.admin_user_tok,
"GET",
self.url + "?from=-5",
access_token=self.admin_user_tok,
)
self.assertEqual(400, int(channel.result["code"]), msg=channel.result["body"])
@ -1978,7 +2118,9 @@ class UserMediaRestTestCase(unittest.HomeserverTestCase):
# `next_token` does not appear
# Number of results is the number of entries
channel = self.make_request(
"GET", self.url + "?limit=20", access_token=self.admin_user_tok,
"GET",
self.url + "?limit=20",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -1989,7 +2131,9 @@ class UserMediaRestTestCase(unittest.HomeserverTestCase):
# `next_token` does not appear
# Number of max results is larger than the number of entries
channel = self.make_request(
"GET", self.url + "?limit=21", access_token=self.admin_user_tok,
"GET",
self.url + "?limit=21",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -2000,7 +2144,9 @@ class UserMediaRestTestCase(unittest.HomeserverTestCase):
# `next_token` does appear
# Number of max results is smaller than the number of entries
channel = self.make_request(
"GET", self.url + "?limit=19", access_token=self.admin_user_tok,
"GET",
self.url + "?limit=19",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -2012,7 +2158,9 @@ class UserMediaRestTestCase(unittest.HomeserverTestCase):
# Set `from` to value of `next_token` for request remaining entries
# `next_token` does not appear
channel = self.make_request(
"GET", self.url + "?from=19", access_token=self.admin_user_tok,
"GET",
self.url + "?from=19",
access_token=self.admin_user_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -2026,7 +2174,11 @@ class UserMediaRestTestCase(unittest.HomeserverTestCase):
if user has no media created
"""
channel = self.make_request("GET", self.url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
self.url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(0, channel.json_body["total"])
@ -2041,7 +2193,11 @@ class UserMediaRestTestCase(unittest.HomeserverTestCase):
other_user_tok = self.login("user", "pass")
self._create_media(other_user_tok, number_media)
channel = self.make_request("GET", self.url, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
self.url,
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(number_media, channel.json_body["total"])
@ -2068,8 +2224,7 @@ class UserMediaRestTestCase(unittest.HomeserverTestCase):
)
def _check_fields(self, content):
"""Checks that all attributes are present in content
"""
"""Checks that all attributes are present in content"""
for m in content:
self.assertIn("media_id", m)
self.assertIn("media_type", m)
@ -2082,8 +2237,7 @@ class UserMediaRestTestCase(unittest.HomeserverTestCase):
class UserTokenRestTestCase(unittest.HomeserverTestCase):
"""Test for /_synapse/admin/v1/users/<user>/login
"""
"""Test for /_synapse/admin/v1/users/<user>/login"""
servlets = [
synapse.rest.admin.register_servlets,
@ -2114,16 +2268,14 @@ class UserTokenRestTestCase(unittest.HomeserverTestCase):
return channel.json_body["access_token"]
def test_no_auth(self):
"""Try to login as a user without authentication.
"""
"""Try to login as a user without authentication."""
channel = self.make_request("POST", self.url, b"{}")
self.assertEqual(401, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(Codes.MISSING_TOKEN, channel.json_body["errcode"])
def test_not_admin(self):
"""Try to login as a user as a non-admin user.
"""
"""Try to login as a user as a non-admin user."""
channel = self.make_request(
"POST", self.url, b"{}", access_token=self.other_user_tok
)
@ -2131,8 +2283,7 @@ class UserTokenRestTestCase(unittest.HomeserverTestCase):
self.assertEqual(403, int(channel.result["code"]), msg=channel.result["body"])
def test_send_event(self):
"""Test that sending event as a user works.
"""
"""Test that sending event as a user works."""
# Create a room.
room_id = self.helper.create_room_as(self.other_user, tok=self.other_user_tok)
@ -2146,8 +2297,7 @@ class UserTokenRestTestCase(unittest.HomeserverTestCase):
self.assertEqual(event.sender, self.other_user)
def test_devices(self):
"""Tests that logging in as a user doesn't create a new device for them.
"""
"""Tests that logging in as a user doesn't create a new device for them."""
# Login in as the user
self._get_token()
@ -2161,8 +2311,7 @@ class UserTokenRestTestCase(unittest.HomeserverTestCase):
self.assertEqual(len(channel.json_body["devices"]), 1)
def test_logout(self):
"""Test that calling `/logout` with the token works.
"""
"""Test that calling `/logout` with the token works."""
# Login in as the user
puppet_token = self._get_token()
@ -2252,8 +2401,7 @@ class UserTokenRestTestCase(unittest.HomeserverTestCase):
}
)
def test_consent(self):
"""Test that sending a message is not subject to the privacy policies.
"""
"""Test that sending a message is not subject to the privacy policies."""
# Have the admin user accept the terms.
self.get_success(self.store.user_set_consent_version(self.admin_user, "1.0"))
@ -2328,11 +2476,19 @@ class WhoisRestTestCase(unittest.HomeserverTestCase):
self.register_user("user2", "pass")
other_user2_token = self.login("user2", "pass")
channel = self.make_request("GET", self.url1, access_token=other_user2_token,)
channel = self.make_request(
"GET",
self.url1,
access_token=other_user2_token,
)
self.assertEqual(403, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(Codes.FORBIDDEN, channel.json_body["errcode"])
channel = self.make_request("GET", self.url2, access_token=other_user2_token,)
channel = self.make_request(
"GET",
self.url2,
access_token=other_user2_token,
)
self.assertEqual(403, int(channel.result["code"]), msg=channel.result["body"])
self.assertEqual(Codes.FORBIDDEN, channel.json_body["errcode"])
@ -2343,11 +2499,19 @@ class WhoisRestTestCase(unittest.HomeserverTestCase):
url1 = "/_synapse/admin/v1/whois/@unknown_person:unknown_domain"
url2 = "/_matrix/client/r0/admin/whois/@unknown_person:unknown_domain"
channel = self.make_request("GET", url1, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
url1,
access_token=self.admin_user_tok,
)
self.assertEqual(400, channel.code, msg=channel.json_body)
self.assertEqual("Can only whois a local user", channel.json_body["error"])
channel = self.make_request("GET", url2, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
url2,
access_token=self.admin_user_tok,
)
self.assertEqual(400, channel.code, msg=channel.json_body)
self.assertEqual("Can only whois a local user", channel.json_body["error"])
@ -2355,12 +2519,20 @@ class WhoisRestTestCase(unittest.HomeserverTestCase):
"""
The lookup should succeed for an admin.
"""
channel = self.make_request("GET", self.url1, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
self.url1,
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(self.other_user, channel.json_body["user_id"])
self.assertIn("devices", channel.json_body)
channel = self.make_request("GET", self.url2, access_token=self.admin_user_tok,)
channel = self.make_request(
"GET",
self.url2,
access_token=self.admin_user_tok,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(self.other_user, channel.json_body["user_id"])
self.assertIn("devices", channel.json_body)
@ -2371,12 +2543,20 @@ class WhoisRestTestCase(unittest.HomeserverTestCase):
"""
other_user_token = self.login("user", "pass")
channel = self.make_request("GET", self.url1, access_token=other_user_token,)
channel = self.make_request(
"GET",
self.url1,
access_token=other_user_token,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(self.other_user, channel.json_body["user_id"])
self.assertIn("devices", channel.json_body)
channel = self.make_request("GET", self.url2, access_token=other_user_token,)
channel = self.make_request(
"GET",
self.url2,
access_token=other_user_token,
)
self.assertEqual(200, channel.code, msg=channel.json_body)
self.assertEqual(self.other_user, channel.json_body["user_id"])
self.assertIn("devices", channel.json_body)

4
tests/rest/client/test_power_levels.py
View file

@ -73,7 +73,9 @@ class PowerLevelsTestCase(HomeserverTestCase):
# Mod the mod
room_power_levels = self.helper.get_state(
self.room_id, "m.room.power_levels", tok=self.admin_access_token,
self.room_id,
"m.room.power_levels",
tok=self.admin_access_token,
)
# Update existing power levels with mod at PL50

3
tests/rest/client/test_redactions.py
View file

@ -181,8 +181,7 @@ class RedactionsTestCase(HomeserverTestCase):
)
def test_redact_event_as_moderator_ratelimit(self):
"""Tests that the correct ratelimiting is applied to redactions
"""
"""Tests that the correct ratelimiting is applied to redactions"""
message_ids = []
# as a regular user, send messages to redact

3
tests/rest/client/test_retention.py
View file

@ -250,7 +250,8 @@ class RetentionNoDefaultPolicyTestCase(unittest.HomeserverTestCase):
mock_federation_client = Mock(spec=["backfill"])
self.hs = self.setup_test_homeserver(
config=config, federation_client=mock_federation_client,
config=config,
federation_client=mock_federation_client,
)
return self.hs

10
tests/rest/client/test_shadow_banned.py
View file

@ -260,7 +260,10 @@ class ProfileTestCase(_ShadowBannedBase):
message_handler = self.hs.get_message_handler()
event = self.get_success(
message_handler.get_room_data(
self.banned_user_id, room_id, "m.room.member", self.banned_user_id,
self.banned_user_id,
room_id,
"m.room.member",
self.banned_user_id,
)
)
self.assertEqual(
@ -292,7 +295,10 @@ class ProfileTestCase(_ShadowBannedBase):
message_handler = self.hs.get_message_handler()
event = self.get_success(
message_handler.get_room_data(
self.banned_user_id, room_id, "m.room.member", self.banned_user_id,
self.banned_user_id,
room_id,
"m.room.member",
self.banned_user_id,
)
)
self.assertEqual(

4
tests/rest/client/v1/test_events.py
View file

@ -150,6 +150,8 @@ class GetEventsTestCase(unittest.HomeserverTestCase):
event_id = resp["event_id"]
channel = self.make_request(
"GET", "/events/" + event_id, access_token=self.token,
"GET",
"/events/" + event_id,
access_token=self.token,
)
self.assertEquals(channel.code, 200, msg=channel.result)

18
tests/rest/client/v1/test_login.py
View file

@ -611,7 +611,9 @@ class MultiSSOTestCase(unittest.HomeserverTestCase):
# matrix access token, mxid, and device id.
login_token = params[2][1]
chan = self.make_request(
"POST", "/login", content={"type": "m.login.token", "token": login_token},
"POST",
"/login",
content={"type": "m.login.token", "token": login_token},
)
self.assertEqual(chan.code, 200, chan.result)
self.assertEqual(chan.json_body["user_id"], "@user1:test")
@ -619,7 +621,8 @@ class MultiSSOTestCase(unittest.HomeserverTestCase):
def test_multi_sso_redirect_to_unknown(self):
"""An unknown IdP should cause a 400"""
channel = self.make_request(
"GET", "/_synapse/client/pick_idp?redirectUrl=http://x&idp=xyz",
"GET",
"/_synapse/client/pick_idp?redirectUrl=http://x&idp=xyz",
)
self.assertEqual(channel.code, 400, channel.result)
@ -719,7 +722,8 @@ class CASTestCase(unittest.HomeserverTestCase):
mocked_http_client.get_raw.side_effect = get_raw
self.hs = self.setup_test_homeserver(
config=config, proxied_http_client=mocked_http_client,
config=config,
proxied_http_client=mocked_http_client,
)
return self.hs
@ -1244,7 +1248,9 @@ class UsernamePickerTestCase(HomeserverTestCase):
# looks ok.
username_mapping_sessions = self.hs.get_sso_handler()._username_mapping_sessions
self.assertIn(
session_id, username_mapping_sessions, "session id not found in map",
session_id,
username_mapping_sessions,
"session id not found in map",
)
session = username_mapping_sessions[session_id]
self.assertEqual(session.remote_user_id, "tester")
@ -1299,7 +1305,9 @@ class UsernamePickerTestCase(HomeserverTestCase):
# finally, submit the matrix login token to the login API, which gives us our
# matrix access token, mxid, and device id.
chan = self.make_request(
"POST", "/login", content={"type": "m.login.token", "token": login_token},
"POST",
"/login",
content={"type": "m.login.token", "token": login_token},
)
self.assertEqual(chan.code, 200, chan.result)
self.assertEqual(chan.json_body["user_id"], "@bobby:test")

16
tests/rest/client/v1/test_rooms.py
View file

@ -46,7 +46,9 @@ class RoomBase(unittest.HomeserverTestCase):
def make_homeserver(self, reactor, clock):
self.hs = self.setup_test_homeserver(
"red", federation_http_client=None, federation_client=Mock(),
"red",
federation_http_client=None,
federation_client=Mock(),
)
self.hs.get_federation_handler = Mock()
@ -1480,7 +1482,9 @@ class LabelsTestCase(unittest.HomeserverTestCase):
results = channel.json_body["search_categories"]["room_events"]["results"]
self.assertEqual(
len(results), 2, [result["result"]["content"] for result in results],
len(results),
2,
[result["result"]["content"] for result in results],
)
self.assertEqual(
results[0]["result"]["content"]["body"],
@ -1515,7 +1519,9 @@ class LabelsTestCase(unittest.HomeserverTestCase):
results = channel.json_body["search_categories"]["room_events"]["results"]
self.assertEqual(
len(results), 4, [result["result"]["content"] for result in results],
len(results),
4,
[result["result"]["content"] for result in results],
)
self.assertEqual(
results[0]["result"]["content"]["body"],
@ -1562,7 +1568,9 @@ class LabelsTestCase(unittest.HomeserverTestCase):
results = channel.json_body["search_categories"]["room_events"]["results"]
self.assertEqual(
len(results), 1, [result["result"]["content"] for result in results],
len(results),
1,
[result["result"]["content"] for result in results],
)
self.assertEqual(
results[0]["result"]["content"]["body"],

4
tests/rest/client/v1/test_typing.py
View file

@ -37,7 +37,9 @@ class RoomTypingTestCase(unittest.HomeserverTestCase):
def make_homeserver(self, reactor, clock):
hs = self.setup_test_homeserver(
"red", federation_http_client=None, federation_client=Mock(),
"red",
federation_http_client=None,
federation_client=Mock(),
)
self.event_source = hs.get_event_sources().sources["typing"]

36
tests/rest/client/v1/utils.py
View file

@ -166,9 +166,12 @@ class RestHelper:
json.dumps(data).encode("utf8"),
)
assert int(channel.result["code"]) == expect_code, (
"Expected: %d, got: %d, resp: %r"
% (expect_code, int(channel.result["code"]), channel.result["body"])
assert (
int(channel.result["code"]) == expect_code
), "Expected: %d, got: %d, resp: %r" % (
expect_code,
int(channel.result["code"]),
channel.result["body"],
)
self.auth_user_id = temp_id
@ -201,9 +204,12 @@ class RestHelper:
json.dumps(content).encode("utf8"),
)
assert int(channel.result["code"]) == expect_code, (
"Expected: %d, got: %d, resp: %r"
% (expect_code, int(channel.result["code"]), channel.result["body"])
assert (
int(channel.result["code"]) == expect_code
), "Expected: %d, got: %d, resp: %r" % (
expect_code,
int(channel.result["code"]),
channel.result["body"],
)
return channel.json_body
@ -251,9 +257,12 @@ class RestHelper:
channel = make_request(self.hs.get_reactor(), self.site, method, path, content)
assert int(channel.result["code"]) == expect_code, (
"Expected: %d, got: %d, resp: %r"
% (expect_code, int(channel.result["code"]), channel.result["body"])
assert (
int(channel.result["code"]) == expect_code
), "Expected: %d, got: %d, resp: %r" % (
expect_code,
int(channel.result["code"]),
channel.result["body"],
)
return channel.json_body
@ -447,7 +456,10 @@ class RestHelper:
return self.complete_oidc_auth(oauth_uri, cookies, user_info_dict)
def complete_oidc_auth(
self, oauth_uri: str, cookies: Mapping[str, str], user_info_dict: JsonDict,
self,
oauth_uri: str,
cookies: Mapping[str, str],
user_info_dict: JsonDict,
) -> FakeChannel:
"""Mock out an OIDC authentication flow
@ -491,7 +503,9 @@ class RestHelper:
(expected_uri, resp_obj) = expected_requests.pop(0)
assert uri == expected_uri
resp = FakeResponse(
code=200, phrase=b"OK", body=json.dumps(resp_obj).encode("utf-8"),
code=200,
phrase=b"OK",
body=json.dumps(resp_obj).encode("utf-8"),
)
return resp

76
tests/rest/client/v2_alpha/test_account.py
View file

@ -75,8 +75,7 @@ class PasswordResetTestCase(unittest.HomeserverTestCase):
self.submit_token_resource = PasswordResetSubmitTokenResource(hs)
def test_basic_password_reset(self):
"""Test basic password reset flow
"""
"""Test basic password reset flow"""
old_password = "monkey"
new_password = "kangeroo"
@ -114,8 +113,7 @@ class PasswordResetTestCase(unittest.HomeserverTestCase):
@override_config({"rc_3pid_validation": {"burst_count": 3}})
def test_ratelimit_by_email(self):
"""Test that we ratelimit /requestToken for the same email.
"""
"""Test that we ratelimit /requestToken for the same email."""
old_password = "monkey"
new_password = "kangeroo"
@ -203,8 +201,7 @@ class PasswordResetTestCase(unittest.HomeserverTestCase):
self.attempt_wrong_password_login("kermit", old_password)
def test_cant_reset_password_without_clicking_link(self):
"""Test that we do actually need to click the link in the email
"""
"""Test that we do actually need to click the link in the email"""
old_password = "monkey"
new_password = "kangeroo"
@ -299,7 +296,9 @@ class PasswordResetTestCase(unittest.HomeserverTestCase):
if channel.code != 200:
raise HttpResponseException(
channel.code, channel.result["reason"], channel.result["body"],
channel.code,
channel.result["reason"],
channel.result["body"],
)
return channel.json_body["sid"]
@ -566,8 +565,7 @@ class ThreepidEmailRestTestCase(unittest.HomeserverTestCase):
@override_config({"rc_3pid_validation": {"burst_count": 3}})
def test_ratelimit_by_ip(self):
"""Tests that adding emails is ratelimited by IP
"""
"""Tests that adding emails is ratelimited by IP"""
# We expect to be able to set three emails before getting ratelimited.
self.get_success(self._add_email("foo1@test.bar", "foo1@test.bar"))
@ -580,8 +578,7 @@ class ThreepidEmailRestTestCase(unittest.HomeserverTestCase):
self.assertEqual(cm.exception.code, 429)
def test_add_email_if_disabled(self):
"""Test adding email to profile when doing so is disallowed
"""
"""Test adding email to profile when doing so is disallowed"""
self.hs.config.enable_3pid_changes = False
client_secret = "foobar"
@ -611,15 +608,16 @@ class ThreepidEmailRestTestCase(unittest.HomeserverTestCase):
# Get user
channel = self.make_request(
"GET", self.url_3pid, access_token=self.user_id_tok,
"GET",
self.url_3pid,
access_token=self.user_id_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
self.assertFalse(channel.json_body["threepids"])
def test_delete_email(self):
"""Test deleting an email from profile
"""
"""Test deleting an email from profile"""
# Add a threepid
self.get_success(
self.store.user_add_threepid(
@ -641,15 +639,16 @@ class ThreepidEmailRestTestCase(unittest.HomeserverTestCase):
# Get user
channel = self.make_request(
"GET", self.url_3pid, access_token=self.user_id_tok,
"GET",
self.url_3pid,
access_token=self.user_id_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
self.assertFalse(channel.json_body["threepids"])
def test_delete_email_if_disabled(self):
"""Test deleting an email from profile when disallowed
"""
"""Test deleting an email from profile when disallowed"""
self.hs.config.enable_3pid_changes = False
# Add a threepid
@ -675,7 +674,9 @@ class ThreepidEmailRestTestCase(unittest.HomeserverTestCase):
# Get user
channel = self.make_request(
"GET", self.url_3pid, access_token=self.user_id_tok,
"GET",
self.url_3pid,
access_token=self.user_id_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -683,8 +684,7 @@ class ThreepidEmailRestTestCase(unittest.HomeserverTestCase):
self.assertEqual(self.email, channel.json_body["threepids"][0]["address"])
def test_cant_add_email_without_clicking_link(self):
"""Test that we do actually need to click the link in the email
"""
"""Test that we do actually need to click the link in the email"""
client_secret = "foobar"
session_id = self._request_token(self.email, client_secret)
@ -710,7 +710,9 @@ class ThreepidEmailRestTestCase(unittest.HomeserverTestCase):
# Get user
channel = self.make_request(
"GET", self.url_3pid, access_token=self.user_id_tok,
"GET",
self.url_3pid,
access_token=self.user_id_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -743,7 +745,9 @@ class ThreepidEmailRestTestCase(unittest.HomeserverTestCase):
# Get user
channel = self.make_request(
"GET", self.url_3pid, access_token=self.user_id_tok,
"GET",
self.url_3pid,
access_token=self.user_id_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])
@ -788,7 +792,10 @@ class ThreepidEmailRestTestCase(unittest.HomeserverTestCase):
# Ensure not providing a next_link parameter still works
self._request_token(
"something@example.com", "some_secret", next_link=None, expect_code=200,
"something@example.com",
"some_secret",
next_link=None,
expect_code=200,
)
self._request_token(
@ -846,17 +853,27 @@ class ThreepidEmailRestTestCase(unittest.HomeserverTestCase):
if next_link:
body["next_link"] = next_link
channel = self.make_request("POST", b"account/3pid/email/requestToken", body,)
channel = self.make_request(
"POST",
b"account/3pid/email/requestToken",
body,
)
if channel.code != expect_code:
raise HttpResponseException(
channel.code, channel.result["reason"], channel.result["body"],
channel.code,
channel.result["reason"],
channel.result["body"],
)
return channel.json_body.get("sid")
def _request_token_invalid_email(
self, email, expected_errcode, expected_error, client_secret="foobar",
self,
email,
expected_errcode,
expected_error,
client_secret="foobar",
):
channel = self.make_request(
"POST",
@ -895,8 +912,7 @@ class ThreepidEmailRestTestCase(unittest.HomeserverTestCase):
return match.group(0)
def _add_email(self, request_email, expected_email):
"""Test adding an email to profile
"""
"""Test adding an email to profile"""
previous_email_attempts = len(self.email_attempts)
client_secret = "foobar"
@ -926,7 +942,9 @@ class ThreepidEmailRestTestCase(unittest.HomeserverTestCase):
# Get user
channel = self.make_request(
"GET", self.url_3pid, access_token=self.user_id_tok,
"GET",
self.url_3pid,
access_token=self.user_id_tok,
)
self.assertEqual(200, int(channel.result["code"]), msg=channel.result["body"])

24
tests/rest/client/v2_alpha/test_auth.py
View file

@ -102,7 +102,8 @@ class FallbackAuthTests(unittest.HomeserverTestCase):
"""Ensure that fallback auth via a captcha works."""
# Returns a 401 as per the spec
channel = self.register(
401, {"username": "user", "type": "m.login.password", "password": "bar"},
401,
{"username": "user", "type": "m.login.password", "password": "bar"},
)
# Grab the session
@ -191,7 +192,10 @@ class UIAuthTests(unittest.HomeserverTestCase):
) -> FakeChannel:
"""Delete an individual device."""
channel = self.make_request(
"DELETE", "devices/" + device, body, access_token=access_token,
"DELETE",
"devices/" + device,
body,
access_token=access_token,
)
# Ensure the response is sane.
@ -204,7 +208,10 @@ class UIAuthTests(unittest.HomeserverTestCase):
# Note that this uses the delete_devices endpoint so that we can modify
# the payload half-way through some tests.
channel = self.make_request(
"POST", "delete_devices", body, access_token=self.user_tok,
"POST",
"delete_devices",
body,
access_token=self.user_tok,
)
# Ensure the response is sane.
@ -417,7 +424,10 @@ class UIAuthTests(unittest.HomeserverTestCase):
# and now the delete request should succeed.
self.delete_device(
self.user_tok, self.device_id, 200, body={"auth": {"session": session_id}},
self.user_tok,
self.device_id,
200,
body={"auth": {"session": session_id}},
)
@skip_unless(HAS_OIDC, "requires OIDC")
@ -443,8 +453,7 @@ class UIAuthTests(unittest.HomeserverTestCase):
@skip_unless(HAS_OIDC, "requires OIDC")
@override_config({"oidc_config": TEST_OIDC_CONFIG})
def test_offers_both_flows_for_upgraded_user(self):
"""A user that had a password and then logged in with SSO should get both flows
"""
"""A user that had a password and then logged in with SSO should get both flows"""
login_resp = self.helper.login_via_oidc(UserID.from_string(self.user).localpart)
self.assertEqual(login_resp["user_id"], self.user)
@ -459,8 +468,7 @@ class UIAuthTests(unittest.HomeserverTestCase):
@skip_unless(HAS_OIDC, "requires OIDC")
@override_config({"oidc_config": TEST_OIDC_CONFIG})
def test_ui_auth_fails_for_incorrect_sso_user(self):
"""If the user tries to authenticate with the wrong SSO user, they get an error
"""
"""If the user tries to authenticate with the wrong SSO user, they get an error"""
# log the user in
login_resp = self.helper.login_via_oidc(UserID.from_string(self.user).localpart)
self.assertEqual(login_resp["user_id"], self.user)

20
tests/rest/client/v2_alpha/test_password_policy.py
View file

@ -91,7 +91,9 @@ class PasswordPolicyTestCase(unittest.HomeserverTestCase):
self.assertEqual(channel.code, 400, channel.result)
self.assertEqual(
channel.json_body["errcode"], Codes.PASSWORD_TOO_SHORT, channel.result,
channel.json_body["errcode"],
Codes.PASSWORD_TOO_SHORT,
channel.result,
)
def test_password_no_digit(self):
@ -100,7 +102,9 @@ class PasswordPolicyTestCase(unittest.HomeserverTestCase):
self.assertEqual(channel.code, 400, channel.result)
self.assertEqual(
channel.json_body["errcode"], Codes.PASSWORD_NO_DIGIT, channel.result,
channel.json_body["errcode"],
Codes.PASSWORD_NO_DIGIT,
channel.result,
)
def test_password_no_symbol(self):
@ -109,7 +113,9 @@ class PasswordPolicyTestCase(unittest.HomeserverTestCase):
self.assertEqual(channel.code, 400, channel.result)
self.assertEqual(
channel.json_body["errcode"], Codes.PASSWORD_NO_SYMBOL, channel.result,
channel.json_body["errcode"],
Codes.PASSWORD_NO_SYMBOL,
channel.result,
)
def test_password_no_uppercase(self):
@ -118,7 +124,9 @@ class PasswordPolicyTestCase(unittest.HomeserverTestCase):
self.assertEqual(channel.code, 400, channel.result)
self.assertEqual(
channel.json_body["errcode"], Codes.PASSWORD_NO_UPPERCASE, channel.result,
channel.json_body["errcode"],
Codes.PASSWORD_NO_UPPERCASE,
channel.result,
)
def test_password_no_lowercase(self):
@ -127,7 +135,9 @@ class PasswordPolicyTestCase(unittest.HomeserverTestCase):
self.assertEqual(channel.code, 400, channel.result)
self.assertEqual(
channel.json_body["errcode"], Codes.PASSWORD_NO_LOWERCASE, channel.result,
channel.json_body["errcode"],
Codes.PASSWORD_NO_LOWERCASE,
channel.result,
)
def test_password_compliant(self):

27
tests/rest/client/v2_alpha/test_relations.py
View file

@ -83,14 +83,12 @@ class RelationsTestCase(unittest.HomeserverTestCase):
)
def test_deny_membership(self):
"""Test that we deny relations on membership events
"""
"""Test that we deny relations on membership events"""
channel = self._send_relation(RelationTypes.ANNOTATION, EventTypes.Member)
self.assertEquals(400, channel.code, channel.json_body)
def test_deny_double_react(self):
"""Test that we deny relations on membership events
"""
"""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)
@ -98,8 +96,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
self.assertEquals(400, channel.code, channel.json_body)
def test_basic_paginate_relations(self):
"""Tests that calling pagination API correctly the latest relations.
"""
"""Tests that calling pagination API correctly the latest relations."""
channel = self._send_relation(RelationTypes.ANNOTATION, "m.reaction")
self.assertEquals(200, channel.code, channel.json_body)
@ -174,8 +171,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
self.assertEquals(found_event_ids, expected_event_ids)
def test_aggregation_pagination_groups(self):
"""Test that we can paginate annotation groups correctly.
"""
"""Test that we can paginate annotation groups correctly."""
# We need to create ten separate users to send each reaction.
access_tokens = [self.user_token, self.user2_token]
@ -240,8 +236,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
self.assertEquals(sent_groups, found_groups)
def test_aggregation_pagination_within_group(self):
"""Test that we can paginate within an annotation group.
"""
"""Test that we can paginate within an annotation group."""
# We need to create ten separate users to send each reaction.
access_tokens = [self.user_token, self.user2_token]
@ -311,8 +306,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
self.assertEquals(found_event_ids, expected_event_ids)
def test_aggregation(self):
"""Test that annotations get correctly aggregated.
"""
"""Test that annotations get correctly aggregated."""
channel = self._send_relation(RelationTypes.ANNOTATION, "m.reaction", "a")
self.assertEquals(200, channel.code, channel.json_body)
@ -344,8 +338,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
)
def test_aggregation_redactions(self):
"""Test that annotations get correctly aggregated after a redaction.
"""
"""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)
@ -379,8 +372,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
)
def test_aggregation_must_be_annotation(self):
"""Test that aggregations must be annotations.
"""
"""Test that aggregations must be annotations."""
channel = self.make_request(
"GET",
@ -437,8 +429,7 @@ class RelationsTestCase(unittest.HomeserverTestCase):
)
def test_edit(self):
"""Test that a simple edit works.
"""
"""Test that a simple edit works."""
new_body = {"msgtype": "m.text", "body": "I've been edited!"}
channel = self._send_relation(

23
tests/rest/client/v2_alpha/test_sync.py
View file

@ -388,13 +388,19 @@ class UnreadMessagesTestCase(unittest.HomeserverTestCase):
# Check that room name changes increase the unread counter.
self.helper.send_state(
self.room_id, "m.room.name", {"name": "my super room"}, tok=self.tok2,
self.room_id,
"m.room.name",
{"name": "my super room"},
tok=self.tok2,
)
self._check_unread_count(1)
# Check that room topic changes increase the unread counter.
self.helper.send_state(
self.room_id, "m.room.topic", {"topic": "welcome!!!"}, tok=self.tok2,
self.room_id,
"m.room.topic",
{"topic": "welcome!!!"},
tok=self.tok2,
)
self._check_unread_count(2)
@ -404,7 +410,10 @@ class UnreadMessagesTestCase(unittest.HomeserverTestCase):
# Check that custom events with a body increase the unread counter.
self.helper.send_event(
self.room_id, "org.matrix.custom_type", {"body": "hello"}, tok=self.tok2,
self.room_id,
"org.matrix.custom_type",
{"body": "hello"},
tok=self.tok2,
)
self._check_unread_count(4)
@ -443,14 +452,18 @@ class UnreadMessagesTestCase(unittest.HomeserverTestCase):
"""Syncs and compares the unread count with the expected value."""
channel = self.make_request(
"GET", self.url % self.next_batch, access_token=self.tok,
"GET",
self.url % self.next_batch,
access_token=self.tok,
)
self.assertEqual(channel.code, 200, channel.json_body)
room_entry = channel.json_body["rooms"]["join"][self.room_id]
self.assertEqual(
room_entry["org.matrix.msc2654.unread_count"], expected_count, room_entry,
room_entry["org.matrix.msc2654.unread_count"],
expected_count,
room_entry,
)
# Store the next batch for the next request.

16
tests/rest/client/v2_alpha/test_upgrade_room.py
View file

@ -85,7 +85,9 @@ class UpgradeRoomTest(unittest.HomeserverTestCase):
# Increase the power levels so that this user can upgrade.
power_levels = self.helper.get_state(
self.room_id, "m.room.power_levels", tok=self.creator_token,
self.room_id,
"m.room.power_levels",
tok=self.creator_token,
)
power_levels["users"][self.other] = 100
self.helper.send_state(
@ -109,7 +111,9 @@ class UpgradeRoomTest(unittest.HomeserverTestCase):
# Increase the power levels so that this user can upgrade.
power_levels = self.helper.get_state(
self.room_id, "m.room.power_levels", tok=self.creator_token,
self.room_id,
"m.room.power_levels",
tok=self.creator_token,
)
power_levels["users_default"] = 100
self.helper.send_state(
@ -133,7 +137,9 @@ class UpgradeRoomTest(unittest.HomeserverTestCase):
# Increase the power levels so that this user can upgrade.
power_levels = self.helper.get_state(
self.room_id, "m.room.power_levels", tok=self.creator_token,
self.room_id,
"m.room.power_levels",
tok=self.creator_token,
)
power_levels["events"]["m.room.tombstone"] = 0
self.helper.send_state(
@ -148,6 +154,8 @@ class UpgradeRoomTest(unittest.HomeserverTestCase):
self.assertEquals(200, channel.code, channel.result)
power_levels = self.helper.get_state(
self.room_id, "m.room.power_levels", tok=self.creator_token,
self.room_id,
"m.room.power_levels",
tok=self.creator_token,
)
self.assertNotIn(self.other, power_levels["users"])

7
tests/rest/key/v2/test_remote_key_resource.py
View file

@ -180,7 +180,8 @@ class EndToEndPerspectivesTests(BaseRemoteKeyResourceTestCase):
async def post_json(destination, path, data):
self.assertEqual(destination, self.hs.hostname)
self.assertEqual(
path, "/_matrix/key/v2/query",
path,
"/_matrix/key/v2/query",
)
channel = FakeChannel(self.site, self.reactor)
@ -188,7 +189,9 @@ class EndToEndPerspectivesTests(BaseRemoteKeyResourceTestCase):
req.content = BytesIO(encode_canonical_json(data))
req.requestReceived(
b"POST", path.encode("utf-8"), b"1.1",
b"POST",
path.encode("utf-8"),
b"1.1",
)
channel.await_result()
self.assertEqual(channel.code, 200)

14
tests/rest/media/v1/test_media_storage.py
View file

@ -167,7 +167,16 @@ class _TestImage:
),
),
# an empty file
(_TestImage(b"", b"image/gif", b".gif", None, None, False,),),
(
_TestImage(
b"",
b"image/gif",
b".gif",
None,
None,
False,
),
),
],
)
class MediaRepoTests(unittest.HomeserverTestCase):
@ -469,8 +478,7 @@ class SpamCheckerTestCase(unittest.HomeserverTestCase):
return config
def test_upload_innocent(self):
"""Attempt to upload some innocent data that should be allowed.
"""
"""Attempt to upload some innocent data that should be allowed."""
image_data = unhexlify(
b"89504e470d0a1a0a0000000d4948445200000001000000010806"