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()))
+ )
|
