diff --git a/tests/crypto/test_keyring.py b/tests/crypto/test_keyring.py
index d643bec887..c30a1a69e7 100644
--- a/tests/crypto/test_keyring.py
+++ b/tests/crypto/test_keyring.py
@@ -19,14 +19,14 @@ from mock import Mock
import signedjson.key
import signedjson.sign
-from twisted.internet import defer, reactor
+from twisted.internet import defer
from synapse.api.errors import SynapseError
from synapse.crypto import keyring
-from synapse.util import Clock, logcontext
+from synapse.util import logcontext
from synapse.util.logcontext import LoggingContext
-from tests import unittest, utils
+from tests import unittest
class MockPerspectiveServer(object):
@@ -52,75 +52,50 @@ class MockPerspectiveServer(object):
return res
-class KeyringTestCase(unittest.TestCase):
- @defer.inlineCallbacks
- def setUp(self):
+class KeyringTestCase(unittest.HomeserverTestCase):
+ def make_homeserver(self, reactor, clock):
self.mock_perspective_server = MockPerspectiveServer()
self.http_client = Mock()
- self.hs = yield utils.setup_test_homeserver(
- self.addCleanup, handlers=None, http_client=self.http_client
- )
+ hs = self.setup_test_homeserver(handlers=None, http_client=self.http_client)
keys = self.mock_perspective_server.get_verify_keys()
- self.hs.config.perspectives = {self.mock_perspective_server.server_name: keys}
-
- def assert_sentinel_context(self):
- if LoggingContext.current_context() != LoggingContext.sentinel:
- self.fail(
- "Expected sentinel context but got %s" % (
- LoggingContext.current_context(),
- )
- )
+ hs.config.perspectives = {self.mock_perspective_server.server_name: keys}
+ return hs
def check_context(self, _, expected):
self.assertEquals(
getattr(LoggingContext.current_context(), "request", None), expected
)
- @defer.inlineCallbacks
def test_wait_for_previous_lookups(self):
kr = keyring.Keyring(self.hs)
lookup_1_deferred = defer.Deferred()
lookup_2_deferred = defer.Deferred()
- with LoggingContext("one") as context_one:
- context_one.request = "one"
-
- wait_1_deferred = kr.wait_for_previous_lookups(
- ["server1"], {"server1": lookup_1_deferred}
- )
-
- # there were no previous lookups, so the deferred should be ready
- self.assertTrue(wait_1_deferred.called)
- # ... so we should have preserved the LoggingContext.
- self.assertIs(LoggingContext.current_context(), context_one)
- wait_1_deferred.addBoth(self.check_context, "one")
-
- with LoggingContext("two") as context_two:
- context_two.request = "two"
+ # we run the lookup in a logcontext so that the patched inlineCallbacks can check
+ # it is doing the right thing with logcontexts.
+ wait_1_deferred = run_in_context(
+ kr.wait_for_previous_lookups, ["server1"], {"server1": lookup_1_deferred}
+ )
- # set off another wait. It should block because the first lookup
- # hasn't yet completed.
- wait_2_deferred = kr.wait_for_previous_lookups(
- ["server1"], {"server1": lookup_2_deferred}
- )
- self.assertFalse(wait_2_deferred.called)
+ # there were no previous lookups, so the deferred should be ready
+ self.successResultOf(wait_1_deferred)
- # ... so we should have reset the LoggingContext.
- self.assert_sentinel_context()
+ # set off another wait. It should block because the first lookup
+ # hasn't yet completed.
+ wait_2_deferred = run_in_context(
+ kr.wait_for_previous_lookups, ["server1"], {"server1": lookup_2_deferred}
+ )
- wait_2_deferred.addBoth(self.check_context, "two")
+ self.assertFalse(wait_2_deferred.called)
- # let the first lookup complete (in the sentinel context)
- lookup_1_deferred.callback(None)
+ # let the first lookup complete (in the sentinel context)
+ lookup_1_deferred.callback(None)
- # now the second wait should complete and restore our
- # loggingcontext.
- yield wait_2_deferred
+ # now the second wait should complete.
+ self.successResultOf(wait_2_deferred)
- @defer.inlineCallbacks
def test_verify_json_objects_for_server_awaits_previous_requests(self):
- clock = Clock(reactor)
key1 = signedjson.key.generate_signing_key(1)
kr = keyring.Keyring(self.hs)
@@ -145,81 +120,103 @@ class KeyringTestCase(unittest.TestCase):
self.http_client.post_json.side_effect = get_perspectives
- with LoggingContext("11") as context_11:
- context_11.request = "11"
-
- # start off a first set of lookups
- res_deferreds = kr.verify_json_objects_for_server(
- [("server10", json1), ("server11", {})]
- )
-
- # the unsigned json should be rejected pretty quickly
- self.assertTrue(res_deferreds[1].called)
- try:
- yield res_deferreds[1]
- self.assertFalse("unsigned json didn't cause a failure")
- except SynapseError:
- pass
-
- self.assertFalse(res_deferreds[0].called)
- res_deferreds[0].addBoth(self.check_context, None)
-
- # wait a tick for it to send the request to the perspectives server
- # (it first tries the datastore)
- yield clock.sleep(1) # XXX find out why this takes so long!
- self.http_client.post_json.assert_called_once()
-
- self.assertIs(LoggingContext.current_context(), context_11)
-
- context_12 = LoggingContext("12")
- context_12.request = "12"
- with logcontext.PreserveLoggingContext(context_12):
- # a second request for a server with outstanding requests
- # should block rather than start a second call
+ # start off a first set of lookups
+ @defer.inlineCallbacks
+ def first_lookup():
+ with LoggingContext("11") as context_11:
+ context_11.request = "11"
+
+ res_deferreds = kr.verify_json_objects_for_server(
+ [("server10", json1), ("server11", {})]
+ )
+
+ # the unsigned json should be rejected pretty quickly
+ self.assertTrue(res_deferreds[1].called)
+ try:
+ yield res_deferreds[1]
+ self.assertFalse("unsigned json didn't cause a failure")
+ except SynapseError:
+ pass
+
+ self.assertFalse(res_deferreds[0].called)
+ res_deferreds[0].addBoth(self.check_context, None)
+
+ yield logcontext.make_deferred_yieldable(res_deferreds[0])
+
+ # let verify_json_objects_for_server finish its work before we kill the
+ # logcontext
+ yield self.clock.sleep(0)
+
+ d0 = first_lookup()
+
+ # wait a tick for it to send the request to the perspectives server
+ # (it first tries the datastore)
+ self.pump()
+ self.http_client.post_json.assert_called_once()
+
+ # a second request for a server with outstanding requests
+ # should block rather than start a second call
+ @defer.inlineCallbacks
+ def second_lookup():
+ with LoggingContext("12") as context_12:
+ context_12.request = "12"
self.http_client.post_json.reset_mock()
self.http_client.post_json.return_value = defer.Deferred()
res_deferreds_2 = kr.verify_json_objects_for_server(
- [("server10", json1)]
+ [("server10", json1, )]
)
- yield clock.sleep(1)
- self.http_client.post_json.assert_not_called()
res_deferreds_2[0].addBoth(self.check_context, None)
+ yield logcontext.make_deferred_yieldable(res_deferreds_2[0])
- # complete the first request
- with logcontext.PreserveLoggingContext():
- persp_deferred.callback(persp_resp)
- self.assertIs(LoggingContext.current_context(), context_11)
+ # let verify_json_objects_for_server finish its work before we kill the
+ # logcontext
+ yield self.clock.sleep(0)
- with logcontext.PreserveLoggingContext():
- yield res_deferreds[0]
- yield res_deferreds_2[0]
+ d2 = second_lookup()
+
+ self.pump()
+ self.http_client.post_json.assert_not_called()
+
+ # complete the first request
+ persp_deferred.callback(persp_resp)
+ self.get_success(d0)
+ self.get_success(d2)
- @defer.inlineCallbacks
def test_verify_json_for_server(self):
kr = keyring.Keyring(self.hs)
key1 = signedjson.key.generate_signing_key(1)
- yield self.hs.datastore.store_server_verify_key(
+ r = self.hs.datastore.store_server_verify_key(
"server9", "", time.time() * 1000, signedjson.key.get_verify_key(key1)
)
+ self.get_success(r)
json1 = {}
signedjson.sign.sign_json(json1, "server9", key1)
- with LoggingContext("one") as context_one:
- context_one.request = "one"
+ # should fail immediately on an unsigned object
+ d = _verify_json_for_server(kr, "server9", {})
+ self.failureResultOf(d, SynapseError)
+
+ d = _verify_json_for_server(kr, "server9", json1)
+ self.assertFalse(d.called)
+ self.get_success(d)
- defer = kr.verify_json_for_server("server9", {})
- try:
- yield defer
- self.fail("should fail on unsigned json")
- except SynapseError:
- pass
- self.assertIs(LoggingContext.current_context(), context_one)
- defer = kr.verify_json_for_server("server9", json1)
- self.assertFalse(defer.called)
- self.assert_sentinel_context()
- yield defer
+@defer.inlineCallbacks
+def run_in_context(f, *args, **kwargs):
+ with LoggingContext("testctx"):
+ rv = yield f(*args, **kwargs)
+ defer.returnValue(rv)
+
+
+def _verify_json_for_server(keyring, server_name, json_object):
+ """thin wrapper around verify_json_for_server which makes sure it is wrapped
+ with the patched defer.inlineCallbacks.
+ """
+ @defer.inlineCallbacks
+ def v():
+ rv1 = yield keyring.verify_json_for_server(server_name, json_object)
+ defer.returnValue(rv1)
- self.assertIs(LoggingContext.current_context(), context_one)
+ return run_in_context(v)
diff --git a/tests/handlers/test_typing.py b/tests/handlers/test_typing.py
index 6460cbc708..5a0b6c201c 100644
--- a/tests/handlers/test_typing.py
+++ b/tests/handlers/test_typing.py
@@ -121,9 +121,9 @@ class TypingNotificationsTestCase(unittest.HomeserverTestCase):
self.datastore.get_joined_hosts_for_room = get_joined_hosts_for_room
- def get_current_user_in_room(room_id):
+ def get_current_users_in_room(room_id):
return set(str(u) for u in self.room_members)
- hs.get_state_handler().get_current_user_in_room = get_current_user_in_room
+ hs.get_state_handler().get_current_users_in_room = get_current_users_in_room
self.datastore.get_user_directory_stream_pos.return_value = (
# we deliberately return a non-None stream pos to avoid doing an initial_spam
diff --git a/tests/rest/client/v1/test_admin.py b/tests/rest/client/v1/test_admin.py
index ef38473bd6..c00ef21d75 100644
--- a/tests/rest/client/v1/test_admin.py
+++ b/tests/rest/client/v1/test_admin.py
@@ -21,6 +21,7 @@ from mock import Mock
from synapse.api.constants import UserTypes
from synapse.rest.client.v1 import admin, events, login, room
+from synapse.rest.client.v2_alpha import groups
from tests import unittest
@@ -490,3 +491,126 @@ class ShutdownRoomTestCase(unittest.HomeserverTestCase):
self.assertEqual(
expect_code, int(channel.result["code"]), msg=channel.result["body"],
)
+
+
+class DeleteGroupTestCase(unittest.HomeserverTestCase):
+ servlets = [
+ admin.register_servlets,
+ login.register_servlets,
+ groups.register_servlets,
+ ]
+
+ def prepare(self, reactor, clock, hs):
+ self.store = hs.get_datastore()
+
+ self.admin_user = self.register_user("admin", "pass", admin=True)
+ self.admin_user_tok = self.login("admin", "pass")
+
+ self.other_user = self.register_user("user", "pass")
+ self.other_user_token = self.login("user", "pass")
+
+ def test_delete_group(self):
+ # Create a new group
+ request, channel = self.make_request(
+ "POST",
+ "/create_group".encode('ascii'),
+ access_token=self.admin_user_tok,
+ content={
+ "localpart": "test",
+ }
+ )
+
+ self.render(request)
+ self.assertEqual(
+ 200, int(channel.result["code"]), msg=channel.result["body"],
+ )
+
+ group_id = channel.json_body["group_id"]
+
+ self._check_group(group_id, expect_code=200)
+
+ # Invite/join another user
+
+ url = "/groups/%s/admin/users/invite/%s" % (group_id, self.other_user)
+ request, channel = self.make_request(
+ "PUT",
+ url.encode('ascii'),
+ access_token=self.admin_user_tok,
+ content={}
+ )
+ self.render(request)
+ self.assertEqual(
+ 200, int(channel.result["code"]), msg=channel.result["body"],
+ )
+
+ url = "/groups/%s/self/accept_invite" % (group_id,)
+ request, channel = self.make_request(
+ "PUT",
+ url.encode('ascii'),
+ access_token=self.other_user_token,
+ content={}
+ )
+ self.render(request)
+ self.assertEqual(
+ 200, int(channel.result["code"]), msg=channel.result["body"],
+ )
+
+ # Check other user knows they're in the group
+ self.assertIn(group_id, self._get_groups_user_is_in(self.admin_user_tok))
+ self.assertIn(group_id, self._get_groups_user_is_in(self.other_user_token))
+
+ # Now delete the group
+ url = "/admin/delete_group/" + group_id
+ request, channel = self.make_request(
+ "POST",
+ url.encode('ascii'),
+ access_token=self.admin_user_tok,
+ content={
+ "localpart": "test",
+ }
+ )
+
+ self.render(request)
+ self.assertEqual(
+ 200, int(channel.result["code"]), msg=channel.result["body"],
+ )
+
+ # Check group returns 404
+ self._check_group(group_id, expect_code=404)
+
+ # Check users don't think they're in the group
+ self.assertNotIn(group_id, self._get_groups_user_is_in(self.admin_user_tok))
+ self.assertNotIn(group_id, self._get_groups_user_is_in(self.other_user_token))
+
+ def _check_group(self, group_id, expect_code):
+ """Assert that trying to fetch the given group results in the given
+ HTTP status code
+ """
+
+ url = "/groups/%s/profile" % (group_id,)
+ request, channel = self.make_request(
+ "GET",
+ url.encode('ascii'),
+ access_token=self.admin_user_tok,
+ )
+
+ self.render(request)
+ self.assertEqual(
+ expect_code, int(channel.result["code"]), msg=channel.result["body"],
+ )
+
+ def _get_groups_user_is_in(self, access_token):
+ """Returns the list of groups the user is in (given their access token)
+ """
+ request, channel = self.make_request(
+ "GET",
+ "/joined_groups".encode('ascii'),
+ access_token=access_token,
+ )
+
+ self.render(request)
+ self.assertEqual(
+ 200, int(channel.result["code"]), msg=channel.result["body"],
+ )
+
+ return channel.json_body["groups"]
diff --git a/tests/storage/test_presence.py b/tests/storage/test_presence.py
deleted file mode 100644
index c7a63f39b9..0000000000
--- a/tests/storage/test_presence.py
+++ /dev/null
@@ -1,118 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2014-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 twisted.internet import defer
-
-from synapse.types import UserID
-
-from tests import unittest
-from tests.utils import setup_test_homeserver
-
-
-class PresenceStoreTestCase(unittest.TestCase):
- @defer.inlineCallbacks
- def setUp(self):
- hs = yield setup_test_homeserver(self.addCleanup)
-
- self.store = hs.get_datastore()
-
- self.u_apple = UserID.from_string("@apple:test")
- self.u_banana = UserID.from_string("@banana:test")
-
- @defer.inlineCallbacks
- def test_presence_list(self):
- self.assertEquals(
- [],
- (
- yield self.store.get_presence_list(
- observer_localpart=self.u_apple.localpart
- )
- ),
- )
- self.assertEquals(
- [],
- (
- yield self.store.get_presence_list(
- observer_localpart=self.u_apple.localpart, accepted=True
- )
- ),
- )
-
- yield self.store.add_presence_list_pending(
- observer_localpart=self.u_apple.localpart,
- observed_userid=self.u_banana.to_string(),
- )
-
- self.assertEquals(
- [{"observed_user_id": "@banana:test", "accepted": 0}],
- (
- yield self.store.get_presence_list(
- observer_localpart=self.u_apple.localpart
- )
- ),
- )
- self.assertEquals(
- [],
- (
- yield self.store.get_presence_list(
- observer_localpart=self.u_apple.localpart, accepted=True
- )
- ),
- )
-
- yield self.store.set_presence_list_accepted(
- observer_localpart=self.u_apple.localpart,
- observed_userid=self.u_banana.to_string(),
- )
-
- self.assertEquals(
- [{"observed_user_id": "@banana:test", "accepted": 1}],
- (
- yield self.store.get_presence_list(
- observer_localpart=self.u_apple.localpart
- )
- ),
- )
- self.assertEquals(
- [{"observed_user_id": "@banana:test", "accepted": 1}],
- (
- yield self.store.get_presence_list(
- observer_localpart=self.u_apple.localpart, accepted=True
- )
- ),
- )
-
- yield self.store.del_presence_list(
- observer_localpart=self.u_apple.localpart,
- observed_userid=self.u_banana.to_string(),
- )
-
- self.assertEquals(
- [],
- (
- yield self.store.get_presence_list(
- observer_localpart=self.u_apple.localpart
- )
- ),
- )
- self.assertEquals(
- [],
- (
- yield self.store.get_presence_list(
- observer_localpart=self.u_apple.localpart, accepted=True
- )
- ),
- )
|
