diff --git a/tests/rest/client/v1/test_register.py b/tests/rest/client/v1/test_register.py
index f596acb85f..f15fb36213 100644
--- a/tests/rest/client/v1/test_register.py
+++ b/tests/rest/client/v1/test_register.py
@@ -17,26 +17,22 @@ import json
from mock import Mock
-from twisted.internet import defer
+from twisted.test.proto_helpers import MemoryReactorClock
-from synapse.rest.client.v1.register import CreateUserRestServlet
+from synapse.http.server import JsonResource
+from synapse.rest.client.v1.register import register_servlets
+from synapse.util import Clock
from tests import unittest
-from tests.utils import mock_getRawHeaders
+from tests.server import make_request, setup_test_homeserver
class CreateUserServletTestCase(unittest.TestCase):
+ """
+ Tests for CreateUserRestServlet.
+ """
def setUp(self):
- # do the dance to hook up request data to self.request_data
- self.request_data = ""
- self.request = Mock(
- content=Mock(read=Mock(side_effect=lambda: self.request_data)),
- path='/_matrix/client/api/v1/createUser'
- )
- self.request.args = {}
- self.request.requestHeaders.getRawHeaders = mock_getRawHeaders()
-
self.registration_handler = Mock()
self.appservice = Mock(sender="@as:test")
@@ -44,39 +40,49 @@ class CreateUserServletTestCase(unittest.TestCase):
get_app_service_by_token=Mock(return_value=self.appservice)
)
- # do the dance to hook things up to the hs global
- handlers = Mock(
- registration_handler=self.registration_handler,
+ handlers = Mock(registration_handler=self.registration_handler)
+ self.clock = MemoryReactorClock()
+ self.hs_clock = Clock(self.clock)
+
+ self.hs = self.hs = setup_test_homeserver(
+ http_client=None, clock=self.hs_clock, reactor=self.clock
)
- self.hs = Mock()
- self.hs.hostname = "superbig~testing~thing.com"
self.hs.get_datastore = Mock(return_value=self.datastore)
self.hs.get_handlers = Mock(return_value=handlers)
- self.servlet = CreateUserRestServlet(self.hs)
- @defer.inlineCallbacks
def test_POST_createuser_with_valid_user(self):
+
+ res = JsonResource(self.hs)
+ register_servlets(self.hs, res)
+
+ request_data = json.dumps(
+ {
+ "localpart": "someone",
+ "displayname": "someone interesting",
+ "duration_seconds": 200,
+ }
+ )
+
+ url = b'/_matrix/client/api/v1/createUser?access_token=i_am_an_app_service'
+
user_id = "@someone:interesting"
token = "my token"
- self.request.args = {
- "access_token": "i_am_an_app_service"
- }
- self.request_data = json.dumps({
- "localpart": "someone",
- "displayname": "someone interesting",
- "duration_seconds": 200
- })
self.registration_handler.get_or_create_user = Mock(
return_value=(user_id, token)
)
- (code, result) = yield self.servlet.on_POST(self.request)
- self.assertEquals(code, 200)
+ request, channel = make_request(b"POST", url, request_data)
+ request.render(res)
+
+ # Advance the clock because it waits
+ self.clock.advance(1)
+
+ self.assertEquals(channel.result["code"], b"200")
det_data = {
"user_id": user_id,
"access_token": token,
- "home_server": self.hs.hostname
+ "home_server": self.hs.hostname,
}
- self.assertDictContainsSubset(det_data, result)
+ self.assertDictContainsSubset(det_data, json.loads(channel.result["body"]))
diff --git a/tests/rest/client/v1/test_rooms.py b/tests/rest/client/v1/test_rooms.py
index 895dffa095..6b5764095e 100644
--- a/tests/rest/client/v1/test_rooms.py
+++ b/tests/rest/client/v1/test_rooms.py
@@ -25,949 +25,772 @@ from twisted.internet import defer
import synapse.rest.client.v1.room
from synapse.api.constants import Membership
+from synapse.http.server import JsonResource
from synapse.types import UserID
+from synapse.util import Clock
-from ....utils import MockHttpResource, setup_test_homeserver
-from .utils import RestTestCase
+from tests import unittest
+from tests.server import (
+ ThreadedMemoryReactorClock,
+ make_request,
+ render,
+ setup_test_homeserver,
+)
-PATH_PREFIX = "/_matrix/client/api/v1"
+from .utils import RestHelper
+PATH_PREFIX = b"/_matrix/client/api/v1"
-class RoomPermissionsTestCase(RestTestCase):
- """ Tests room permissions. """
- user_id = "@sid1:red"
- rmcreator_id = "@notme:red"
- @defer.inlineCallbacks
+class RoomBase(unittest.TestCase):
+ rmcreator_id = None
+
def setUp(self):
- self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
- hs = yield setup_test_homeserver(
+ self.clock = ThreadedMemoryReactorClock()
+ self.hs_clock = Clock(self.clock)
+
+ self.hs = setup_test_homeserver(
"red",
http_client=None,
+ clock=self.hs_clock,
+ reactor=self.clock,
federation_client=Mock(),
ratelimiter=NonCallableMock(spec_set=["send_message"]),
)
- self.ratelimiter = hs.get_ratelimiter()
+ self.ratelimiter = self.hs.get_ratelimiter()
self.ratelimiter.send_message.return_value = (True, 0)
- hs.get_handlers().federation_handler = Mock()
+ self.hs.get_federation_handler = Mock(return_value=Mock())
def get_user_by_access_token(token=None, allow_guest=False):
return {
- "user": UserID.from_string(self.auth_user_id),
+ "user": UserID.from_string(self.helper.auth_user_id),
"token_id": 1,
"is_guest": False,
}
- hs.get_auth().get_user_by_access_token = get_user_by_access_token
+
+ def get_user_by_req(request, allow_guest=False, rights="access"):
+ return synapse.types.create_requester(
+ UserID.from_string(self.helper.auth_user_id), 1, False, None
+ )
+
+ self.hs.get_auth().get_user_by_req = get_user_by_req
+ self.hs.get_auth().get_user_by_access_token = get_user_by_access_token
+ self.hs.get_auth().get_access_token_from_request = Mock(return_value=b"1234")
def _insert_client_ip(*args, **kwargs):
return defer.succeed(None)
- hs.get_datastore().insert_client_ip = _insert_client_ip
- self.auth_user_id = self.rmcreator_id
+ self.hs.get_datastore().insert_client_ip = _insert_client_ip
- synapse.rest.client.v1.room.register_servlets(hs, self.mock_resource)
+ self.resource = JsonResource(self.hs)
+ synapse.rest.client.v1.room.register_servlets(self.hs, self.resource)
+ self.helper = RestHelper(self.hs, self.resource, self.user_id)
- self.auth = hs.get_auth()
- # create some rooms under the name rmcreator_id
- self.uncreated_rmid = "!aa:test"
+class RoomPermissionsTestCase(RoomBase):
+ """ Tests room permissions. """
- self.created_rmid = yield self.create_room_as(self.rmcreator_id,
- is_public=False)
+ user_id = b"@sid1:red"
+ rmcreator_id = b"@notme:red"
+
+ def setUp(self):
- self.created_public_rmid = yield self.create_room_as(self.rmcreator_id,
- is_public=True)
+ super(RoomPermissionsTestCase, self).setUp()
+
+ self.helper.auth_user_id = self.rmcreator_id
+ # create some rooms under the name rmcreator_id
+ self.uncreated_rmid = "!aa:test"
+ self.created_rmid = self.helper.create_room_as(
+ self.rmcreator_id, is_public=False
+ )
+ self.created_public_rmid = self.helper.create_room_as(
+ self.rmcreator_id, is_public=True
+ )
# send a message in one of the rooms
self.created_rmid_msg_path = (
- "/rooms/%s/send/m.room.message/a1" % (self.created_rmid)
- )
- (code, response) = yield self.mock_resource.trigger(
- "PUT",
+ "rooms/%s/send/m.room.message/a1" % (self.created_rmid)
+ ).encode('ascii')
+ request, channel = make_request(
+ b"PUT",
self.created_rmid_msg_path,
- '{"msgtype":"m.text","body":"test msg"}'
+ b'{"msgtype":"m.text","body":"test msg"}',
)
- self.assertEquals(200, code, msg=str(response))
+ render(request, self.resource, self.clock)
+ self.assertEquals(channel.result["code"], b"200", channel.result)
# set topic for public room
- (code, response) = yield self.mock_resource.trigger(
- "PUT",
- "/rooms/%s/state/m.room.topic" % self.created_public_rmid,
- '{"topic":"Public Room Topic"}'
+ request, channel = make_request(
+ b"PUT",
+ ("rooms/%s/state/m.room.topic" % self.created_public_rmid).encode('ascii'),
+ b'{"topic":"Public Room Topic"}',
)
- self.assertEquals(200, code, msg=str(response))
+ render(request, self.resource, self.clock)
+ self.assertEquals(channel.result["code"], b"200", channel.result)
# auth as user_id now
- self.auth_user_id = self.user_id
-
- def tearDown(self):
- pass
+ self.helper.auth_user_id = self.user_id
- @defer.inlineCallbacks
def test_send_message(self):
- msg_content = '{"msgtype":"m.text","body":"hello"}'
- send_msg_path = (
- "/rooms/%s/send/m.room.message/mid1" % (self.created_rmid,)
- )
+ msg_content = b'{"msgtype":"m.text","body":"hello"}'
+
+ seq = iter(range(100))
+
+ def send_msg_path():
+ return b"/rooms/%s/send/m.room.message/mid%s" % (
+ self.created_rmid,
+ str(next(seq)).encode('ascii'),
+ )
# send message in uncreated room, expect 403
- (code, response) = yield self.mock_resource.trigger(
- "PUT",
- "/rooms/%s/send/m.room.message/mid2" % (self.uncreated_rmid,),
- msg_content
+ request, channel = make_request(
+ b"PUT",
+ b"/rooms/%s/send/m.room.message/mid2" % (self.uncreated_rmid,),
+ msg_content,
)
- self.assertEquals(403, code, msg=str(response))
+ render(request, self.resource, self.clock)
+ self.assertEquals(403, int(channel.result["code"]), msg=channel.result["body"])
# send message in created room not joined (no state), expect 403
- (code, response) = yield self.mock_resource.trigger(
- "PUT",
- send_msg_path,
- msg_content
- )
- self.assertEquals(403, code, msg=str(response))
+ request, channel = make_request(b"PUT", send_msg_path(), msg_content)
+ render(request, self.resource, self.clock)
+ self.assertEquals(403, int(channel.result["code"]), msg=channel.result["body"])
# send message in created room and invited, expect 403
- yield self.invite(
- room=self.created_rmid,
- src=self.rmcreator_id,
- targ=self.user_id
- )
- (code, response) = yield self.mock_resource.trigger(
- "PUT",
- send_msg_path,
- msg_content
+ self.helper.invite(
+ room=self.created_rmid, src=self.rmcreator_id, targ=self.user_id
)
- self.assertEquals(403, code, msg=str(response))
+ request, channel = make_request(b"PUT", send_msg_path(), msg_content)
+ render(request, self.resource, self.clock)
+ self.assertEquals(403, int(channel.result["code"]), msg=channel.result["body"])
# send message in created room and joined, expect 200
- yield self.join(room=self.created_rmid, user=self.user_id)
- (code, response) = yield self.mock_resource.trigger(
- "PUT",
- send_msg_path,
- msg_content
- )
- self.assertEquals(200, code, msg=str(response))
+ self.helper.join(room=self.created_rmid, user=self.user_id)
+ request, channel = make_request(b"PUT", send_msg_path(), msg_content)
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]), msg=channel.result["body"])
# send message in created room and left, expect 403
- yield self.leave(room=self.created_rmid, user=self.user_id)
- (code, response) = yield self.mock_resource.trigger(
- "PUT",
- send_msg_path,
- msg_content
- )
- self.assertEquals(403, code, msg=str(response))
+ self.helper.leave(room=self.created_rmid, user=self.user_id)
+ request, channel = make_request(b"PUT", send_msg_path(), msg_content)
+ render(request, self.resource, self.clock)
+ self.assertEquals(403, int(channel.result["code"]), msg=channel.result["body"])
- @defer.inlineCallbacks
def test_topic_perms(self):
- topic_content = '{"topic":"My Topic Name"}'
- topic_path = "/rooms/%s/state/m.room.topic" % self.created_rmid
+ topic_content = b'{"topic":"My Topic Name"}'
+ topic_path = b"/rooms/%s/state/m.room.topic" % self.created_rmid
# set/get topic in uncreated room, expect 403
- (code, response) = yield self.mock_resource.trigger(
- "PUT", "/rooms/%s/state/m.room.topic" % self.uncreated_rmid,
- topic_content
+ request, channel = make_request(
+ b"PUT", b"/rooms/%s/state/m.room.topic" % self.uncreated_rmid, topic_content
)
- self.assertEquals(403, code, msg=str(response))
- (code, response) = yield self.mock_resource.trigger_get(
- "/rooms/%s/state/m.room.topic" % self.uncreated_rmid
+ render(request, self.resource, self.clock)
+ self.assertEquals(403, int(channel.result["code"]), msg=channel.result["body"])
+ request, channel = make_request(
+ b"GET", "/rooms/%s/state/m.room.topic" % self.uncreated_rmid
)
- self.assertEquals(403, code, msg=str(response))
+ render(request, self.resource, self.clock)
+ self.assertEquals(403, int(channel.result["code"]), msg=channel.result["body"])
# set/get topic in created PRIVATE room not joined, expect 403
- (code, response) = yield self.mock_resource.trigger(
- "PUT", topic_path, topic_content
- )
- self.assertEquals(403, code, msg=str(response))
- (code, response) = yield self.mock_resource.trigger_get(topic_path)
- self.assertEquals(403, code, msg=str(response))
+ request, channel = make_request(b"PUT", topic_path, topic_content)
+ render(request, self.resource, self.clock)
+ self.assertEquals(403, int(channel.result["code"]), msg=channel.result["body"])
+ request, channel = make_request(b"GET", topic_path)
+ render(request, self.resource, self.clock)
+ self.assertEquals(403, int(channel.result["code"]), msg=channel.result["body"])
# set topic in created PRIVATE room and invited, expect 403
- yield self.invite(
+ self.helper.invite(
room=self.created_rmid, src=self.rmcreator_id, targ=self.user_id
)
- (code, response) = yield self.mock_resource.trigger(
- "PUT", topic_path, topic_content
- )
- self.assertEquals(403, code, msg=str(response))
+ request, channel = make_request(b"PUT", topic_path, topic_content)
+ render(request, self.resource, self.clock)
+ self.assertEquals(403, int(channel.result["code"]), msg=channel.result["body"])
# get topic in created PRIVATE room and invited, expect 403
- (code, response) = yield self.mock_resource.trigger_get(topic_path)
- self.assertEquals(403, code, msg=str(response))
+ request, channel = make_request(b"GET", topic_path)
+ render(request, self.resource, self.clock)
+ self.assertEquals(403, int(channel.result["code"]), msg=channel.result["body"])
# set/get topic in created PRIVATE room and joined, expect 200
- yield self.join(room=self.created_rmid, user=self.user_id)
+ self.helper.join(room=self.created_rmid, user=self.user_id)
# Only room ops can set topic by default
- self.auth_user_id = self.rmcreator_id
- (code, response) = yield self.mock_resource.trigger(
- "PUT", topic_path, topic_content
- )
- self.assertEquals(200, code, msg=str(response))
- self.auth_user_id = self.user_id
+ self.helper.auth_user_id = self.rmcreator_id
+ request, channel = make_request(b"PUT", topic_path, topic_content)
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]), msg=channel.result["body"])
+ self.helper.auth_user_id = self.user_id
- (code, response) = yield self.mock_resource.trigger_get(topic_path)
- self.assertEquals(200, code, msg=str(response))
- self.assert_dict(json.loads(topic_content), response)
+ request, channel = make_request(b"GET", topic_path)
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]), msg=channel.result["body"])
+ self.assert_dict(json.loads(topic_content), channel.json_body)
# set/get topic in created PRIVATE room and left, expect 403
- yield self.leave(room=self.created_rmid, user=self.user_id)
- (code, response) = yield self.mock_resource.trigger(
- "PUT", topic_path, topic_content
- )
- self.assertEquals(403, code, msg=str(response))
- (code, response) = yield self.mock_resource.trigger_get(topic_path)
- self.assertEquals(200, code, msg=str(response))
+ self.helper.leave(room=self.created_rmid, user=self.user_id)
+ request, channel = make_request(b"PUT", topic_path, topic_content)
+ render(request, self.resource, self.clock)
+ self.assertEquals(403, int(channel.result["code"]), msg=channel.result["body"])
+ request, channel = make_request(b"GET", topic_path)
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]), msg=channel.result["body"])
# get topic in PUBLIC room, not joined, expect 403
- (code, response) = yield self.mock_resource.trigger_get(
- "/rooms/%s/state/m.room.topic" % self.created_public_rmid
+ request, channel = make_request(
+ b"GET", b"/rooms/%s/state/m.room.topic" % self.created_public_rmid
)
- self.assertEquals(403, code, msg=str(response))
+ render(request, self.resource, self.clock)
+ self.assertEquals(403, int(channel.result["code"]), msg=channel.result["body"])
# set topic in PUBLIC room, not joined, expect 403
- (code, response) = yield self.mock_resource.trigger(
- "PUT",
- "/rooms/%s/state/m.room.topic" % self.created_public_rmid,
- topic_content
+ request, channel = make_request(
+ b"PUT",
+ b"/rooms/%s/state/m.room.topic" % self.created_public_rmid,
+ topic_content,
)
- self.assertEquals(403, code, msg=str(response))
+ render(request, self.resource, self.clock)
+ self.assertEquals(403, int(channel.result["code"]), msg=channel.result["body"])
- @defer.inlineCallbacks
def _test_get_membership(self, room=None, members=[], expect_code=None):
for member in members:
- path = "/rooms/%s/state/m.room.member/%s" % (room, member)
- (code, response) = yield self.mock_resource.trigger_get(path)
- self.assertEquals(expect_code, code)
+ path = b"/rooms/%s/state/m.room.member/%s" % (room, member)
+ request, channel = make_request(b"GET", path)
+ render(request, self.resource, self.clock)
+ self.assertEquals(expect_code, int(channel.result["code"]))
- @defer.inlineCallbacks
def test_membership_basic_room_perms(self):
# === room does not exist ===
room = self.uncreated_rmid
# get membership of self, get membership of other, uncreated room
# expect all 403s
- yield self._test_get_membership(
- members=[self.user_id, self.rmcreator_id],
- room=room, expect_code=403)
+ self._test_get_membership(
+ members=[self.user_id, self.rmcreator_id], room=room, expect_code=403
+ )
# trying to invite people to this room should 403
- yield self.invite(room=room, src=self.user_id, targ=self.rmcreator_id,
- expect_code=403)
+ self.helper.invite(
+ room=room, src=self.user_id, targ=self.rmcreator_id, expect_code=403
+ )
# set [invite/join/left] of self, set [invite/join/left] of other,
# expect all 404s because room doesn't exist on any server
for usr in [self.user_id, self.rmcreator_id]:
- yield self.join(room=room, user=usr, expect_code=404)
- yield self.leave(room=room, user=usr, expect_code=404)
+ self.helper.join(room=room, user=usr, expect_code=404)
+ self.helper.leave(room=room, user=usr, expect_code=404)
- @defer.inlineCallbacks
def test_membership_private_room_perms(self):
room = self.created_rmid
# get membership of self, get membership of other, private room + invite
# expect all 403s
- yield self.invite(room=room, src=self.rmcreator_id,
- targ=self.user_id)
- yield self._test_get_membership(
- members=[self.user_id, self.rmcreator_id],
- room=room, expect_code=403)
+ self.helper.invite(room=room, src=self.rmcreator_id, targ=self.user_id)
+ self._test_get_membership(
+ members=[self.user_id, self.rmcreator_id], room=room, expect_code=403
+ )
# get membership of self, get membership of other, private room + joined
# expect all 200s
- yield self.join(room=room, user=self.user_id)
- yield self._test_get_membership(
- members=[self.user_id, self.rmcreator_id],
- room=room, expect_code=200)
+ self.helper.join(room=room, user=self.user_id)
+ self._test_get_membership(
+ members=[self.user_id, self.rmcreator_id], room=room, expect_code=200
+ )
# get membership of self, get membership of other, private room + left
# expect all 200s
- yield self.leave(room=room, user=self.user_id)
- yield self._test_get_membership(
- members=[self.user_id, self.rmcreator_id],
- room=room, expect_code=200)
+ self.helper.leave(room=room, user=self.user_id)
+ self._test_get_membership(
+ members=[self.user_id, self.rmcreator_id], room=room, expect_code=200
+ )
- @defer.inlineCallbacks
def test_membership_public_room_perms(self):
room = self.created_public_rmid
# get membership of self, get membership of other, public room + invite
# expect 403
- yield self.invite(room=room, src=self.rmcreator_id,
- targ=self.user_id)
- yield self._test_get_membership(
- members=[self.user_id, self.rmcreator_id],
- room=room, expect_code=403)
+ self.helper.invite(room=room, src=self.rmcreator_id, targ=self.user_id)
+ self._test_get_membership(
+ members=[self.user_id, self.rmcreator_id], room=room, expect_code=403
+ )
# get membership of self, get membership of other, public room + joined
# expect all 200s
- yield self.join(room=room, user=self.user_id)
- yield self._test_get_membership(
- members=[self.user_id, self.rmcreator_id],
- room=room, expect_code=200)
+ self.helper.join(room=room, user=self.user_id)
+ self._test_get_membership(
+ members=[self.user_id, self.rmcreator_id], room=room, expect_code=200
+ )
# get membership of self, get membership of other, public room + left
# expect 200.
- yield self.leave(room=room, user=self.user_id)
- yield self._test_get_membership(
- members=[self.user_id, self.rmcreator_id],
- room=room, expect_code=200)
+ self.helper.leave(room=room, user=self.user_id)
+ self._test_get_membership(
+ members=[self.user_id, self.rmcreator_id], room=room, expect_code=200
+ )
- @defer.inlineCallbacks
def test_invited_permissions(self):
room = self.created_rmid
- yield self.invite(room=room, src=self.rmcreator_id, targ=self.user_id)
+ self.helper.invite(room=room, src=self.rmcreator_id, targ=self.user_id)
# set [invite/join/left] of other user, expect 403s
- yield self.invite(room=room, src=self.user_id, targ=self.rmcreator_id,
- expect_code=403)
- yield self.change_membership(room=room, src=self.user_id,
- targ=self.rmcreator_id,
- membership=Membership.JOIN,
- expect_code=403)
- yield self.change_membership(room=room, src=self.user_id,
- targ=self.rmcreator_id,
- membership=Membership.LEAVE,
- expect_code=403)
-
- @defer.inlineCallbacks
+ self.helper.invite(
+ room=room, src=self.user_id, targ=self.rmcreator_id, expect_code=403
+ )
+ self.helper.change_membership(
+ room=room,
+ src=self.user_id,
+ targ=self.rmcreator_id,
+ membership=Membership.JOIN,
+ expect_code=403,
+ )
+ self.helper.change_membership(
+ room=room,
+ src=self.user_id,
+ targ=self.rmcreator_id,
+ membership=Membership.LEAVE,
+ expect_code=403,
+ )
+
def test_joined_permissions(self):
room = self.created_rmid
- yield self.invite(room=room, src=self.rmcreator_id, targ=self.user_id)
- yield self.join(room=room, user=self.user_id)
+ self.helper.invite(room=room, src=self.rmcreator_id, targ=self.user_id)
+ self.helper.join(room=room, user=self.user_id)
# set invited of self, expect 403
- yield self.invite(room=room, src=self.user_id, targ=self.user_id,
- expect_code=403)
+ self.helper.invite(
+ room=room, src=self.user_id, targ=self.user_id, expect_code=403
+ )
# set joined of self, expect 200 (NOOP)
- yield self.join(room=room, user=self.user_id)
+ self.helper.join(room=room, user=self.user_id)
other = "@burgundy:red"
# set invited of other, expect 200
- yield self.invite(room=room, src=self.user_id, targ=other,
- expect_code=200)
+ self.helper.invite(room=room, src=self.user_id, targ=other, expect_code=200)
# set joined of other, expect 403
- yield self.change_membership(room=room, src=self.user_id,
- targ=other,
- membership=Membership.JOIN,
- expect_code=403)
+ self.helper.change_membership(
+ room=room,
+ src=self.user_id,
+ targ=other,
+ membership=Membership.JOIN,
+ expect_code=403,
+ )
# set left of other, expect 403
- yield self.change_membership(room=room, src=self.user_id,
- targ=other,
- membership=Membership.LEAVE,
- expect_code=403)
+ self.helper.change_membership(
+ room=room,
+ src=self.user_id,
+ targ=other,
+ membership=Membership.LEAVE,
+ expect_code=403,
+ )
# set left of self, expect 200
- yield self.leave(room=room, user=self.user_id)
+ self.helper.leave(room=room, user=self.user_id)
- @defer.inlineCallbacks
def test_leave_permissions(self):
room = self.created_rmid
- yield self.invite(room=room, src=self.rmcreator_id, targ=self.user_id)
- yield self.join(room=room, user=self.user_id)
- yield self.leave(room=room, user=self.user_id)
+ self.helper.invite(room=room, src=self.rmcreator_id, targ=self.user_id)
+ self.helper.join(room=room, user=self.user_id)
+ self.helper.leave(room=room, user=self.user_id)
# set [invite/join/left] of self, set [invite/join/left] of other,
# expect all 403s
for usr in [self.user_id, self.rmcreator_id]:
- yield self.change_membership(
+ self.helper.change_membership(
room=room,
src=self.user_id,
targ=usr,
membership=Membership.INVITE,
- expect_code=403
+ expect_code=403,
)
- yield self.change_membership(
+ self.helper.change_membership(
room=room,
src=self.user_id,
targ=usr,
membership=Membership.JOIN,
- expect_code=403
+ expect_code=403,
)
# It is always valid to LEAVE if you've already left (currently.)
- yield self.change_membership(
+ self.helper.change_membership(
room=room,
src=self.user_id,
targ=self.rmcreator_id,
membership=Membership.LEAVE,
- expect_code=403
+ expect_code=403,
)
-class RoomsMemberListTestCase(RestTestCase):
+class RoomsMemberListTestCase(RoomBase):
""" Tests /rooms/$room_id/members/list REST events."""
- user_id = "@sid1:red"
-
- @defer.inlineCallbacks
- def setUp(self):
- self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
-
- hs = yield setup_test_homeserver(
- "red",
- http_client=None,
- federation_client=Mock(),
- ratelimiter=NonCallableMock(spec_set=["send_message"]),
- )
- self.ratelimiter = hs.get_ratelimiter()
- self.ratelimiter.send_message.return_value = (True, 0)
-
- hs.get_handlers().federation_handler = Mock()
-
- self.auth_user_id = self.user_id
-
- def get_user_by_access_token(token=None, allow_guest=False):
- return {
- "user": UserID.from_string(self.auth_user_id),
- "token_id": 1,
- "is_guest": False,
- }
- hs.get_auth().get_user_by_access_token = get_user_by_access_token
-
- def _insert_client_ip(*args, **kwargs):
- return defer.succeed(None)
- hs.get_datastore().insert_client_ip = _insert_client_ip
- synapse.rest.client.v1.room.register_servlets(hs, self.mock_resource)
+ user_id = b"@sid1:red"
- def tearDown(self):
- pass
-
- @defer.inlineCallbacks
def test_get_member_list(self):
- room_id = yield self.create_room_as(self.user_id)
- (code, response) = yield self.mock_resource.trigger_get(
- "/rooms/%s/members" % room_id
- )
- self.assertEquals(200, code, msg=str(response))
+ room_id = self.helper.create_room_as(self.user_id)
+ request, channel = make_request(b"GET", b"/rooms/%s/members" % room_id)
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]), msg=channel.result["body"])
- @defer.inlineCallbacks
def test_get_member_list_no_room(self):
- (code, response) = yield self.mock_resource.trigger_get(
- "/rooms/roomdoesnotexist/members"
- )
- self.assertEquals(403, code, msg=str(response))
+ request, channel = make_request(b"GET", b"/rooms/roomdoesnotexist/members")
+ render(request, self.resource, self.clock)
+ self.assertEquals(403, int(channel.result["code"]), msg=channel.result["body"])
- @defer.inlineCallbacks
def test_get_member_list_no_permission(self):
- room_id = yield self.create_room_as("@some_other_guy:red")
- (code, response) = yield self.mock_resource.trigger_get(
- "/rooms/%s/members" % room_id
- )
- self.assertEquals(403, code, msg=str(response))
+ room_id = self.helper.create_room_as(b"@some_other_guy:red")
+ request, channel = make_request(b"GET", b"/rooms/%s/members" % room_id)
+ render(request, self.resource, self.clock)
+ self.assertEquals(403, int(channel.result["code"]), msg=channel.result["body"])
- @defer.inlineCallbacks
def test_get_member_list_mixed_memberships(self):
- room_creator = "@some_other_guy:red"
- room_id = yield self.create_room_as(room_creator)
- room_path = "/rooms/%s/members" % room_id
- yield self.invite(room=room_id, src=room_creator,
- targ=self.user_id)
+ room_creator = b"@some_other_guy:red"
+ room_id = self.helper.create_room_as(room_creator)
+ room_path = b"/rooms/%s/members" % room_id
+ self.helper.invite(room=room_id, src=room_creator, targ=self.user_id)
# can't see list if you're just invited.
- (code, response) = yield self.mock_resource.trigger_get(room_path)
- self.assertEquals(403, code, msg=str(response))
+ request, channel = make_request(b"GET", room_path)
+ render(request, self.resource, self.clock)
+ self.assertEquals(403, int(channel.result["code"]), msg=channel.result["body"])
- yield self.join(room=room_id, user=self.user_id)
+ self.helper.join(room=room_id, user=self.user_id)
# can see list now joined
- (code, response) = yield self.mock_resource.trigger_get(room_path)
- self.assertEquals(200, code, msg=str(response))
+ request, channel = make_request(b"GET", room_path)
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]), msg=channel.result["body"])
- yield self.leave(room=room_id, user=self.user_id)
+ self.helper.leave(room=room_id, user=self.user_id)
# can see old list once left
- (code, response) = yield self.mock_resource.trigger_get(room_path)
- self.assertEquals(200, code, msg=str(response))
+ request, channel = make_request(b"GET", room_path)
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]), msg=channel.result["body"])
-class RoomsCreateTestCase(RestTestCase):
+class RoomsCreateTestCase(RoomBase):
""" Tests /rooms and /rooms/$room_id REST events. """
- user_id = "@sid1:red"
-
- @defer.inlineCallbacks
- def setUp(self):
- self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
- self.auth_user_id = self.user_id
- hs = yield setup_test_homeserver(
- "red",
- http_client=None,
- federation_client=Mock(),
- ratelimiter=NonCallableMock(spec_set=["send_message"]),
- )
- self.ratelimiter = hs.get_ratelimiter()
- self.ratelimiter.send_message.return_value = (True, 0)
-
- hs.get_handlers().federation_handler = Mock()
-
- def get_user_by_access_token(token=None, allow_guest=False):
- return {
- "user": UserID.from_string(self.auth_user_id),
- "token_id": 1,
- "is_guest": False,
- }
- hs.get_auth().get_user_by_access_token = get_user_by_access_token
-
- def _insert_client_ip(*args, **kwargs):
- return defer.succeed(None)
- hs.get_datastore().insert_client_ip = _insert_client_ip
-
- synapse.rest.client.v1.room.register_servlets(hs, self.mock_resource)
+ user_id = b"@sid1:red"
- @defer.inlineCallbacks
def test_post_room_no_keys(self):
# POST with no config keys, expect new room id
- (code, response) = yield self.mock_resource.trigger("POST",
- "/createRoom",
- "{}")
- self.assertEquals(200, code, response)
- self.assertTrue("room_id" in response)
+ request, channel = make_request(b"POST", b"/createRoom", b"{}")
+
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]), channel.result)
+ self.assertTrue("room_id" in channel.json_body)
- @defer.inlineCallbacks
def test_post_room_visibility_key(self):
# POST with visibility config key, expect new room id
- (code, response) = yield self.mock_resource.trigger(
- "POST",
- "/createRoom",
- '{"visibility":"private"}')
- self.assertEquals(200, code)
- self.assertTrue("room_id" in response)
-
- @defer.inlineCallbacks
+ request, channel = make_request(
+ b"POST", b"/createRoom", b'{"visibility":"private"}'
+ )
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]))
+ self.assertTrue("room_id" in channel.json_body)
+
def test_post_room_custom_key(self):
# POST with custom config keys, expect new room id
- (code, response) = yield self.mock_resource.trigger(
- "POST",
- "/createRoom",
- '{"custom":"stuff"}')
- self.assertEquals(200, code)
- self.assertTrue("room_id" in response)
-
- @defer.inlineCallbacks
+ request, channel = make_request(b"POST", b"/createRoom", b'{"custom":"stuff"}')
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]))
+ self.assertTrue("room_id" in channel.json_body)
+
def test_post_room_known_and_unknown_keys(self):
# POST with custom + known config keys, expect new room id
- (code, response) = yield self.mock_resource.trigger(
- "POST",
- "/createRoom",
- '{"visibility":"private","custom":"things"}')
- self.assertEquals(200, code)
- self.assertTrue("room_id" in response)
-
- @defer.inlineCallbacks
+ request, channel = make_request(
+ b"POST", b"/createRoom", b'{"visibility":"private","custom":"things"}'
+ )
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]))
+ self.assertTrue("room_id" in channel.json_body)
+
def test_post_room_invalid_content(self):
# POST with invalid content / paths, expect 400
- (code, response) = yield self.mock_resource.trigger(
- "POST",
- "/createRoom",
- '{"visibili')
- self.assertEquals(400, code)
+ request, channel = make_request(b"POST", b"/createRoom", b'{"visibili')
+ render(request, self.resource, self.clock)
+ self.assertEquals(400, int(channel.result["code"]))
- (code, response) = yield self.mock_resource.trigger(
- "POST",
- "/createRoom",
- '["hello"]')
- self.assertEquals(400, code)
+ request, channel = make_request(b"POST", b"/createRoom", b'["hello"]')
+ render(request, self.resource, self.clock)
+ self.assertEquals(400, int(channel.result["code"]))
-class RoomTopicTestCase(RestTestCase):
+class RoomTopicTestCase(RoomBase):
""" Tests /rooms/$room_id/topic REST events. """
- user_id = "@sid1:red"
- @defer.inlineCallbacks
- def setUp(self):
- self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
- self.auth_user_id = self.user_id
+ user_id = b"@sid1:red"
- hs = yield setup_test_homeserver(
- "red",
- http_client=None,
- federation_client=Mock(),
- ratelimiter=NonCallableMock(spec_set=["send_message"]),
- )
- self.ratelimiter = hs.get_ratelimiter()
- self.ratelimiter.send_message.return_value = (True, 0)
-
- hs.get_handlers().federation_handler = Mock()
-
- def get_user_by_access_token(token=None, allow_guest=False):
- return {
- "user": UserID.from_string(self.auth_user_id),
- "token_id": 1,
- "is_guest": False,
- }
-
- hs.get_auth().get_user_by_access_token = get_user_by_access_token
-
- def _insert_client_ip(*args, **kwargs):
- return defer.succeed(None)
- hs.get_datastore().insert_client_ip = _insert_client_ip
+ def setUp(self):
- synapse.rest.client.v1.room.register_servlets(hs, self.mock_resource)
+ super(RoomTopicTestCase, self).setUp()
# create the room
- self.room_id = yield self.create_room_as(self.user_id)
- self.path = "/rooms/%s/state/m.room.topic" % (self.room_id,)
-
- def tearDown(self):
- pass
+ self.room_id = self.helper.create_room_as(self.user_id)
+ self.path = b"/rooms/%s/state/m.room.topic" % (self.room_id,)
- @defer.inlineCallbacks
def test_invalid_puts(self):
# missing keys or invalid json
- (code, response) = yield self.mock_resource.trigger(
- "PUT", self.path, '{}'
- )
- self.assertEquals(400, code, msg=str(response))
+ request, channel = make_request(b"PUT", self.path, '{}')
+ render(request, self.resource, self.clock)
+ self.assertEquals(400, int(channel.result["code"]), msg=channel.result["body"])
- (code, response) = yield self.mock_resource.trigger(
- "PUT", self.path, '{"_name":"bob"}'
- )
- self.assertEquals(400, code, msg=str(response))
+ request, channel = make_request(b"PUT", self.path, '{"_name":"bob"}')
+ render(request, self.resource, self.clock)
+ self.assertEquals(400, int(channel.result["code"]), msg=channel.result["body"])
- (code, response) = yield self.mock_resource.trigger(
- "PUT", self.path, '{"nao'
- )
- self.assertEquals(400, code, msg=str(response))
+ request, channel = make_request(b"PUT", self.path, '{"nao')
+ render(request, self.resource, self.clock)
+ self.assertEquals(400, int(channel.result["code"]), msg=channel.result["body"])
- (code, response) = yield self.mock_resource.trigger(
- "PUT", self.path, '[{"_name":"bob"},{"_name":"jill"}]'
+ request, channel = make_request(
+ b"PUT", self.path, '[{"_name":"bob"},{"_name":"jill"}]'
)
- self.assertEquals(400, code, msg=str(response))
+ render(request, self.resource, self.clock)
+ self.assertEquals(400, int(channel.result["code"]), msg=channel.result["body"])
- (code, response) = yield self.mock_resource.trigger(
- "PUT", self.path, 'text only'
- )
- self.assertEquals(400, code, msg=str(response))
+ request, channel = make_request(b"PUT", self.path, 'text only')
+ render(request, self.resource, self.clock)
+ self.assertEquals(400, int(channel.result["code"]), msg=channel.result["body"])
- (code, response) = yield self.mock_resource.trigger(
- "PUT", self.path, ''
- )
- self.assertEquals(400, code, msg=str(response))
+ request, channel = make_request(b"PUT", self.path, '')
+ render(request, self.resource, self.clock)
+ self.assertEquals(400, int(channel.result["code"]), msg=channel.result["body"])
# valid key, wrong type
content = '{"topic":["Topic name"]}'
- (code, response) = yield self.mock_resource.trigger(
- "PUT", self.path, content
- )
- self.assertEquals(400, code, msg=str(response))
+ request, channel = make_request(b"PUT", self.path, content)
+ render(request, self.resource, self.clock)
+ self.assertEquals(400, int(channel.result["code"]), msg=channel.result["body"])
- @defer.inlineCallbacks
def test_rooms_topic(self):
# nothing should be there
- (code, response) = yield self.mock_resource.trigger_get(self.path)
- self.assertEquals(404, code, msg=str(response))
+ request, channel = make_request(b"GET", self.path)
+ render(request, self.resource, self.clock)
+ self.assertEquals(404, int(channel.result["code"]), msg=channel.result["body"])
# valid put
content = '{"topic":"Topic name"}'
- (code, response) = yield self.mock_resource.trigger(
- "PUT", self.path, content
- )
- self.assertEquals(200, code, msg=str(response))
+ request, channel = make_request(b"PUT", self.path, content)
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]), msg=channel.result["body"])
# valid get
- (code, response) = yield self.mock_resource.trigger_get(self.path)
- self.assertEquals(200, code, msg=str(response))
- self.assert_dict(json.loads(content), response)
+ request, channel = make_request(b"GET", self.path)
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]), msg=channel.result["body"])
+ self.assert_dict(json.loads(content), channel.json_body)
- @defer.inlineCallbacks
def test_rooms_topic_with_extra_keys(self):
# valid put with extra keys
content = '{"topic":"Seasons","subtopic":"Summer"}'
- (code, response) = yield self.mock_resource.trigger(
- "PUT", self.path, content
- )
- self.assertEquals(200, code, msg=str(response))
+ request, channel = make_request(b"PUT", self.path, content)
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]), msg=channel.result["body"])
# valid get
- (code, response) = yield self.mock_resource.trigger_get(self.path)
- self.assertEquals(200, code, msg=str(response))
- self.assert_dict(json.loads(content), response)
+ request, channel = make_request(b"GET", self.path)
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]), msg=channel.result["body"])
+ self.assert_dict(json.loads(content), channel.json_body)
-class RoomMemberStateTestCase(RestTestCase):
+class RoomMemberStateTestCase(RoomBase):
""" Tests /rooms/$room_id/members/$user_id/state REST events. """
- user_id = "@sid1:red"
-
- @defer.inlineCallbacks
- def setUp(self):
- self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
- self.auth_user_id = self.user_id
-
- hs = yield setup_test_homeserver(
- "red",
- http_client=None,
- federation_client=Mock(),
- ratelimiter=NonCallableMock(spec_set=["send_message"]),
- )
- self.ratelimiter = hs.get_ratelimiter()
- self.ratelimiter.send_message.return_value = (True, 0)
- hs.get_handlers().federation_handler = Mock()
+ user_id = b"@sid1:red"
- def get_user_by_access_token(token=None, allow_guest=False):
- return {
- "user": UserID.from_string(self.auth_user_id),
- "token_id": 1,
- "is_guest": False,
- }
- hs.get_auth().get_user_by_access_token = get_user_by_access_token
-
- def _insert_client_ip(*args, **kwargs):
- return defer.succeed(None)
- hs.get_datastore().insert_client_ip = _insert_client_ip
-
- synapse.rest.client.v1.room.register_servlets(hs, self.mock_resource)
+ def setUp(self):
- self.room_id = yield self.create_room_as(self.user_id)
+ super(RoomMemberStateTestCase, self).setUp()
+ self.room_id = self.helper.create_room_as(self.user_id)
def tearDown(self):
pass
- @defer.inlineCallbacks
def test_invalid_puts(self):
path = "/rooms/%s/state/m.room.member/%s" % (self.room_id, self.user_id)
# missing keys or invalid json
- (code, response) = yield self.mock_resource.trigger("PUT", path, '{}')
- self.assertEquals(400, code, msg=str(response))
+ request, channel = make_request(b"PUT", path, '{}')
+ render(request, self.resource, self.clock)
+ self.assertEquals(400, int(channel.result["code"]), msg=channel.result["body"])
- (code, response) = yield self.mock_resource.trigger(
- "PUT", path, '{"_name":"bob"}'
- )
- self.assertEquals(400, code, msg=str(response))
+ request, channel = make_request(b"PUT", path, '{"_name":"bob"}')
+ render(request, self.resource, self.clock)
+ self.assertEquals(400, int(channel.result["code"]), msg=channel.result["body"])
- (code, response) = yield self.mock_resource.trigger(
- "PUT", path, '{"nao'
- )
- self.assertEquals(400, code, msg=str(response))
+ request, channel = make_request(b"PUT", path, '{"nao')
+ render(request, self.resource, self.clock)
+ self.assertEquals(400, int(channel.result["code"]), msg=channel.result["body"])
- (code, response) = yield self.mock_resource.trigger(
- "PUT", path, '[{"_name":"bob"},{"_name":"jill"}]'
+ request, channel = make_request(
+ b"PUT", path, b'[{"_name":"bob"},{"_name":"jill"}]'
)
- self.assertEquals(400, code, msg=str(response))
+ render(request, self.resource, self.clock)
+ self.assertEquals(400, int(channel.result["code"]), msg=channel.result["body"])
- (code, response) = yield self.mock_resource.trigger(
- "PUT", path, 'text only'
- )
- self.assertEquals(400, code, msg=str(response))
+ request, channel = make_request(b"PUT", path, 'text only')
+ render(request, self.resource, self.clock)
+ self.assertEquals(400, int(channel.result["code"]), msg=channel.result["body"])
- (code, response) = yield self.mock_resource.trigger(
- "PUT", path, ''
- )
- self.assertEquals(400, code, msg=str(response))
+ request, channel = make_request(b"PUT", path, '')
+ render(request, self.resource, self.clock)
+ self.assertEquals(400, int(channel.result["code"]), msg=channel.result["body"])
# valid keys, wrong types
- content = ('{"membership":["%s","%s","%s"]}' % (
- Membership.INVITE, Membership.JOIN, Membership.LEAVE
- ))
- (code, response) = yield self.mock_resource.trigger("PUT", path, content)
- self.assertEquals(400, code, msg=str(response))
+ content = '{"membership":["%s","%s","%s"]}' % (
+ Membership.INVITE,
+ Membership.JOIN,
+ Membership.LEAVE,
+ )
+ request, channel = make_request(b"PUT", path, content.encode('ascii'))
+ render(request, self.resource, self.clock)
+ self.assertEquals(400, int(channel.result["code"]), msg=channel.result["body"])
- @defer.inlineCallbacks
def test_rooms_members_self(self):
path = "/rooms/%s/state/m.room.member/%s" % (
- urlparse.quote(self.room_id), self.user_id
+ urlparse.quote(self.room_id),
+ self.user_id,
)
# valid join message (NOOP since we made the room)
content = '{"membership":"%s"}' % Membership.JOIN
- (code, response) = yield self.mock_resource.trigger("PUT", path, content)
- self.assertEquals(200, code, msg=str(response))
+ request, channel = make_request(b"PUT", path, content.encode('ascii'))
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]), msg=channel.result["body"])
- (code, response) = yield self.mock_resource.trigger("GET", path, None)
- self.assertEquals(200, code, msg=str(response))
+ request, channel = make_request(b"GET", path, None)
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]), msg=channel.result["body"])
- expected_response = {
- "membership": Membership.JOIN,
- }
- self.assertEquals(expected_response, response)
+ expected_response = {"membership": Membership.JOIN}
+ self.assertEquals(expected_response, channel.json_body)
- @defer.inlineCallbacks
def test_rooms_members_other(self):
self.other_id = "@zzsid1:red"
path = "/rooms/%s/state/m.room.member/%s" % (
- urlparse.quote(self.room_id), self.other_id
+ urlparse.quote(self.room_id),
+ self.other_id,
)
# valid invite message
content = '{"membership":"%s"}' % Membership.INVITE
- (code, response) = yield self.mock_resource.trigger("PUT", path, content)
- self.assertEquals(200, code, msg=str(response))
+ request, channel = make_request(b"PUT", path, content)
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]), msg=channel.result["body"])
- (code, response) = yield self.mock_resource.trigger("GET", path, None)
- self.assertEquals(200, code, msg=str(response))
- self.assertEquals(json.loads(content), response)
+ request, channel = make_request(b"GET", path, None)
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]), msg=channel.result["body"])
+ self.assertEquals(json.loads(content), channel.json_body)
- @defer.inlineCallbacks
def test_rooms_members_other_custom_keys(self):
self.other_id = "@zzsid1:red"
path = "/rooms/%s/state/m.room.member/%s" % (
- urlparse.quote(self.room_id), self.other_id
+ urlparse.quote(self.room_id),
+ self.other_id,
)
# valid invite message with custom key
- content = ('{"membership":"%s","invite_text":"%s"}' % (
- Membership.INVITE, "Join us!"
- ))
- (code, response) = yield self.mock_resource.trigger("PUT", path, content)
- self.assertEquals(200, code, msg=str(response))
+ content = '{"membership":"%s","invite_text":"%s"}' % (
+ Membership.INVITE,
+ "Join us!",
+ )
+ request, channel = make_request(b"PUT", path, content)
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]), msg=channel.result["body"])
- (code, response) = yield self.mock_resource.trigger("GET", path, None)
- self.assertEquals(200, code, msg=str(response))
- self.assertEquals(json.loads(content), response)
+ request, channel = make_request(b"GET", path, None)
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]), msg=channel.result["body"])
+ self.assertEquals(json.loads(content), channel.json_body)
-class RoomMessagesTestCase(RestTestCase):
+class RoomMessagesTestCase(RoomBase):
""" Tests /rooms/$room_id/messages/$user_id/$msg_id REST events. """
+
user_id = "@sid1:red"
- @defer.inlineCallbacks
def setUp(self):
- self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
- self.auth_user_id = self.user_id
-
- hs = yield setup_test_homeserver(
- "red",
- http_client=None,
- federation_client=Mock(),
- ratelimiter=NonCallableMock(spec_set=["send_message"]),
- )
- self.ratelimiter = hs.get_ratelimiter()
- self.ratelimiter.send_message.return_value = (True, 0)
-
- hs.get_handlers().federation_handler = Mock()
+ super(RoomMessagesTestCase, self).setUp()
- def get_user_by_access_token(token=None, allow_guest=False):
- return {
- "user": UserID.from_string(self.auth_user_id),
- "token_id": 1,
- "is_guest": False,
- }
- hs.get_auth().get_user_by_access_token = get_user_by_access_token
-
- def _insert_client_ip(*args, **kwargs):
- return defer.succeed(None)
- hs.get_datastore().insert_client_ip = _insert_client_ip
+ self.room_id = self.helper.create_room_as(self.user_id)
- synapse.rest.client.v1.room.register_servlets(hs, self.mock_resource)
-
- self.room_id = yield self.create_room_as(self.user_id)
-
- def tearDown(self):
- pass
-
- @defer.inlineCallbacks
def test_invalid_puts(self):
- path = "/rooms/%s/send/m.room.message/mid1" % (
- urlparse.quote(self.room_id))
+ path = "/rooms/%s/send/m.room.message/mid1" % (urlparse.quote(self.room_id))
# missing keys or invalid json
- (code, response) = yield self.mock_resource.trigger(
- "PUT", path, '{}'
- )
- self.assertEquals(400, code, msg=str(response))
+ request, channel = make_request(b"PUT", path, '{}')
+ render(request, self.resource, self.clock)
+ self.assertEquals(400, int(channel.result["code"]), msg=channel.result["body"])
- (code, response) = yield self.mock_resource.trigger(
- "PUT", path, '{"_name":"bob"}'
- )
- self.assertEquals(400, code, msg=str(response))
+ request, channel = make_request(b"PUT", path, '{"_name":"bob"}')
+ render(request, self.resource, self.clock)
+ self.assertEquals(400, int(channel.result["code"]), msg=channel.result["body"])
- (code, response) = yield self.mock_resource.trigger(
- "PUT", path, '{"nao'
- )
- self.assertEquals(400, code, msg=str(response))
+ request, channel = make_request(b"PUT", path, '{"nao')
+ render(request, self.resource, self.clock)
+ self.assertEquals(400, int(channel.result["code"]), msg=channel.result["body"])
- (code, response) = yield self.mock_resource.trigger(
- "PUT", path, '[{"_name":"bob"},{"_name":"jill"}]'
+ request, channel = make_request(
+ b"PUT", path, '[{"_name":"bob"},{"_name":"jill"}]'
)
- self.assertEquals(400, code, msg=str(response))
+ render(request, self.resource, self.clock)
+ self.assertEquals(400, int(channel.result["code"]), msg=channel.result["body"])
- (code, response) = yield self.mock_resource.trigger(
- "PUT", path, 'text only'
- )
- self.assertEquals(400, code, msg=str(response))
+ request, channel = make_request(b"PUT", path, 'text only')
+ render(request, self.resource, self.clock)
+ self.assertEquals(400, int(channel.result["code"]), msg=channel.result["body"])
- (code, response) = yield self.mock_resource.trigger(
- "PUT", path, ''
- )
- self.assertEquals(400, code, msg=str(response))
+ request, channel = make_request(b"PUT", path, '')
+ render(request, self.resource, self.clock)
+ self.assertEquals(400, int(channel.result["code"]), msg=channel.result["body"])
- @defer.inlineCallbacks
def test_rooms_messages_sent(self):
- path = "/rooms/%s/send/m.room.message/mid1" % (
- urlparse.quote(self.room_id))
+ path = "/rooms/%s/send/m.room.message/mid1" % (urlparse.quote(self.room_id))
content = '{"body":"test","msgtype":{"type":"a"}}'
- (code, response) = yield self.mock_resource.trigger("PUT", path, content)
- self.assertEquals(400, code, msg=str(response))
+ request, channel = make_request(b"PUT", path, content)
+ render(request, self.resource, self.clock)
+ self.assertEquals(400, int(channel.result["code"]), msg=channel.result["body"])
# custom message types
content = '{"body":"test","msgtype":"test.custom.text"}'
- (code, response) = yield self.mock_resource.trigger("PUT", path, content)
- self.assertEquals(200, code, msg=str(response))
-
-# (code, response) = yield self.mock_resource.trigger("GET", path, None)
-# self.assertEquals(200, code, msg=str(response))
-# self.assert_dict(json.loads(content), response)
+ request, channel = make_request(b"PUT", path, content)
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]), msg=channel.result["body"])
# m.text message type
- path = "/rooms/%s/send/m.room.message/mid2" % (
- urlparse.quote(self.room_id))
+ path = "/rooms/%s/send/m.room.message/mid2" % (urlparse.quote(self.room_id))
content = '{"body":"test2","msgtype":"m.text"}'
- (code, response) = yield self.mock_resource.trigger("PUT", path, content)
- self.assertEquals(200, code, msg=str(response))
+ request, channel = make_request(b"PUT", path, content)
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]), msg=channel.result["body"])
-class RoomInitialSyncTestCase(RestTestCase):
+class RoomInitialSyncTestCase(RoomBase):
""" Tests /rooms/$room_id/initialSync. """
+
user_id = "@sid1:red"
- @defer.inlineCallbacks
def setUp(self):
- self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
- self.auth_user_id = self.user_id
-
- hs = yield setup_test_homeserver(
- "red",
- http_client=None,
- federation_client=Mock(),
- ratelimiter=NonCallableMock(spec_set=[
- "send_message",
- ]),
- )
- self.ratelimiter = hs.get_ratelimiter()
- self.ratelimiter.send_message.return_value = (True, 0)
-
- hs.get_handlers().federation_handler = Mock()
-
- def get_user_by_access_token(token=None, allow_guest=False):
- return {
- "user": UserID.from_string(self.auth_user_id),
- "token_id": 1,
- "is_guest": False,
- }
- hs.get_auth().get_user_by_access_token = get_user_by_access_token
-
- def _insert_client_ip(*args, **kwargs):
- return defer.succeed(None)
- hs.get_datastore().insert_client_ip = _insert_client_ip
-
- synapse.rest.client.v1.room.register_servlets(hs, self.mock_resource)
+ super(RoomInitialSyncTestCase, self).setUp()
# create the room
- self.room_id = yield self.create_room_as(self.user_id)
+ self.room_id = self.helper.create_room_as(self.user_id)
- @defer.inlineCallbacks
def test_initial_sync(self):
- (code, response) = yield self.mock_resource.trigger_get(
- "/rooms/%s/initialSync" % self.room_id
- )
- self.assertEquals(200, code)
+ request, channel = make_request(b"GET", "/rooms/%s/initialSync" % self.room_id)
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]))
- self.assertEquals(self.room_id, response["room_id"])
- self.assertEquals("join", response["membership"])
+ self.assertEquals(self.room_id, channel.json_body["room_id"])
+ self.assertEquals("join", channel.json_body["membership"])
# Room state is easier to assert on if we unpack it into a dict
state = {}
- for event in response["state"]:
+ for event in channel.json_body["state"]:
if "state_key" not in event:
continue
t = event["type"]
@@ -977,75 +800,48 @@ class RoomInitialSyncTestCase(RestTestCase):
self.assertTrue("m.room.create" in state)
- self.assertTrue("messages" in response)
- self.assertTrue("chunk" in response["messages"])
- self.assertTrue("end" in response["messages"])
+ self.assertTrue("messages" in channel.json_body)
+ self.assertTrue("chunk" in channel.json_body["messages"])
+ self.assertTrue("end" in channel.json_body["messages"])
- self.assertTrue("presence" in response)
+ self.assertTrue("presence" in channel.json_body)
presence_by_user = {
- e["content"]["user_id"]: e for e in response["presence"]
+ e["content"]["user_id"]: e for e in channel.json_body["presence"]
}
self.assertTrue(self.user_id in presence_by_user)
self.assertEquals("m.presence", presence_by_user[self.user_id]["type"])
-class RoomMessageListTestCase(RestTestCase):
+class RoomMessageListTestCase(RoomBase):
""" Tests /rooms/$room_id/messages REST events. """
+
user_id = "@sid1:red"
- @defer.inlineCallbacks
def setUp(self):
- self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
- self.auth_user_id = self.user_id
-
- hs = yield setup_test_homeserver(
- "red",
- http_client=None,
- federation_client=Mock(),
- ratelimiter=NonCallableMock(spec_set=["send_message"]),
- )
- self.ratelimiter = hs.get_ratelimiter()
- self.ratelimiter.send_message.return_value = (True, 0)
-
- hs.get_handlers().federation_handler = Mock()
-
- def get_user_by_access_token(token=None, allow_guest=False):
- return {
- "user": UserID.from_string(self.auth_user_id),
- "token_id": 1,
- "is_guest": False,
- }
- hs.get_auth().get_user_by_access_token = get_user_by_access_token
+ super(RoomMessageListTestCase, self).setUp()
+ self.room_id = self.helper.create_room_as(self.user_id)
- def _insert_client_ip(*args, **kwargs):
- return defer.succeed(None)
- hs.get_datastore().insert_client_ip = _insert_client_ip
-
- synapse.rest.client.v1.room.register_servlets(hs, self.mock_resource)
-
- self.room_id = yield self.create_room_as(self.user_id)
-
- @defer.inlineCallbacks
def test_topo_token_is_accepted(self):
token = "t1-0_0_0_0_0_0_0_0_0"
- (code, response) = yield self.mock_resource.trigger_get(
- "/rooms/%s/messages?access_token=x&from=%s" %
- (self.room_id, token))
- self.assertEquals(200, code)
- self.assertTrue("start" in response)
- self.assertEquals(token, response['start'])
- self.assertTrue("chunk" in response)
- self.assertTrue("end" in response)
-
- @defer.inlineCallbacks
+ request, channel = make_request(
+ b"GET", "/rooms/%s/messages?access_token=x&from=%s" % (self.room_id, token)
+ )
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]))
+ self.assertTrue("start" in channel.json_body)
+ self.assertEquals(token, channel.json_body['start'])
+ self.assertTrue("chunk" in channel.json_body)
+ self.assertTrue("end" in channel.json_body)
+
def test_stream_token_is_accepted_for_fwd_pagianation(self):
token = "s0_0_0_0_0_0_0_0_0"
- (code, response) = yield self.mock_resource.trigger_get(
- "/rooms/%s/messages?access_token=x&from=%s" %
- (self.room_id, token))
- self.assertEquals(200, code)
- self.assertTrue("start" in response)
- self.assertEquals(token, response['start'])
- self.assertTrue("chunk" in response)
- self.assertTrue("end" in response)
+ request, channel = make_request(
+ b"GET", "/rooms/%s/messages?access_token=x&from=%s" % (self.room_id, token)
+ )
+ render(request, self.resource, self.clock)
+ self.assertEquals(200, int(channel.result["code"]))
+ self.assertTrue("start" in channel.json_body)
+ self.assertEquals(token, channel.json_body['start'])
+ self.assertTrue("chunk" in channel.json_body)
+ self.assertTrue("end" in channel.json_body)
diff --git a/tests/rest/client/v1/utils.py b/tests/rest/client/v1/utils.py
index 54d7ba380d..41de8e0762 100644
--- a/tests/rest/client/v1/utils.py
+++ b/tests/rest/client/v1/utils.py
@@ -16,13 +16,14 @@
import json
import time
-# twisted imports
+import attr
+
from twisted.internet import defer
from synapse.api.constants import Membership
-# trial imports
from tests import unittest
+from tests.server import make_request, wait_until_result
class RestTestCase(unittest.TestCase):
@@ -133,3 +134,113 @@ class RestTestCase(unittest.TestCase):
for key in required:
self.assertEquals(required[key], actual[key],
msg="%s mismatch. %s" % (key, actual))
+
+
+@attr.s
+class RestHelper(object):
+ """Contains extra helper functions to quickly and clearly perform a given
+ REST action, which isn't the focus of the test.
+ """
+
+ hs = attr.ib()
+ resource = attr.ib()
+ auth_user_id = attr.ib()
+
+ def create_room_as(self, room_creator, is_public=True, tok=None):
+ temp_id = self.auth_user_id
+ self.auth_user_id = room_creator
+ path = b"/_matrix/client/r0/createRoom"
+ content = {}
+ if not is_public:
+ content["visibility"] = "private"
+ if tok:
+ path = path + b"?access_token=%s" % tok.encode('ascii')
+
+ request, channel = make_request(b"POST", path, json.dumps(content).encode('utf8'))
+ request.render(self.resource)
+ wait_until_result(self.hs.get_reactor(), channel)
+
+ assert channel.result["code"] == b"200", channel.result
+ self.auth_user_id = temp_id
+ return channel.json_body["room_id"]
+
+ def invite(self, room=None, src=None, targ=None, expect_code=200, tok=None):
+ self.change_membership(
+ room=room,
+ src=src,
+ targ=targ,
+ tok=tok,
+ membership=Membership.INVITE,
+ expect_code=expect_code,
+ )
+
+ def join(self, room=None, user=None, expect_code=200, tok=None):
+ self.change_membership(
+ room=room,
+ src=user,
+ targ=user,
+ tok=tok,
+ membership=Membership.JOIN,
+ expect_code=expect_code,
+ )
+
+ def leave(self, room=None, user=None, expect_code=200, tok=None):
+ self.change_membership(
+ room=room,
+ src=user,
+ targ=user,
+ tok=tok,
+ membership=Membership.LEAVE,
+ expect_code=expect_code,
+ )
+
+ def change_membership(self, room, src, targ, membership, tok=None, expect_code=200):
+ temp_id = self.auth_user_id
+ self.auth_user_id = src
+
+ path = "/_matrix/client/r0/rooms/%s/state/m.room.member/%s" % (room, targ)
+ if tok:
+ path = path + "?access_token=%s" % tok
+
+ data = {"membership": membership}
+
+ request, channel = make_request(
+ b"PUT", path.encode('ascii'), json.dumps(data).encode('utf8')
+ )
+
+ request.render(self.resource)
+ wait_until_result(self.hs.get_reactor(), channel)
+
+ 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
+
+ @defer.inlineCallbacks
+ def register(self, user_id):
+ (code, response) = yield self.mock_resource.trigger(
+ "POST",
+ "/_matrix/client/r0/register",
+ json.dumps(
+ {"user": user_id, "password": "test", "type": "m.login.password"}
+ ),
+ )
+ self.assertEquals(200, code)
+ defer.returnValue(response)
+
+ @defer.inlineCallbacks
+ def send(self, room_id, body=None, txn_id=None, tok=None, expect_code=200):
+ if txn_id is None:
+ txn_id = "m%s" % (str(time.time()))
+ if body is None:
+ body = "body_text_here"
+
+ path = "/_matrix/client/r0/rooms/%s/send/m.room.message/%s" % (room_id, txn_id)
+ content = '{"msgtype":"m.text","body":"%s"}' % body
+ if tok:
+ path = path + "?access_token=%s" % tok
+
+ (code, response) = yield self.mock_resource.trigger("PUT", path, content)
+ self.assertEquals(expect_code, code, msg=str(response))
diff --git a/tests/rest/client/v2_alpha/__init__.py b/tests/rest/client/v2_alpha/__init__.py
index f18a8a6027..e69de29bb2 100644
--- a/tests/rest/client/v2_alpha/__init__.py
+++ b/tests/rest/client/v2_alpha/__init__.py
@@ -1,61 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2015, 2016 OpenMarket Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from mock import Mock
-
-from twisted.internet import defer
-
-from synapse.types import UserID
-
-from tests import unittest
-
-from ....utils import MockHttpResource, setup_test_homeserver
-
-PATH_PREFIX = "/_matrix/client/v2_alpha"
-
-
-class V2AlphaRestTestCase(unittest.TestCase):
- # Consumer must define
- # USER_ID = <some string>
- # TO_REGISTER = [<list of REST servlets to register>]
-
- @defer.inlineCallbacks
- def setUp(self):
- self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
-
- hs = yield setup_test_homeserver(
- datastore=self.make_datastore_mock(),
- http_client=None,
- resource_for_client=self.mock_resource,
- resource_for_federation=self.mock_resource,
- )
-
- def get_user_by_access_token(token=None, allow_guest=False):
- return {
- "user": UserID.from_string(self.USER_ID),
- "token_id": 1,
- "is_guest": False,
- }
- hs.get_auth().get_user_by_access_token = get_user_by_access_token
-
- for r in self.TO_REGISTER:
- r.register_servlets(hs, self.mock_resource)
-
- def make_datastore_mock(self):
- store = Mock(spec=[
- "insert_client_ip",
- ])
- store.get_app_service_by_token = Mock(return_value=None)
- return store
diff --git a/tests/rest/client/v2_alpha/test_filter.py b/tests/rest/client/v2_alpha/test_filter.py
index bb0b2f94ea..5ea9cc825f 100644
--- a/tests/rest/client/v2_alpha/test_filter.py
+++ b/tests/rest/client/v2_alpha/test_filter.py
@@ -13,35 +13,33 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-from twisted.internet import defer
-
import synapse.types
from synapse.api.errors import Codes
+from synapse.http.server import JsonResource
from synapse.rest.client.v2_alpha import filter
from synapse.types import UserID
+from synapse.util import Clock
from tests import unittest
-
-from ....utils import MockHttpResource, setup_test_homeserver
+from tests.server import ThreadedMemoryReactorClock as MemoryReactorClock
+from tests.server import make_request, setup_test_homeserver, wait_until_result
PATH_PREFIX = "/_matrix/client/v2_alpha"
class FilterTestCase(unittest.TestCase):
- USER_ID = "@apple:test"
+ USER_ID = b"@apple:test"
EXAMPLE_FILTER = {"room": {"timeline": {"types": ["m.room.message"]}}}
- EXAMPLE_FILTER_JSON = '{"room": {"timeline": {"types": ["m.room.message"]}}}'
+ EXAMPLE_FILTER_JSON = b'{"room": {"timeline": {"types": ["m.room.message"]}}}'
TO_REGISTER = [filter]
- @defer.inlineCallbacks
def setUp(self):
- self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
+ self.clock = MemoryReactorClock()
+ self.hs_clock = Clock(self.clock)
- self.hs = yield setup_test_homeserver(
- http_client=None,
- resource_for_client=self.mock_resource,
- resource_for_federation=self.mock_resource,
+ self.hs = setup_test_homeserver(
+ http_client=None, clock=self.hs_clock, reactor=self.clock
)
self.auth = self.hs.get_auth()
@@ -55,82 +53,103 @@ class FilterTestCase(unittest.TestCase):
def get_user_by_req(request, allow_guest=False, rights="access"):
return synapse.types.create_requester(
- UserID.from_string(self.USER_ID), 1, False, None)
+ UserID.from_string(self.USER_ID), 1, False, None
+ )
self.auth.get_user_by_access_token = get_user_by_access_token
self.auth.get_user_by_req = get_user_by_req
self.store = self.hs.get_datastore()
self.filtering = self.hs.get_filtering()
+ self.resource = JsonResource(self.hs)
for r in self.TO_REGISTER:
- r.register_servlets(self.hs, self.mock_resource)
+ r.register_servlets(self.hs, self.resource)
- @defer.inlineCallbacks
def test_add_filter(self):
- (code, response) = yield self.mock_resource.trigger(
- "POST", "/user/%s/filter" % (self.USER_ID), self.EXAMPLE_FILTER_JSON
- )
- self.assertEquals(200, code)
- self.assertEquals({"filter_id": "0"}, response)
- filter = yield self.store.get_user_filter(
- user_localpart='apple',
- filter_id=0,
+ request, channel = make_request(
+ b"POST",
+ b"/_matrix/client/r0/user/%s/filter" % (self.USER_ID),
+ self.EXAMPLE_FILTER_JSON,
)
- self.assertEquals(filter, self.EXAMPLE_FILTER)
+ request.render(self.resource)
+ wait_until_result(self.clock, channel)
+
+ self.assertEqual(channel.result["code"], b"200")
+ self.assertEqual(channel.json_body, {"filter_id": "0"})
+ filter = self.store.get_user_filter(user_localpart="apple", filter_id=0)
+ self.clock.advance(0)
+ self.assertEquals(filter.result, self.EXAMPLE_FILTER)
- @defer.inlineCallbacks
def test_add_filter_for_other_user(self):
- (code, response) = yield self.mock_resource.trigger(
- "POST", "/user/%s/filter" % ('@watermelon:test'), self.EXAMPLE_FILTER_JSON
+ request, channel = make_request(
+ b"POST",
+ b"/_matrix/client/r0/user/%s/filter" % (b"@watermelon:test"),
+ self.EXAMPLE_FILTER_JSON,
)
- self.assertEquals(403, code)
- self.assertEquals(response['errcode'], Codes.FORBIDDEN)
+ request.render(self.resource)
+ wait_until_result(self.clock, channel)
+
+ self.assertEqual(channel.result["code"], b"403")
+ self.assertEquals(channel.json_body["errcode"], Codes.FORBIDDEN)
- @defer.inlineCallbacks
def test_add_filter_non_local_user(self):
_is_mine = self.hs.is_mine
self.hs.is_mine = lambda target_user: False
- (code, response) = yield self.mock_resource.trigger(
- "POST", "/user/%s/filter" % (self.USER_ID), self.EXAMPLE_FILTER_JSON
+ request, channel = make_request(
+ b"POST",
+ b"/_matrix/client/r0/user/%s/filter" % (self.USER_ID),
+ self.EXAMPLE_FILTER_JSON,
)
+ request.render(self.resource)
+ wait_until_result(self.clock, channel)
+
self.hs.is_mine = _is_mine
- self.assertEquals(403, code)
- self.assertEquals(response['errcode'], Codes.FORBIDDEN)
+ self.assertEqual(channel.result["code"], b"403")
+ self.assertEquals(channel.json_body["errcode"], Codes.FORBIDDEN)
- @defer.inlineCallbacks
def test_get_filter(self):
- filter_id = yield self.filtering.add_user_filter(
- user_localpart='apple',
- user_filter=self.EXAMPLE_FILTER
+ filter_id = self.filtering.add_user_filter(
+ user_localpart="apple", user_filter=self.EXAMPLE_FILTER
)
- (code, response) = yield self.mock_resource.trigger_get(
- "/user/%s/filter/%s" % (self.USER_ID, filter_id)
+ self.clock.advance(1)
+ filter_id = filter_id.result
+ request, channel = make_request(
+ b"GET", b"/_matrix/client/r0/user/%s/filter/%s" % (self.USER_ID, filter_id)
)
- self.assertEquals(200, code)
- self.assertEquals(self.EXAMPLE_FILTER, response)
+ request.render(self.resource)
+ wait_until_result(self.clock, channel)
+
+ self.assertEqual(channel.result["code"], b"200")
+ self.assertEquals(channel.json_body, self.EXAMPLE_FILTER)
- @defer.inlineCallbacks
def test_get_filter_non_existant(self):
- (code, response) = yield self.mock_resource.trigger_get(
- "/user/%s/filter/12382148321" % (self.USER_ID)
+ request, channel = make_request(
+ b"GET", "/_matrix/client/r0/user/%s/filter/12382148321" % (self.USER_ID)
)
- self.assertEquals(400, code)
- self.assertEquals(response['errcode'], Codes.NOT_FOUND)
+ request.render(self.resource)
+ wait_until_result(self.clock, channel)
+
+ self.assertEqual(channel.result["code"], b"400")
+ self.assertEquals(channel.json_body["errcode"], Codes.NOT_FOUND)
# Currently invalid params do not have an appropriate errcode
# in errors.py
- @defer.inlineCallbacks
def test_get_filter_invalid_id(self):
- (code, response) = yield self.mock_resource.trigger_get(
- "/user/%s/filter/foobar" % (self.USER_ID)
+ request, channel = make_request(
+ b"GET", "/_matrix/client/r0/user/%s/filter/foobar" % (self.USER_ID)
)
- self.assertEquals(400, code)
+ request.render(self.resource)
+ wait_until_result(self.clock, channel)
+
+ self.assertEqual(channel.result["code"], b"400")
# No ID also returns an invalid_id error
- @defer.inlineCallbacks
def test_get_filter_no_id(self):
- (code, response) = yield self.mock_resource.trigger_get(
- "/user/%s/filter/" % (self.USER_ID)
+ request, channel = make_request(
+ b"GET", "/_matrix/client/r0/user/%s/filter/" % (self.USER_ID)
)
- self.assertEquals(400, code)
+ request.render(self.resource)
+ wait_until_result(self.clock, channel)
+
+ self.assertEqual(channel.result["code"], b"400")
diff --git a/tests/rest/client/v2_alpha/test_register.py b/tests/rest/client/v2_alpha/test_register.py
index 9b57a56070..e004d8fc73 100644
--- a/tests/rest/client/v2_alpha/test_register.py
+++ b/tests/rest/client/v2_alpha/test_register.py
@@ -2,165 +2,192 @@ import json
from mock import Mock
-from twisted.internet import defer
from twisted.python import failure
+from twisted.test.proto_helpers import MemoryReactorClock
-from synapse.api.errors import InteractiveAuthIncompleteError, SynapseError
-from synapse.rest.client.v2_alpha.register import RegisterRestServlet
+from synapse.api.errors import InteractiveAuthIncompleteError
+from synapse.http.server import JsonResource
+from synapse.rest.client.v2_alpha.register import register_servlets
+from synapse.util import Clock
from tests import unittest
-from tests.utils import mock_getRawHeaders
+from tests.server import make_request, setup_test_homeserver, wait_until_result
class RegisterRestServletTestCase(unittest.TestCase):
-
def setUp(self):
- # do the dance to hook up request data to self.request_data
- self.request_data = ""
- self.request = Mock(
- content=Mock(read=Mock(side_effect=lambda: self.request_data)),
- path='/_matrix/api/v2_alpha/register'
- )
- self.request.args = {}
- self.request.requestHeaders.getRawHeaders = mock_getRawHeaders()
+
+ self.clock = MemoryReactorClock()
+ self.hs_clock = Clock(self.clock)
+ self.url = b"/_matrix/client/r0/register"
self.appservice = None
- self.auth = Mock(get_appservice_by_req=Mock(
- side_effect=lambda x: self.appservice)
+ self.auth = Mock(
+ get_appservice_by_req=Mock(side_effect=lambda x: self.appservice)
)
self.auth_result = failure.Failure(InteractiveAuthIncompleteError(None))
self.auth_handler = Mock(
check_auth=Mock(side_effect=lambda x, y, z: self.auth_result),
- get_session_data=Mock(return_value=None)
+ get_session_data=Mock(return_value=None),
)
self.registration_handler = Mock()
self.identity_handler = Mock()
self.login_handler = Mock()
self.device_handler = Mock()
+ self.device_handler.check_device_registered = Mock(return_value="FAKE")
+
+ self.datastore = Mock(return_value=Mock())
+ self.datastore.get_current_state_deltas = Mock(return_value=[])
# do the dance to hook it up to the hs global
self.handlers = Mock(
registration_handler=self.registration_handler,
identity_handler=self.identity_handler,
- login_handler=self.login_handler
+ login_handler=self.login_handler,
+ )
+ self.hs = setup_test_homeserver(
+ http_client=None, clock=self.hs_clock, reactor=self.clock
)
- self.hs = Mock()
- self.hs.hostname = "superbig~testing~thing.com"
self.hs.get_auth = Mock(return_value=self.auth)
self.hs.get_handlers = Mock(return_value=self.handlers)
self.hs.get_auth_handler = Mock(return_value=self.auth_handler)
self.hs.get_device_handler = Mock(return_value=self.device_handler)
+ self.hs.get_datastore = Mock(return_value=self.datastore)
self.hs.config.enable_registration = True
self.hs.config.registrations_require_3pid = []
self.hs.config.auto_join_rooms = []
- # init the thing we're testing
- self.servlet = RegisterRestServlet(self.hs)
+ self.resource = JsonResource(self.hs)
+ register_servlets(self.hs, self.resource)
- @defer.inlineCallbacks
def test_POST_appservice_registration_valid(self):
user_id = "@kermit:muppet"
token = "kermits_access_token"
- self.request.args = {
- "access_token": "i_am_an_app_service"
- }
- self.request_data = json.dumps({
- "username": "kermit"
- })
- self.appservice = {
- "id": "1234"
- }
- self.registration_handler.appservice_register = Mock(
- return_value=user_id
- )
- self.auth_handler.get_access_token_for_user_id = Mock(
- return_value=token
+ self.appservice = {"id": "1234"}
+ self.registration_handler.appservice_register = Mock(return_value=user_id)
+ self.auth_handler.get_access_token_for_user_id = Mock(return_value=token)
+ request_data = json.dumps({"username": "kermit"})
+
+ request, channel = make_request(
+ b"POST", self.url + b"?access_token=i_am_an_app_service", request_data
)
+ request.render(self.resource)
+ wait_until_result(self.clock, channel)
- (code, result) = yield self.servlet.on_POST(self.request)
- self.assertEquals(code, 200)
+ self.assertEquals(channel.result["code"], b"200", channel.result)
det_data = {
"user_id": user_id,
"access_token": token,
- "home_server": self.hs.hostname
+ "home_server": self.hs.hostname,
}
- self.assertDictContainsSubset(det_data, result)
+ self.assertDictContainsSubset(det_data, json.loads(channel.result["body"]))
- @defer.inlineCallbacks
def test_POST_appservice_registration_invalid(self):
- self.request.args = {
- "access_token": "i_am_an_app_service"
- }
-
- self.request_data = json.dumps({
- "username": "kermit"
- })
self.appservice = None # no application service exists
- result = yield self.servlet.on_POST(self.request)
- self.assertEquals(result, (401, None))
+ request_data = json.dumps({"username": "kermit"})
+ request, channel = make_request(
+ b"POST", self.url + b"?access_token=i_am_an_app_service", request_data
+ )
+ request.render(self.resource)
+ wait_until_result(self.clock, channel)
+
+ self.assertEquals(channel.result["code"], b"401", channel.result)
def test_POST_bad_password(self):
- self.request_data = json.dumps({
- "username": "kermit",
- "password": 666
- })
- d = self.servlet.on_POST(self.request)
- return self.assertFailure(d, SynapseError)
+ request_data = json.dumps({"username": "kermit", "password": 666})
+ request, channel = make_request(b"POST", self.url, request_data)
+ request.render(self.resource)
+ wait_until_result(self.clock, channel)
+
+ self.assertEquals(channel.result["code"], b"400", channel.result)
+ self.assertEquals(
+ json.loads(channel.result["body"])["error"], "Invalid password"
+ )
def test_POST_bad_username(self):
- self.request_data = json.dumps({
- "username": 777,
- "password": "monkey"
- })
- d = self.servlet.on_POST(self.request)
- return self.assertFailure(d, SynapseError)
-
- @defer.inlineCallbacks
+ request_data = json.dumps({"username": 777, "password": "monkey"})
+ request, channel = make_request(b"POST", self.url, request_data)
+ request.render(self.resource)
+ wait_until_result(self.clock, channel)
+
+ self.assertEquals(channel.result["code"], b"400", channel.result)
+ self.assertEquals(
+ json.loads(channel.result["body"])["error"], "Invalid username"
+ )
+
def test_POST_user_valid(self):
user_id = "@kermit:muppet"
token = "kermits_access_token"
device_id = "frogfone"
- self.request_data = json.dumps({
- "username": "kermit",
- "password": "monkey",
- "device_id": device_id,
- })
+ request_data = json.dumps(
+ {"username": "kermit", "password": "monkey", "device_id": device_id}
+ )
self.registration_handler.check_username = Mock(return_value=True)
- self.auth_result = (None, {
- "username": "kermit",
- "password": "monkey"
- }, None)
+ self.auth_result = (None, {"username": "kermit", "password": "monkey"}, None)
self.registration_handler.register = Mock(return_value=(user_id, None))
- self.auth_handler.get_access_token_for_user_id = Mock(
- return_value=token
- )
- self.device_handler.check_device_registered = \
- Mock(return_value=device_id)
+ self.auth_handler.get_access_token_for_user_id = Mock(return_value=token)
+ self.device_handler.check_device_registered = Mock(return_value=device_id)
+
+ request, channel = make_request(b"POST", self.url, request_data)
+ request.render(self.resource)
+ wait_until_result(self.clock, channel)
- (code, result) = yield self.servlet.on_POST(self.request)
- self.assertEquals(code, 200)
det_data = {
"user_id": user_id,
"access_token": token,
"home_server": self.hs.hostname,
"device_id": device_id,
}
- self.assertDictContainsSubset(det_data, result)
+ self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertDictContainsSubset(det_data, json.loads(channel.result["body"]))
self.auth_handler.get_login_tuple_for_user_id(
- user_id, device_id=device_id, initial_device_display_name=None)
+ user_id, device_id=device_id, initial_device_display_name=None
+ )
def test_POST_disabled_registration(self):
self.hs.config.enable_registration = False
- self.request_data = json.dumps({
- "username": "kermit",
- "password": "monkey"
- })
+ request_data = json.dumps({"username": "kermit", "password": "monkey"})
self.registration_handler.check_username = Mock(return_value=True)
- self.auth_result = (None, {
- "username": "kermit",
- "password": "monkey"
- }, None)
+ self.auth_result = (None, {"username": "kermit", "password": "monkey"}, None)
self.registration_handler.register = Mock(return_value=("@user:id", "t"))
- d = self.servlet.on_POST(self.request)
- return self.assertFailure(d, SynapseError)
+
+ request, channel = make_request(b"POST", self.url, request_data)
+ request.render(self.resource)
+ wait_until_result(self.clock, channel)
+
+ self.assertEquals(channel.result["code"], b"403", channel.result)
+ self.assertEquals(
+ json.loads(channel.result["body"])["error"],
+ "Registration has been disabled",
+ )
+
+ def test_POST_guest_registration(self):
+ user_id = "a@b"
+ self.hs.config.macaroon_secret_key = "test"
+ self.hs.config.allow_guest_access = True
+ self.registration_handler.register = Mock(return_value=(user_id, None))
+
+ request, channel = make_request(b"POST", self.url + b"?kind=guest", b"{}")
+ request.render(self.resource)
+ wait_until_result(self.clock, channel)
+
+ det_data = {
+ "user_id": user_id,
+ "home_server": self.hs.hostname,
+ "device_id": "guest_device",
+ }
+ self.assertEquals(channel.result["code"], b"200", channel.result)
+ self.assertDictContainsSubset(det_data, json.loads(channel.result["body"]))
+
+ def test_POST_disabled_guest_registration(self):
+ self.hs.config.allow_guest_access = False
+
+ request, channel = make_request(b"POST", self.url + b"?kind=guest", b"{}")
+ request.render(self.resource)
+ wait_until_result(self.clock, channel)
+
+ self.assertEquals(channel.result["code"], b"403", channel.result)
+ self.assertEquals(
+ json.loads(channel.result["body"])["error"], "Guest access is disabled"
+ )
diff --git a/tests/rest/client/v2_alpha/test_sync.py b/tests/rest/client/v2_alpha/test_sync.py
new file mode 100644
index 0000000000..704cf97a40
--- /dev/null
+++ b/tests/rest/client/v2_alpha/test_sync.py
@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+# Copyright 2018 New Vector
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import synapse.types
+from synapse.http.server import JsonResource
+from synapse.rest.client.v2_alpha import sync
+from synapse.types import UserID
+from synapse.util import Clock
+
+from tests import unittest
+from tests.server import ThreadedMemoryReactorClock as MemoryReactorClock
+from tests.server import make_request, setup_test_homeserver, wait_until_result
+
+PATH_PREFIX = "/_matrix/client/v2_alpha"
+
+
+class FilterTestCase(unittest.TestCase):
+
+ USER_ID = b"@apple:test"
+ TO_REGISTER = [sync]
+
+ def setUp(self):
+ self.clock = MemoryReactorClock()
+ self.hs_clock = Clock(self.clock)
+
+ self.hs = setup_test_homeserver(
+ http_client=None, clock=self.hs_clock, reactor=self.clock
+ )
+
+ self.auth = self.hs.get_auth()
+
+ def get_user_by_access_token(token=None, allow_guest=False):
+ return {
+ "user": UserID.from_string(self.USER_ID),
+ "token_id": 1,
+ "is_guest": False,
+ }
+
+ def get_user_by_req(request, allow_guest=False, rights="access"):
+ return synapse.types.create_requester(
+ UserID.from_string(self.USER_ID), 1, False, None
+ )
+
+ self.auth.get_user_by_access_token = get_user_by_access_token
+ self.auth.get_user_by_req = get_user_by_req
+
+ self.store = self.hs.get_datastore()
+ self.filtering = self.hs.get_filtering()
+ self.resource = JsonResource(self.hs)
+
+ for r in self.TO_REGISTER:
+ r.register_servlets(self.hs, self.resource)
+
+ def test_sync_argless(self):
+ request, channel = make_request(b"GET", b"/_matrix/client/r0/sync")
+ request.render(self.resource)
+ wait_until_result(self.clock, channel)
+
+ self.assertEqual(channel.result["code"], b"200")
+ self.assertTrue(
+ set(
+ [
+ "next_batch",
+ "rooms",
+ "presence",
+ "account_data",
+ "to_device",
+ "device_lists",
+ ]
+ ).issubset(set(channel.json_body.keys()))
+ )
|
