diff --git a/tests/api/test_filtering.py b/tests/api/test_filtering.py
new file mode 100644
index 0000000000..65b2f590c8
--- /dev/null
+++ b/tests/api/test_filtering.py
@@ -0,0 +1,502 @@
+# -*- coding: utf-8 -*-
+# Copyright 2015 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 collections import namedtuple
+from tests import unittest
+from twisted.internet import defer
+
+from mock import Mock, NonCallableMock
+from tests.utils import (
+ MockHttpResource, DeferredMockCallable, setup_test_homeserver
+)
+
+from synapse.types import UserID
+from synapse.api.filtering import Filter
+
+user_localpart = "test_user"
+MockEvent = namedtuple("MockEvent", "sender type room_id")
+
+class FilteringTestCase(unittest.TestCase):
+
+ @defer.inlineCallbacks
+ def setUp(self):
+ self.mock_federation_resource = MockHttpResource()
+
+ self.mock_http_client = Mock(spec=[])
+ self.mock_http_client.put_json = DeferredMockCallable()
+
+ hs = yield setup_test_homeserver(
+ handlers=None,
+ http_client=self.mock_http_client,
+ keyring=Mock(),
+ )
+
+ self.filtering = hs.get_filtering()
+ self.filter = Filter({})
+
+ self.datastore = hs.get_datastore()
+
+ def test_definition_types_works_with_literals(self):
+ definition = {
+ "types": ["m.room.message", "org.matrix.foo.bar"]
+ }
+ event = MockEvent(
+ sender="@foo:bar",
+ type="m.room.message",
+ room_id="!foo:bar"
+ )
+ self.assertTrue(
+ self.filter._passes_definition(definition, event)
+ )
+
+ def test_definition_types_works_with_wildcards(self):
+ definition = {
+ "types": ["m.*", "org.matrix.foo.bar"]
+ }
+ event = MockEvent(
+ sender="@foo:bar",
+ type="m.room.message",
+ room_id="!foo:bar"
+ )
+ self.assertTrue(
+ self.filter._passes_definition(definition, event)
+ )
+
+ def test_definition_types_works_with_unknowns(self):
+ definition = {
+ "types": ["m.room.message", "org.matrix.foo.bar"]
+ }
+ event = MockEvent(
+ sender="@foo:bar",
+ type="now.for.something.completely.different",
+ room_id="!foo:bar"
+ )
+ self.assertFalse(
+ self.filter._passes_definition(definition, event)
+ )
+
+ def test_definition_not_types_works_with_literals(self):
+ definition = {
+ "not_types": ["m.room.message", "org.matrix.foo.bar"]
+ }
+ event = MockEvent(
+ sender="@foo:bar",
+ type="m.room.message",
+ room_id="!foo:bar"
+ )
+ self.assertFalse(
+ self.filter._passes_definition(definition, event)
+ )
+
+ def test_definition_not_types_works_with_wildcards(self):
+ definition = {
+ "not_types": ["m.room.message", "org.matrix.*"]
+ }
+ event = MockEvent(
+ sender="@foo:bar",
+ type="org.matrix.custom.event",
+ room_id="!foo:bar"
+ )
+ self.assertFalse(
+ self.filter._passes_definition(definition, event)
+ )
+
+ def test_definition_not_types_works_with_unknowns(self):
+ definition = {
+ "not_types": ["m.*", "org.*"]
+ }
+ event = MockEvent(
+ sender="@foo:bar",
+ type="com.nom.nom.nom",
+ room_id="!foo:bar"
+ )
+ self.assertTrue(
+ self.filter._passes_definition(definition, event)
+ )
+
+ def test_definition_not_types_takes_priority_over_types(self):
+ definition = {
+ "not_types": ["m.*", "org.*"],
+ "types": ["m.room.message", "m.room.topic"]
+ }
+ event = MockEvent(
+ sender="@foo:bar",
+ type="m.room.topic",
+ room_id="!foo:bar"
+ )
+ self.assertFalse(
+ self.filter._passes_definition(definition, event)
+ )
+
+ def test_definition_senders_works_with_literals(self):
+ definition = {
+ "senders": ["@flibble:wibble"]
+ }
+ event = MockEvent(
+ sender="@flibble:wibble",
+ type="com.nom.nom.nom",
+ room_id="!foo:bar"
+ )
+ self.assertTrue(
+ self.filter._passes_definition(definition, event)
+ )
+
+ def test_definition_senders_works_with_unknowns(self):
+ definition = {
+ "senders": ["@flibble:wibble"]
+ }
+ event = MockEvent(
+ sender="@challenger:appears",
+ type="com.nom.nom.nom",
+ room_id="!foo:bar"
+ )
+ self.assertFalse(
+ self.filter._passes_definition(definition, event)
+ )
+
+ def test_definition_not_senders_works_with_literals(self):
+ definition = {
+ "not_senders": ["@flibble:wibble"]
+ }
+ event = MockEvent(
+ sender="@flibble:wibble",
+ type="com.nom.nom.nom",
+ room_id="!foo:bar"
+ )
+ self.assertFalse(
+ self.filter._passes_definition(definition, event)
+ )
+
+ def test_definition_not_senders_works_with_unknowns(self):
+ definition = {
+ "not_senders": ["@flibble:wibble"]
+ }
+ event = MockEvent(
+ sender="@challenger:appears",
+ type="com.nom.nom.nom",
+ room_id="!foo:bar"
+ )
+ self.assertTrue(
+ self.filter._passes_definition(definition, event)
+ )
+
+ def test_definition_not_senders_takes_priority_over_senders(self):
+ definition = {
+ "not_senders": ["@misspiggy:muppets"],
+ "senders": ["@kermit:muppets", "@misspiggy:muppets"]
+ }
+ event = MockEvent(
+ sender="@misspiggy:muppets",
+ type="m.room.topic",
+ room_id="!foo:bar"
+ )
+ self.assertFalse(
+ self.filter._passes_definition(definition, event)
+ )
+
+ def test_definition_rooms_works_with_literals(self):
+ definition = {
+ "rooms": ["!secretbase:unknown"]
+ }
+ event = MockEvent(
+ sender="@foo:bar",
+ type="m.room.message",
+ room_id="!secretbase:unknown"
+ )
+ self.assertTrue(
+ self.filter._passes_definition(definition, event)
+ )
+
+ def test_definition_rooms_works_with_unknowns(self):
+ definition = {
+ "rooms": ["!secretbase:unknown"]
+ }
+ event = MockEvent(
+ sender="@foo:bar",
+ type="m.room.message",
+ room_id="!anothersecretbase:unknown"
+ )
+ self.assertFalse(
+ self.filter._passes_definition(definition, event)
+ )
+
+ def test_definition_not_rooms_works_with_literals(self):
+ definition = {
+ "not_rooms": ["!anothersecretbase:unknown"]
+ }
+ event = MockEvent(
+ sender="@foo:bar",
+ type="m.room.message",
+ room_id="!anothersecretbase:unknown"
+ )
+ self.assertFalse(
+ self.filter._passes_definition(definition, event)
+ )
+
+ def test_definition_not_rooms_works_with_unknowns(self):
+ definition = {
+ "not_rooms": ["!secretbase:unknown"]
+ }
+ event = MockEvent(
+ sender="@foo:bar",
+ type="m.room.message",
+ room_id="!anothersecretbase:unknown"
+ )
+ self.assertTrue(
+ self.filter._passes_definition(definition, event)
+ )
+
+ def test_definition_not_rooms_takes_priority_over_rooms(self):
+ definition = {
+ "not_rooms": ["!secretbase:unknown"],
+ "rooms": ["!secretbase:unknown"]
+ }
+ event = MockEvent(
+ sender="@foo:bar",
+ type="m.room.message",
+ room_id="!secretbase:unknown"
+ )
+ self.assertFalse(
+ self.filter._passes_definition(definition, event)
+ )
+
+ def test_definition_combined_event(self):
+ definition = {
+ "not_senders": ["@misspiggy:muppets"],
+ "senders": ["@kermit:muppets"],
+ "rooms": ["!stage:unknown"],
+ "not_rooms": ["!piggyshouse:muppets"],
+ "types": ["m.room.message", "muppets.kermit.*"],
+ "not_types": ["muppets.misspiggy.*"]
+ }
+ event = MockEvent(
+ sender="@kermit:muppets", # yup
+ type="m.room.message", # yup
+ room_id="!stage:unknown" # yup
+ )
+ self.assertTrue(
+ self.filter._passes_definition(definition, event)
+ )
+
+ def test_definition_combined_event_bad_sender(self):
+ definition = {
+ "not_senders": ["@misspiggy:muppets"],
+ "senders": ["@kermit:muppets"],
+ "rooms": ["!stage:unknown"],
+ "not_rooms": ["!piggyshouse:muppets"],
+ "types": ["m.room.message", "muppets.kermit.*"],
+ "not_types": ["muppets.misspiggy.*"]
+ }
+ event = MockEvent(
+ sender="@misspiggy:muppets", # nope
+ type="m.room.message", # yup
+ room_id="!stage:unknown" # yup
+ )
+ self.assertFalse(
+ self.filter._passes_definition(definition, event)
+ )
+
+ def test_definition_combined_event_bad_room(self):
+ definition = {
+ "not_senders": ["@misspiggy:muppets"],
+ "senders": ["@kermit:muppets"],
+ "rooms": ["!stage:unknown"],
+ "not_rooms": ["!piggyshouse:muppets"],
+ "types": ["m.room.message", "muppets.kermit.*"],
+ "not_types": ["muppets.misspiggy.*"]
+ }
+ event = MockEvent(
+ sender="@kermit:muppets", # yup
+ type="m.room.message", # yup
+ room_id="!piggyshouse:muppets" # nope
+ )
+ self.assertFalse(
+ self.filter._passes_definition(definition, event)
+ )
+
+ def test_definition_combined_event_bad_type(self):
+ definition = {
+ "not_senders": ["@misspiggy:muppets"],
+ "senders": ["@kermit:muppets"],
+ "rooms": ["!stage:unknown"],
+ "not_rooms": ["!piggyshouse:muppets"],
+ "types": ["m.room.message", "muppets.kermit.*"],
+ "not_types": ["muppets.misspiggy.*"]
+ }
+ event = MockEvent(
+ sender="@kermit:muppets", # yup
+ type="muppets.misspiggy.kisses", # nope
+ room_id="!stage:unknown" # yup
+ )
+ self.assertFalse(
+ self.filter._passes_definition(definition, event)
+ )
+
+ @defer.inlineCallbacks
+ def test_filter_public_user_data_match(self):
+ user_filter_json = {
+ "public_user_data": {
+ "types": ["m.*"]
+ }
+ }
+ user = UserID.from_string("@" + user_localpart + ":test")
+ filter_id = yield self.datastore.add_user_filter(
+ user_localpart=user_localpart,
+ user_filter=user_filter_json,
+ )
+ event = MockEvent(
+ sender="@foo:bar",
+ type="m.profile",
+ room_id="!foo:bar"
+ )
+ events = [event]
+
+ user_filter = yield self.filtering.get_user_filter(
+ user_localpart=user_localpart,
+ filter_id=filter_id,
+ )
+
+ results = user_filter.filter_public_user_data(events=events)
+ self.assertEquals(events, results)
+
+ @defer.inlineCallbacks
+ def test_filter_public_user_data_no_match(self):
+ user_filter_json = {
+ "public_user_data": {
+ "types": ["m.*"]
+ }
+ }
+ user = UserID.from_string("@" + user_localpart + ":test")
+ filter_id = yield self.datastore.add_user_filter(
+ user_localpart=user_localpart,
+ user_filter=user_filter_json,
+ )
+ event = MockEvent(
+ sender="@foo:bar",
+ type="custom.avatar.3d.crazy",
+ room_id="!foo:bar"
+ )
+ events = [event]
+
+ user_filter = yield self.filtering.get_user_filter(
+ user_localpart=user_localpart,
+ filter_id=filter_id,
+ )
+
+ results = user_filter.filter_public_user_data(events=events)
+ self.assertEquals([], results)
+
+ @defer.inlineCallbacks
+ def test_filter_room_state_match(self):
+ user_filter_json = {
+ "room": {
+ "state": {
+ "types": ["m.*"]
+ }
+ }
+ }
+ user = UserID.from_string("@" + user_localpart + ":test")
+ filter_id = yield self.datastore.add_user_filter(
+ user_localpart=user_localpart,
+ user_filter=user_filter_json,
+ )
+ event = MockEvent(
+ sender="@foo:bar",
+ type="m.room.topic",
+ room_id="!foo:bar"
+ )
+ events = [event]
+
+ user_filter = yield self.filtering.get_user_filter(
+ user_localpart=user_localpart,
+ filter_id=filter_id,
+ )
+
+ results = user_filter.filter_room_state(events=events)
+ self.assertEquals(events, results)
+
+ @defer.inlineCallbacks
+ def test_filter_room_state_no_match(self):
+ user_filter_json = {
+ "room": {
+ "state": {
+ "types": ["m.*"]
+ }
+ }
+ }
+ user = UserID.from_string("@" + user_localpart + ":test")
+ filter_id = yield self.datastore.add_user_filter(
+ user_localpart=user_localpart,
+ user_filter=user_filter_json,
+ )
+ event = MockEvent(
+ sender="@foo:bar",
+ type="org.matrix.custom.event",
+ room_id="!foo:bar"
+ )
+ events = [event]
+
+ user_filter = yield self.filtering.get_user_filter(
+ user_localpart=user_localpart,
+ filter_id=filter_id,
+ )
+
+ results = user_filter.filter_room_state(events)
+ self.assertEquals([], results)
+
+ @defer.inlineCallbacks
+ def test_add_filter(self):
+ user_filter_json = {
+ "room": {
+ "state": {
+ "types": ["m.*"]
+ }
+ }
+ }
+
+ filter_id = yield self.filtering.add_user_filter(
+ user_localpart=user_localpart,
+ user_filter=user_filter_json,
+ )
+
+ self.assertEquals(filter_id, 0)
+ self.assertEquals(user_filter_json,
+ (yield self.datastore.get_user_filter(
+ user_localpart=user_localpart,
+ filter_id=0,
+ ))
+ )
+
+ @defer.inlineCallbacks
+ def test_get_filter(self):
+ user_filter_json = {
+ "room": {
+ "state": {
+ "types": ["m.*"]
+ }
+ }
+ }
+
+ filter_id = yield self.datastore.add_user_filter(
+ user_localpart=user_localpart,
+ user_filter=user_filter_json,
+ )
+
+ filter = yield self.filtering.get_user_filter(
+ user_localpart=user_localpart,
+ filter_id=filter_id,
+ )
+
+ self.assertEquals(filter.filter_json, user_filter_json)
diff --git a/tests/federation/test_federation.py b/tests/federation/test_federation.py
index 3e484cd303..2ecd00d2ad 100644
--- a/tests/federation/test_federation.py
+++ b/tests/federation/test_federation.py
@@ -19,9 +19,8 @@ from tests import unittest
# python imports
from mock import Mock, ANY
-from ..utils import MockHttpResource, MockClock, MockKey
+from ..utils import MockHttpResource, MockClock, setup_test_homeserver
-from synapse.server import HomeServer
from synapse.federation import initialize_http_replication
from synapse.events import FrozenEvent
@@ -40,6 +39,7 @@ def make_pdu(prev_pdus=[], **kwargs):
class FederationTestCase(unittest.TestCase):
+ @defer.inlineCallbacks
def setUp(self):
self.mock_resource = MockHttpResource()
self.mock_http_client = Mock(spec=[
@@ -61,17 +61,12 @@ class FederationTestCase(unittest.TestCase):
defer.succeed(DestinationsTable.EntryType("", 0, 0))
)
self.mock_persistence.get_auth_chain.return_value = []
- self.mock_config = Mock()
- self.mock_config.signing_key = [MockKey()]
self.clock = MockClock()
- hs = HomeServer(
- "test",
+ hs = yield setup_test_homeserver(
resource_for_federation=self.mock_resource,
http_client=self.mock_http_client,
- db_pool=None,
datastore=self.mock_persistence,
clock=self.clock,
- config=self.mock_config,
keyring=Mock(),
)
self.federation = initialize_http_replication(hs)
diff --git a/tests/handlers/test_directory.py b/tests/handlers/test_directory.py
index 8e164e4be0..27306ba427 100644
--- a/tests/handlers/test_directory.py
+++ b/tests/handlers/test_directory.py
@@ -19,10 +19,10 @@ from twisted.internet import defer
from mock import Mock
-from synapse.server import HomeServer
from synapse.handlers.directory import DirectoryHandler
+from synapse.types import RoomAlias
-from tests.utils import SQLiteMemoryDbPool, MockKey
+from tests.utils import setup_test_homeserver
class DirectoryHandlers(object):
@@ -45,19 +45,10 @@ class DirectoryTestCase(unittest.TestCase):
self.query_handlers[query_type] = handler
self.mock_federation.register_query_handler = register_query_handler
- db_pool = SQLiteMemoryDbPool()
- yield db_pool.prepare()
-
- self.mock_config = Mock()
- self.mock_config.signing_key = [MockKey()]
-
- hs = HomeServer(
- "test",
- db_pool=db_pool,
+ hs = yield setup_test_homeserver(
http_client=None,
resource_for_federation=Mock(),
replication_layer=self.mock_federation,
- config=self.mock_config,
)
hs.handlers = DirectoryHandlers(hs)
@@ -65,9 +56,9 @@ class DirectoryTestCase(unittest.TestCase):
self.store = hs.get_datastore()
- self.my_room = hs.parse_roomalias("#my-room:test")
- self.your_room = hs.parse_roomalias("#your-room:test")
- self.remote_room = hs.parse_roomalias("#another:remote")
+ self.my_room = RoomAlias.from_string("#my-room:test")
+ self.your_room = RoomAlias.from_string("#your-room:test")
+ self.remote_room = RoomAlias.from_string("#another:remote")
@defer.inlineCallbacks
def test_get_local_association(self):
diff --git a/tests/handlers/test_federation.py b/tests/handlers/test_federation.py
index ed21defd13..c13ade3286 100644
--- a/tests/handlers/test_federation.py
+++ b/tests/handlers/test_federation.py
@@ -19,20 +19,17 @@ from tests import unittest
from synapse.api.constants import EventTypes
from synapse.events import FrozenEvent
from synapse.handlers.federation import FederationHandler
-from synapse.server import HomeServer
from mock import NonCallableMock, ANY, Mock
-from ..utils import MockKey
+from ..utils import setup_test_homeserver
class FederationTestCase(unittest.TestCase):
+ @defer.inlineCallbacks
def setUp(self):
- self.mock_config = NonCallableMock()
- self.mock_config.signing_key = [MockKey()]
-
self.state_handler = NonCallableMock(spec_set=[
"compute_event_context",
])
@@ -43,15 +40,15 @@ class FederationTestCase(unittest.TestCase):
])
self.hostname = "test"
- hs = HomeServer(
+ hs = yield setup_test_homeserver(
self.hostname,
- db_pool=None,
datastore=NonCallableMock(spec_set=[
"persist_event",
"store_room",
"get_room",
"get_destination_retry_timings",
"set_destination_retry_timings",
+ "have_events",
]),
resource_for_federation=NonCallableMock(),
http_client=NonCallableMock(spec_set=[]),
@@ -60,7 +57,6 @@ class FederationTestCase(unittest.TestCase):
"room_member_handler",
"federation_handler",
]),
- config=self.mock_config,
auth=self.auth,
state_handler=self.state_handler,
keyring=Mock(),
@@ -91,6 +87,10 @@ class FederationTestCase(unittest.TestCase):
self.datastore.get_room.return_value = defer.succeed(True)
self.auth.check_host_in_room.return_value = defer.succeed(True)
+ def have_events(event_ids):
+ return defer.succeed({})
+ self.datastore.have_events.side_effect = have_events
+
def annotate(ev, old_state=None):
context = Mock()
context.current_state = {}
diff --git a/tests/handlers/test_presence.py b/tests/handlers/test_presence.py
index b85a89052a..d88a977be4 100644
--- a/tests/handlers/test_presence.py
+++ b/tests/handlers/test_presence.py
@@ -17,20 +17,19 @@
from tests import unittest
from twisted.internet import defer, reactor
-from mock import Mock, call, ANY, NonCallableMock, patch
+from mock import Mock, call, ANY, NonCallableMock
import json
from tests.utils import (
- MockHttpResource, MockClock, DeferredMockCallable, SQLiteMemoryDbPool,
- MockKey
+ MockHttpResource, MockClock, DeferredMockCallable, setup_test_homeserver
)
-from synapse.server import HomeServer
from synapse.api.constants import PresenceState
from synapse.api.errors import SynapseError
from synapse.handlers.presence import PresenceHandler, UserPresenceCache
from synapse.streams.config import SourcePaginationConfig
from synapse.storage.transactions import DestinationsTable
+from synapse.types import UserID
OFFLINE = PresenceState.OFFLINE
UNAVAILABLE = PresenceState.UNAVAILABLE
@@ -59,68 +58,206 @@ class JustPresenceHandlers(object):
def __init__(self, hs):
self.presence_handler = PresenceHandler(hs)
-class PresenceStateTestCase(unittest.TestCase):
- """ Tests presence management. """
+class PresenceTestCase(unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
- db_pool = SQLiteMemoryDbPool()
- yield db_pool.prepare()
+ self.clock = MockClock()
- self.mock_config = NonCallableMock()
- self.mock_config.signing_key = [MockKey()]
+ self.mock_federation_resource = MockHttpResource()
- hs = HomeServer("test",
- clock=MockClock(),
- db_pool=db_pool,
+ self.mock_http_client = Mock(spec=[])
+ self.mock_http_client.put_json = DeferredMockCallable()
+
+ hs_kwargs = {}
+ if hasattr(self, "make_datastore_mock"):
+ hs_kwargs["datastore"] = self.make_datastore_mock()
+
+ hs = yield setup_test_homeserver(
+ clock=self.clock,
handlers=None,
- resource_for_federation=Mock(),
- http_client=None,
- config=self.mock_config,
+ resource_for_federation=self.mock_federation_resource,
+ http_client=self.mock_http_client,
keyring=Mock(),
+ **hs_kwargs
)
hs.handlers = JustPresenceHandlers(hs)
- self.store = hs.get_datastore()
+ self.datastore = hs.get_datastore()
- # Mock the RoomMemberHandler
- room_member_handler = Mock(spec=[])
- hs.handlers.room_member_handler = room_member_handler
+ self.setUp_roommemberhandler_mocks(hs.handlers)
- # Some local users to test with
- self.u_apple = hs.parse_userid("@apple:test")
- self.u_banana = hs.parse_userid("@banana:test")
- self.u_clementine = hs.parse_userid("@clementine:test")
+ self.handler = hs.get_handlers().presence_handler
+ self.event_source = hs.get_event_sources().sources["presence"]
- yield self.store.create_presence(self.u_apple.localpart)
- yield self.store.set_presence_state(
- self.u_apple.localpart, {"state": ONLINE, "status_msg": "Online"}
- )
+ self.distributor = hs.get_distributor()
+ self.distributor.declare("user_joined_room")
- self.handler = hs.get_handlers().presence_handler
+ yield self.setUp_users(hs)
+ def setUp_roommemberhandler_mocks(self, handlers):
+ self.room_id = "a-room"
self.room_members = []
+ room_member_handler = handlers.room_member_handler = Mock(spec=[
+ "get_rooms_for_user",
+ "get_room_members",
+ "fetch_room_distributions_into",
+ ])
+ self.room_member_handler = room_member_handler
+
def get_rooms_for_user(user):
if user in self.room_members:
- return defer.succeed(["a-room"])
+ return defer.succeed([self.room_id])
else:
return defer.succeed([])
room_member_handler.get_rooms_for_user = get_rooms_for_user
def get_room_members(room_id):
- if room_id == "a-room":
+ if room_id == self.room_id:
return defer.succeed(self.room_members)
else:
return defer.succeed([])
room_member_handler.get_room_members = get_room_members
+ @defer.inlineCallbacks
+ def fetch_room_distributions_into(room_id, localusers=None,
+ remotedomains=None, ignore_user=None):
+
+ members = yield get_room_members(room_id)
+ for member in members:
+ if ignore_user is not None and member == ignore_user:
+ continue
+
+ if member.is_mine:
+ if localusers is not None:
+ localusers.add(member)
+ else:
+ if remotedomains is not None:
+ remotedomains.add(member.domain)
+ room_member_handler.fetch_room_distributions_into = (
+ fetch_room_distributions_into)
+
+ self.setUp_datastore_room_mocks(self.datastore)
+
+ def setUp_datastore_room_mocks(self, datastore):
+ def get_room_hosts(room_id):
+ if room_id == self.room_id:
+ hosts = set([u.domain for u in self.room_members])
+ return defer.succeed(hosts)
+ else:
+ return defer.succeed([])
+ datastore.get_joined_hosts_for_room = get_room_hosts
+
def user_rooms_intersect(userlist):
room_member_ids = map(lambda u: u.to_string(), self.room_members)
shared = all(map(lambda i: i in room_member_ids, userlist))
return defer.succeed(shared)
- self.store.user_rooms_intersect = user_rooms_intersect
+ datastore.user_rooms_intersect = user_rooms_intersect
+
+ @defer.inlineCallbacks
+ def setUp_users(self, hs):
+ # Some local users to test with
+ self.u_apple = UserID.from_string("@apple:test")
+ self.u_banana = UserID.from_string("@banana:test")
+ self.u_clementine = UserID.from_string("@clementine:test")
+
+ for u in self.u_apple, self.u_banana, self.u_clementine:
+ yield self.datastore.create_presence(u.localpart)
+
+ yield self.datastore.set_presence_state(
+ self.u_apple.localpart, {"state": ONLINE, "status_msg": "Online"}
+ )
+
+ # ID of a local user that does not exist
+ self.u_durian = UserID.from_string("@durian:test")
+
+ # A remote user
+ self.u_cabbage = UserID.from_string("@cabbage:elsewhere")
+
+
+class MockedDatastorePresenceTestCase(PresenceTestCase):
+ def make_datastore_mock(self):
+ datastore = Mock(spec=[
+ # Bits that Federation needs
+ "prep_send_transaction",
+ "delivered_txn",
+ "get_received_txn_response",
+ "set_received_txn_response",
+ "get_destination_retry_timings",
+ ])
+
+ self.setUp_datastore_federation_mocks(datastore)
+ self.setUp_datastore_presence_mocks(datastore)
+
+ return datastore
+
+ def setUp_datastore_federation_mocks(self, datastore):
+ datastore.get_destination_retry_timings.return_value = (
+ defer.succeed(DestinationsTable.EntryType("", 0, 0))
+ )
+
+ def get_received_txn_response(*args):
+ return defer.succeed(None)
+ datastore.get_received_txn_response = get_received_txn_response
+
+ def setUp_datastore_presence_mocks(self, datastore):
+ self.current_user_state = {
+ "apple": OFFLINE,
+ "banana": OFFLINE,
+ "clementine": OFFLINE,
+ "fig": OFFLINE,
+ }
+
+ def get_presence_state(user_localpart):
+ return defer.succeed(
+ {"state": self.current_user_state[user_localpart],
+ "status_msg": None,
+ "mtime": 123456000}
+ )
+ datastore.get_presence_state = get_presence_state
+
+ def set_presence_state(user_localpart, new_state):
+ was = self.current_user_state[user_localpart]
+ self.current_user_state[user_localpart] = new_state["state"]
+ return defer.succeed({"state": was})
+ datastore.set_presence_state = set_presence_state
+
+ def get_presence_list(user_localpart, accepted):
+ if not user_localpart in self.PRESENCE_LIST:
+ return defer.succeed([])
+ return defer.succeed([
+ {"observed_user_id": u} for u in
+ self.PRESENCE_LIST[user_localpart]])
+ datastore.get_presence_list = get_presence_list
+
+ def is_presence_visible(observed_localpart, observer_userid):
+ return True
+ datastore.is_presence_visible = is_presence_visible
+
+ @defer.inlineCallbacks
+ def setUp_users(self, hs):
+ # Some local users to test with
+ self.u_apple = UserID.from_string("@apple:test")
+ self.u_banana = UserID.from_string("@banana:test")
+ self.u_clementine = UserID.from_string("@clementine:test")
+ self.u_durian = UserID.from_string("@durian:test")
+ self.u_elderberry = UserID.from_string("@elderberry:test")
+ self.u_fig = UserID.from_string("@fig:test")
+
+ # Remote user
+ self.u_onion = UserID.from_string("@onion:farm")
+ self.u_potato = UserID.from_string("@potato:remote")
+
+ yield
+
+
+class PresenceStateTestCase(PresenceTestCase):
+ """ Tests presence management. """
+ @defer.inlineCallbacks
+ def setUp(self):
+ yield super(PresenceStateTestCase, self).setUp()
self.mock_start = Mock()
self.mock_stop = Mock()
@@ -141,7 +278,7 @@ class PresenceStateTestCase(unittest.TestCase):
@defer.inlineCallbacks
def test_get_allowed_state(self):
- yield self.store.allow_presence_visible(
+ yield self.datastore.allow_presence_visible(
observed_localpart=self.u_apple.localpart,
observer_userid=self.u_banana.to_string(),
)
@@ -189,7 +326,7 @@ class PresenceStateTestCase(unittest.TestCase):
{"state": UNAVAILABLE,
"status_msg": "Away",
"mtime": 1000000},
- (yield self.store.get_presence_state(self.u_apple.localpart))
+ (yield self.datastore.get_presence_state(self.u_apple.localpart))
)
self.mock_start.assert_called_with(self.u_apple,
@@ -206,49 +343,11 @@ class PresenceStateTestCase(unittest.TestCase):
self.mock_stop.assert_called_with(self.u_apple)
-class PresenceInvitesTestCase(unittest.TestCase):
+class PresenceInvitesTestCase(PresenceTestCase):
""" Tests presence management. """
-
@defer.inlineCallbacks
def setUp(self):
- self.mock_http_client = Mock(spec=[])
- self.mock_http_client.put_json = DeferredMockCallable()
-
- self.mock_federation_resource = MockHttpResource()
-
- db_pool = SQLiteMemoryDbPool()
- yield db_pool.prepare()
-
- self.mock_config = NonCallableMock()
- self.mock_config.signing_key = [MockKey()]
-
- hs = HomeServer("test",
- clock=MockClock(),
- db_pool=db_pool,
- handlers=None,
- resource_for_client=Mock(),
- resource_for_federation=self.mock_federation_resource,
- http_client=self.mock_http_client,
- config=self.mock_config,
- keyring=Mock(),
- )
- hs.handlers = JustPresenceHandlers(hs)
-
- self.store = hs.get_datastore()
-
- # Some local users to test with
- self.u_apple = hs.parse_userid("@apple:test")
- self.u_banana = hs.parse_userid("@banana:test")
- yield self.store.create_presence(self.u_apple.localpart)
- yield self.store.create_presence(self.u_banana.localpart)
-
- # ID of a local user that does not exist
- self.u_durian = hs.parse_userid("@durian:test")
-
- # A remote user
- self.u_cabbage = hs.parse_userid("@cabbage:elsewhere")
-
- self.handler = hs.get_handlers().presence_handler
+ yield super(PresenceInvitesTestCase, self).setUp()
self.mock_start = Mock()
self.mock_stop = Mock()
@@ -266,10 +365,10 @@ class PresenceInvitesTestCase(unittest.TestCase):
self.assertEquals(
[{"observed_user_id": "@banana:test", "accepted": 1}],
- (yield self.store.get_presence_list(self.u_apple.localpart))
+ (yield self.datastore.get_presence_list(self.u_apple.localpart))
)
self.assertTrue(
- (yield self.store.is_presence_visible(
+ (yield self.datastore.is_presence_visible(
observed_localpart=self.u_banana.localpart,
observer_userid=self.u_apple.to_string(),
))
@@ -285,7 +384,7 @@ class PresenceInvitesTestCase(unittest.TestCase):
self.assertEquals(
[],
- (yield self.store.get_presence_list(self.u_apple.localpart))
+ (yield self.datastore.get_presence_list(self.u_apple.localpart))
)
@defer.inlineCallbacks
@@ -310,7 +409,7 @@ class PresenceInvitesTestCase(unittest.TestCase):
self.assertEquals(
[{"observed_user_id": "@cabbage:elsewhere", "accepted": 0}],
- (yield self.store.get_presence_list(self.u_apple.localpart))
+ (yield self.datastore.get_presence_list(self.u_apple.localpart))
)
yield put_json.await_calls()
@@ -345,7 +444,7 @@ class PresenceInvitesTestCase(unittest.TestCase):
)
self.assertTrue(
- (yield self.store.is_presence_visible(
+ (yield self.datastore.is_presence_visible(
observed_localpart=self.u_apple.localpart,
observer_userid=self.u_cabbage.to_string(),
))
@@ -384,7 +483,7 @@ class PresenceInvitesTestCase(unittest.TestCase):
@defer.inlineCallbacks
def test_accepted_remote(self):
- yield self.store.add_presence_list_pending(
+ yield self.datastore.add_presence_list_pending(
observer_localpart=self.u_apple.localpart,
observed_userid=self.u_cabbage.to_string(),
)
@@ -401,7 +500,7 @@ class PresenceInvitesTestCase(unittest.TestCase):
self.assertEquals(
[{"observed_user_id": "@cabbage:elsewhere", "accepted": 1}],
- (yield self.store.get_presence_list(self.u_apple.localpart))
+ (yield self.datastore.get_presence_list(self.u_apple.localpart))
)
self.mock_start.assert_called_with(
@@ -409,7 +508,7 @@ class PresenceInvitesTestCase(unittest.TestCase):
@defer.inlineCallbacks
def test_denied_remote(self):
- yield self.store.add_presence_list_pending(
+ yield self.datastore.add_presence_list_pending(
observer_localpart=self.u_apple.localpart,
observed_userid="@eggplant:elsewhere",
)
@@ -426,16 +525,16 @@ class PresenceInvitesTestCase(unittest.TestCase):
self.assertEquals(
[],
- (yield self.store.get_presence_list(self.u_apple.localpart))
+ (yield self.datastore.get_presence_list(self.u_apple.localpart))
)
@defer.inlineCallbacks
def test_drop_local(self):
- yield self.store.add_presence_list_pending(
+ yield self.datastore.add_presence_list_pending(
observer_localpart=self.u_apple.localpart,
observed_userid=self.u_banana.to_string(),
)
- yield self.store.set_presence_list_accepted(
+ yield self.datastore.set_presence_list_accepted(
observer_localpart=self.u_apple.localpart,
observed_userid=self.u_banana.to_string(),
)
@@ -447,7 +546,7 @@ class PresenceInvitesTestCase(unittest.TestCase):
self.assertEquals(
[],
- (yield self.store.get_presence_list(self.u_apple.localpart))
+ (yield self.datastore.get_presence_list(self.u_apple.localpart))
)
self.mock_stop.assert_called_with(
@@ -455,11 +554,11 @@ class PresenceInvitesTestCase(unittest.TestCase):
@defer.inlineCallbacks
def test_drop_remote(self):
- yield self.store.add_presence_list_pending(
+ yield self.datastore.add_presence_list_pending(
observer_localpart=self.u_apple.localpart,
observed_userid=self.u_cabbage.to_string(),
)
- yield self.store.set_presence_list_accepted(
+ yield self.datastore.set_presence_list_accepted(
observer_localpart=self.u_apple.localpart,
observed_userid=self.u_cabbage.to_string(),
)
@@ -471,16 +570,16 @@ class PresenceInvitesTestCase(unittest.TestCase):
self.assertEquals(
[],
- (yield self.store.get_presence_list(self.u_apple.localpart))
+ (yield self.datastore.get_presence_list(self.u_apple.localpart))
)
@defer.inlineCallbacks
def test_get_presence_list(self):
- yield self.store.add_presence_list_pending(
+ yield self.datastore.add_presence_list_pending(
observer_localpart=self.u_apple.localpart,
observed_userid=self.u_banana.to_string(),
)
- yield self.store.set_presence_list_accepted(
+ yield self.datastore.set_presence_list_accepted(
observer_localpart=self.u_apple.localpart,
observed_userid=self.u_banana.to_string(),
)
@@ -495,7 +594,7 @@ class PresenceInvitesTestCase(unittest.TestCase):
], presence)
-class PresencePushTestCase(unittest.TestCase):
+class PresencePushTestCase(MockedDatastorePresenceTestCase):
""" Tests steady-state presence status updates.
They assert that presence state update messages are pushed around the place
@@ -505,138 +604,9 @@ class PresencePushTestCase(unittest.TestCase):
presence handler; namely the _local_pushmap and _remote_recvmap.
BE WARNED...
"""
- def setUp(self):
- self.clock = MockClock()
-
- self.mock_http_client = Mock(spec=[])
- self.mock_http_client.put_json = DeferredMockCallable()
-
- self.mock_federation_resource = MockHttpResource()
-
- self.mock_config = NonCallableMock()
- self.mock_config.signing_key = [MockKey()]
-
- hs = HomeServer("test",
- clock=self.clock,
- db_pool=None,
- datastore=Mock(spec=[
- "set_presence_state",
- "get_joined_hosts_for_room",
-
- # Bits that Federation needs
- "prep_send_transaction",
- "delivered_txn",
- "get_received_txn_response",
- "set_received_txn_response",
- "get_destination_retry_timings",
- ]),
- handlers=None,
- resource_for_client=Mock(),
- resource_for_federation=self.mock_federation_resource,
- http_client=self.mock_http_client,
- config=self.mock_config,
- keyring=Mock(),
- )
- hs.handlers = JustPresenceHandlers(hs)
-
- self.datastore = hs.get_datastore()
- self.datastore.get_destination_retry_timings.return_value = (
- defer.succeed(DestinationsTable.EntryType("", 0, 0))
- )
-
- def get_received_txn_response(*args):
- return defer.succeed(None)
- self.datastore.get_received_txn_response = get_received_txn_response
-
- self.handler = hs.get_handlers().presence_handler
- self.event_source = hs.get_event_sources().sources["presence"]
-
- # Mock the RoomMemberHandler
- hs.handlers.room_member_handler = Mock(spec=[
- "get_rooms_for_user",
- "get_room_members",
- ])
- self.room_member_handler = hs.handlers.room_member_handler
-
- self.room_members = []
-
- def get_rooms_for_user(user):
- if user in self.room_members:
- return defer.succeed(["a-room"])
- else:
- return defer.succeed([])
- self.room_member_handler.get_rooms_for_user = get_rooms_for_user
-
- def get_room_members(room_id):
- if room_id == "a-room":
- return defer.succeed(self.room_members)
- else:
- return defer.succeed([])
- self.room_member_handler.get_room_members = get_room_members
-
- def get_room_hosts(room_id):
- if room_id == "a-room":
- hosts = set([u.domain for u in self.room_members])
- return defer.succeed(hosts)
- else:
- return defer.succeed([])
- self.datastore.get_joined_hosts_for_room = get_room_hosts
-
- def user_rooms_intersect(userlist):
- room_member_ids = map(lambda u: u.to_string(), self.room_members)
-
- shared = all(map(lambda i: i in room_member_ids, userlist))
- return defer.succeed(shared)
- self.datastore.user_rooms_intersect = user_rooms_intersect
-
- @defer.inlineCallbacks
- def fetch_room_distributions_into(room_id, localusers=None,
- remotedomains=None, ignore_user=None):
-
- members = yield get_room_members(room_id)
- for member in members:
- if ignore_user is not None and member == ignore_user:
- continue
-
- if member.is_mine:
- if localusers is not None:
- localusers.add(member)
- else:
- if remotedomains is not None:
- remotedomains.add(member.domain)
- self.room_member_handler.fetch_room_distributions_into = (
- fetch_room_distributions_into)
-
- def get_presence_list(user_localpart, accepted=None):
- if user_localpart == "apple":
- return defer.succeed([
- {"observed_user_id": "@banana:test"},
- {"observed_user_id": "@clementine:test"},
- ])
- else:
- return defer.succeed([])
- self.datastore.get_presence_list = get_presence_list
-
- def is_presence_visible(observer_userid, observed_localpart):
- if (observed_localpart == "clementine" and
- observer_userid == "@banana:test"):
- return False
- return False
- self.datastore.is_presence_visible = is_presence_visible
-
- self.distributor = hs.get_distributor()
- self.distributor.declare("user_joined_room")
-
- # Some local users to test with
- self.u_apple = hs.parse_userid("@apple:test")
- self.u_banana = hs.parse_userid("@banana:test")
- self.u_clementine = hs.parse_userid("@clementine:test")
- self.u_durian = hs.parse_userid("@durian:test")
- self.u_elderberry = hs.parse_userid("@elderberry:test")
-
- # Remote user
- self.u_onion = hs.parse_userid("@onion:farm")
- self.u_potato = hs.parse_userid("@potato:remote")
+ PRESENCE_LIST = {
+ 'apple': [ "@banana:test", "@clementine:test" ],
+ }
@defer.inlineCallbacks
def test_push_local(self):
@@ -911,7 +881,7 @@ class PresencePushTestCase(unittest.TestCase):
)
yield self.distributor.fire("user_joined_room", self.u_clementine,
- "a-room"
+ self.room_id
)
self.room_members.append(self.u_clementine)
@@ -974,7 +944,7 @@ class PresencePushTestCase(unittest.TestCase):
self.room_members = [self.u_apple, self.u_banana]
yield self.distributor.fire("user_joined_room", self.u_potato,
- "a-room"
+ self.room_id
)
yield put_json.await_calls()
@@ -1003,13 +973,13 @@ class PresencePushTestCase(unittest.TestCase):
self.room_members.append(self.u_potato)
yield self.distributor.fire("user_joined_room", self.u_clementine,
- "a-room"
+ self.room_id
)
put_json.await_calls()
-class PresencePollingTestCase(unittest.TestCase):
+class PresencePollingTestCase(MockedDatastorePresenceTestCase):
""" Tests presence status polling. """
# For this test, we have three local users; apple is watching and is
@@ -1022,106 +992,18 @@ class PresencePollingTestCase(unittest.TestCase):
'fig': [ "@potato:remote" ],
}
-
+ @defer.inlineCallbacks
def setUp(self):
- self.mock_http_client = Mock(spec=[])
- self.mock_http_client.put_json = DeferredMockCallable()
-
- self.mock_federation_resource = MockHttpResource()
-
- self.mock_config = NonCallableMock()
- self.mock_config.signing_key = [MockKey()]
-
- hs = HomeServer("test",
- clock=MockClock(),
- db_pool=None,
- datastore=Mock(spec=[
- # Bits that Federation needs
- "prep_send_transaction",
- "delivered_txn",
- "get_received_txn_response",
- "set_received_txn_response",
- "get_destination_retry_timings",
- ]),
- handlers=None,
- resource_for_client=Mock(),
- resource_for_federation=self.mock_federation_resource,
- http_client=self.mock_http_client,
- config=self.mock_config,
- keyring=Mock(),
- )
- hs.handlers = JustPresenceHandlers(hs)
-
- self.datastore = hs.get_datastore()
- self.datastore.get_destination_retry_timings.return_value = (
- defer.succeed(DestinationsTable.EntryType("", 0, 0))
- )
-
- def get_received_txn_response(*args):
- return defer.succeed(None)
- self.datastore.get_received_txn_response = get_received_txn_response
+ yield super(PresencePollingTestCase, self).setUp()
self.mock_update_client = Mock()
def update(*args,**kwargs):
- # print "mock_update_client: Args=%s, kwargs=%s" %(args, kwargs,)
return defer.succeed(None)
-
self.mock_update_client.side_effect = update
- self.handler = hs.get_handlers().presence_handler
self.handler.push_update_to_clients = self.mock_update_client
- hs.handlers.room_member_handler = Mock(spec=[
- "get_rooms_for_user",
- ])
- # For this test no users are ever in rooms
- def get_rooms_for_user(user):
- return defer.succeed([])
- hs.handlers.room_member_handler.get_rooms_for_user = get_rooms_for_user
-
- # Mocked database state
- # Local users always start offline
- self.current_user_state = {
- "apple": OFFLINE,
- "banana": OFFLINE,
- "clementine": OFFLINE,
- "fig": OFFLINE,
- }
-
- def get_presence_state(user_localpart):
- return defer.succeed(
- {"state": self.current_user_state[user_localpart],
- "status_msg": None,
- "mtime": 123456000}
- )
- self.datastore.get_presence_state = get_presence_state
-
- def set_presence_state(user_localpart, new_state):
- was = self.current_user_state[user_localpart]
- self.current_user_state[user_localpart] = new_state["state"]
- return defer.succeed({"state": was})
- self.datastore.set_presence_state = set_presence_state
-
- def get_presence_list(user_localpart, accepted):
- return defer.succeed([
- {"observed_user_id": u} for u in
- self.PRESENCE_LIST[user_localpart]])
- self.datastore.get_presence_list = get_presence_list
-
- def is_presence_visible(observed_localpart, observer_userid):
- return True
- self.datastore.is_presence_visible = is_presence_visible
-
- # Local users
- self.u_apple = hs.parse_userid("@apple:test")
- self.u_banana = hs.parse_userid("@banana:test")
- self.u_clementine = hs.parse_userid("@clementine:test")
- self.u_fig = hs.parse_userid("@fig:test")
-
- # Remote users
- self.u_potato = hs.parse_userid("@potato:remote")
-
@defer.inlineCallbacks
def test_push_local(self):
# apple goes online
diff --git a/tests/handlers/test_presencelike.py b/tests/handlers/test_presencelike.py
index 0584e4c8b9..18cac9a846 100644
--- a/tests/handlers/test_presencelike.py
+++ b/tests/handlers/test_presencelike.py
@@ -21,12 +21,12 @@ from twisted.internet import defer
from mock import Mock, call, ANY, NonCallableMock
-from ..utils import MockClock, MockKey
+from ..utils import MockClock, setup_test_homeserver
-from synapse.server import HomeServer
from synapse.api.constants import PresenceState
from synapse.handlers.presence import PresenceHandler
from synapse.handlers.profile import ProfileHandler
+from synapse.types import UserID
OFFLINE = PresenceState.OFFLINE
@@ -56,29 +56,23 @@ class PresenceAndProfileHandlers(object):
class PresenceProfilelikeDataTestCase(unittest.TestCase):
+ @defer.inlineCallbacks
def setUp(self):
- self.mock_config = Mock()
- self.mock_config.signing_key = [MockKey()]
-
- hs = HomeServer("test",
- clock=MockClock(),
- db_pool=None,
- datastore=Mock(spec=[
- "set_presence_state",
- "is_presence_visible",
-
- "set_profile_displayname",
-
- "get_rooms_for_user_where_membership_is",
- ]),
- handlers=None,
- resource_for_federation=Mock(),
- http_client=None,
- replication_layer=MockReplication(),
- ratelimiter=NonCallableMock(spec_set=[
+ hs = yield setup_test_homeserver(
+ clock=MockClock(),
+ datastore=Mock(spec=[
+ "set_presence_state",
+ "is_presence_visible",
+ "set_profile_displayname",
+ "get_rooms_for_user_where_membership_is",
+ ]),
+ handlers=None,
+ resource_for_federation=Mock(),
+ http_client=None,
+ replication_layer=MockReplication(),
+ ratelimiter=NonCallableMock(spec_set=[
"send_message",
- ]),
- config=self.mock_config
+ ]),
)
self.ratelimiter = hs.get_ratelimiter()
self.ratelimiter.send_message.return_value = (True, 0)
@@ -136,12 +130,12 @@ class PresenceProfilelikeDataTestCase(unittest.TestCase):
lambda u: defer.succeed([]))
# Some local users to test with
- self.u_apple = hs.parse_userid("@apple:test")
- self.u_banana = hs.parse_userid("@banana:test")
- self.u_clementine = hs.parse_userid("@clementine:test")
+ self.u_apple = UserID.from_string("@apple:test")
+ self.u_banana = UserID.from_string("@banana:test")
+ self.u_clementine = UserID.from_string("@clementine:test")
# Remote user
- self.u_potato = hs.parse_userid("@potato:remote")
+ self.u_potato = UserID.from_string("@potato:remote")
self.mock_get_joined = (
self.datastore.get_rooms_for_user_where_membership_is
diff --git a/tests/handlers/test_profile.py b/tests/handlers/test_profile.py
index 25b172aa5e..31f03d73df 100644
--- a/tests/handlers/test_profile.py
+++ b/tests/handlers/test_profile.py
@@ -20,11 +20,10 @@ from twisted.internet import defer
from mock import Mock, NonCallableMock
from synapse.api.errors import AuthError
-from synapse.server import HomeServer
from synapse.handlers.profile import ProfileHandler
-from synapse.api.constants import Membership
+from synapse.types import UserID
-from tests.utils import SQLiteMemoryDbPool, MockKey
+from tests.utils import setup_test_homeserver
class ProfileHandlers(object):
@@ -46,23 +45,15 @@ class ProfileTestCase(unittest.TestCase):
self.query_handlers[query_type] = handler
self.mock_federation.register_query_handler = register_query_handler
- db_pool = SQLiteMemoryDbPool()
- yield db_pool.prepare()
-
- self.mock_config = Mock()
- self.mock_config.signing_key = [MockKey()]
-
- hs = HomeServer("test",
- db_pool=db_pool,
- http_client=None,
- handlers=None,
- resource_for_federation=Mock(),
- replication_layer=self.mock_federation,
- config=self.mock_config,
- ratelimiter=NonCallableMock(spec_set=[
- "send_message",
- ])
- )
+ hs = yield setup_test_homeserver(
+ http_client=None,
+ handlers=None,
+ resource_for_federation=Mock(),
+ replication_layer=self.mock_federation,
+ ratelimiter=NonCallableMock(spec_set=[
+ "send_message",
+ ])
+ )
self.ratelimiter = hs.get_ratelimiter()
self.ratelimiter.send_message.return_value = (True, 0)
@@ -71,9 +62,9 @@ class ProfileTestCase(unittest.TestCase):
self.store = hs.get_datastore()
- self.frank = hs.parse_userid("@1234ABCD:test")
- self.bob = hs.parse_userid("@4567:test")
- self.alice = hs.parse_userid("@alice:remote")
+ self.frank = UserID.from_string("@1234ABCD:test")
+ self.bob = UserID.from_string("@4567:test")
+ self.alice = UserID.from_string("@alice:remote")
yield self.store.create_profile(self.frank.localpart)
diff --git a/tests/handlers/test_room.py b/tests/handlers/test_room.py
index 0cb8aa4fbc..6417f73309 100644
--- a/tests/handlers/test_room.py
+++ b/tests/handlers/test_room.py
@@ -15,27 +15,24 @@
from twisted.internet import defer
-from tests import unittest
+from .. import unittest
from synapse.api.constants import EventTypes, Membership
from synapse.handlers.room import RoomMemberHandler, RoomCreationHandler
from synapse.handlers.profile import ProfileHandler
-from synapse.server import HomeServer
-from ..utils import MockKey
+from synapse.types import UserID
+from ..utils import setup_test_homeserver
from mock import Mock, NonCallableMock
class RoomMemberHandlerTestCase(unittest.TestCase):
+ @defer.inlineCallbacks
def setUp(self):
- self.mock_config = NonCallableMock()
- self.mock_config.signing_key = [MockKey()]
-
self.hostname = "red"
- hs = HomeServer(
+ hs = yield setup_test_homeserver(
self.hostname,
- db_pool=None,
ratelimiter=NonCallableMock(spec_set=[
"send_message",
]),
@@ -63,7 +60,6 @@ class RoomMemberHandlerTestCase(unittest.TestCase):
"compute_event_context",
"get_current_state",
]),
- config=self.mock_config,
)
self.federation = NonCallableMock(spec_set=[
@@ -164,7 +160,7 @@ class RoomMemberHandlerTestCase(unittest.TestCase):
event, context=context,
)
self.notifier.on_new_room_event.assert_called_once_with(
- event, extra_users=[self.hs.parse_userid(target_user_id)]
+ event, extra_users=[UserID.from_string(target_user_id)]
)
self.assertFalse(self.datastore.get_room.called)
self.assertFalse(self.datastore.store_room.called)
@@ -174,7 +170,7 @@ class RoomMemberHandlerTestCase(unittest.TestCase):
def test_simple_join(self):
room_id = "!foo:red"
user_id = "@bob:red"
- user = self.hs.parse_userid(user_id)
+ user = UserID.from_string(user_id)
join_signal_observer = Mock()
self.distributor.observe("user_joined_room", join_signal_observer)
@@ -223,7 +219,7 @@ class RoomMemberHandlerTestCase(unittest.TestCase):
yield room_handler.change_membership(event, context)
self.federation.handle_new_event.assert_called_once_with(
- event, None, destinations=set()
+ event, destinations=set()
)
self.datastore.persist_event.assert_called_once_with(
@@ -252,7 +248,7 @@ class RoomMemberHandlerTestCase(unittest.TestCase):
def test_simple_leave(self):
room_id = "!foo:red"
user_id = "@bob:red"
- user = self.hs.parse_userid(user_id)
+ user = UserID.from_string(user_id)
builder = self.hs.get_event_builder_factory().new({
"type": EventTypes.Member,
@@ -301,7 +297,7 @@ class RoomMemberHandlerTestCase(unittest.TestCase):
yield room_handler.change_membership(event, context)
self.federation.handle_new_event.assert_called_once_with(
- event, None, destinations=set(['red'])
+ event, destinations=set(['red'])
)
self.datastore.persist_event.assert_called_once_with(
@@ -318,15 +314,12 @@ class RoomMemberHandlerTestCase(unittest.TestCase):
class RoomCreationTest(unittest.TestCase):
+ @defer.inlineCallbacks
def setUp(self):
self.hostname = "red"
- self.mock_config = NonCallableMock()
- self.mock_config.signing_key = [MockKey()]
-
- hs = HomeServer(
+ hs = yield setup_test_homeserver(
self.hostname,
- db_pool=None,
datastore=NonCallableMock(spec_set=[
"store_room",
"snapshot_room",
@@ -343,7 +336,6 @@ class RoomCreationTest(unittest.TestCase):
ratelimiter=NonCallableMock(spec_set=[
"send_message",
]),
- config=self.mock_config,
)
self.federation = NonCallableMock(spec_set=[
diff --git a/tests/handlers/test_typing.py b/tests/handlers/test_typing.py
index 0d4b368a43..bf34b7ccbd 100644
--- a/tests/handlers/test_typing.py
+++ b/tests/handlers/test_typing.py
@@ -20,13 +20,15 @@ from twisted.internet import defer
from mock import Mock, call, ANY
import json
-from ..utils import MockHttpResource, MockClock, DeferredMockCallable, MockKey
+from ..utils import (
+ MockHttpResource, MockClock, DeferredMockCallable, setup_test_homeserver
+)
from synapse.api.errors import AuthError
-from synapse.server import HomeServer
from synapse.handlers.typing import TypingNotificationHandler
from synapse.storage.transactions import DestinationsTable
+from synapse.types import UserID
def _expect_edu(destination, edu_type, content, origin="test"):
@@ -55,6 +57,7 @@ class JustTypingNotificationHandlers(object):
class TypingNotificationsTestCase(unittest.TestCase):
"""Tests typing notifications to rooms."""
+ @defer.inlineCallbacks
def setUp(self):
self.clock = MockClock()
@@ -63,34 +66,29 @@ class TypingNotificationsTestCase(unittest.TestCase):
self.mock_federation_resource = MockHttpResource()
- self.mock_config = Mock()
- self.mock_config.signing_key = [MockKey()]
-
mock_notifier = Mock(spec=["on_new_user_event"])
self.on_new_user_event = mock_notifier.on_new_user_event
self.auth = Mock(spec=[])
- hs = HomeServer("test",
- auth=self.auth,
- clock=self.clock,
- db_pool=None,
- datastore=Mock(spec=[
- # Bits that Federation needs
- "prep_send_transaction",
- "delivered_txn",
- "get_received_txn_response",
- "set_received_txn_response",
- "get_destination_retry_timings",
- ]),
- handlers=None,
- notifier=mock_notifier,
- resource_for_client=Mock(),
- resource_for_federation=self.mock_federation_resource,
- http_client=self.mock_http_client,
- config=self.mock_config,
- keyring=Mock(),
- )
+ hs = yield setup_test_homeserver(
+ auth=self.auth,
+ clock=self.clock,
+ datastore=Mock(spec=[
+ # Bits that Federation needs
+ "prep_send_transaction",
+ "delivered_txn",
+ "get_received_txn_response",
+ "set_received_txn_response",
+ "get_destination_retry_timings",
+ ]),
+ handlers=None,
+ notifier=mock_notifier,
+ resource_for_client=Mock(),
+ resource_for_federation=self.mock_federation_resource,
+ http_client=self.mock_http_client,
+ keyring=Mock(),
+ )
hs.handlers = JustTypingNotificationHandlers(hs)
self.handler = hs.get_handlers().typing_notification_handler
@@ -153,11 +151,11 @@ class TypingNotificationsTestCase(unittest.TestCase):
self.auth.check_joined_room = check_joined_room
# Some local users to test with
- self.u_apple = hs.parse_userid("@apple:test")
- self.u_banana = hs.parse_userid("@banana:test")
+ self.u_apple = UserID.from_string("@apple:test")
+ self.u_banana = UserID.from_string("@banana:test")
# Remote user
- self.u_onion = hs.parse_userid("@onion:farm")
+ self.u_onion = UserID.from_string("@onion:farm")
@defer.inlineCallbacks
def test_started_typing_local(self):
@@ -352,3 +350,29 @@ class TypingNotificationsTestCase(unittest.TestCase):
}},
]
)
+
+ # SYN-230 - see if we can still set after timeout
+
+ yield self.handler.started_typing(
+ target_user=self.u_apple,
+ auth_user=self.u_apple,
+ room_id=self.room_id,
+ timeout=10000,
+ )
+
+ self.on_new_user_event.assert_has_calls([
+ call(rooms=[self.room_id]),
+ ])
+ self.on_new_user_event.reset_mock()
+
+ self.assertEquals(self.event_source.get_current_key(), 3)
+ self.assertEquals(
+ self.event_source.get_new_events_for_user(self.u_apple, 0, None)[0],
+ [
+ {"type": "m.typing",
+ "room_id": self.room_id,
+ "content": {
+ "user_ids": [self.u_apple.to_string()],
+ }},
+ ]
+ )
diff --git a/tests/rest/__init__.py b/tests/rest/__init__.py
index 9bff9ec169..1a84d94cd9 100644
--- a/tests/rest/__init__.py
+++ b/tests/rest/__init__.py
@@ -1,5 +1,5 @@
# -*- coding: utf-8 -*-
-# Copyright 2014 OpenMarket Ltd
+# Copyright 2015 OpenMarket Ltd
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
@@ -12,4 +12,3 @@
# 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.
-
diff --git a/tests/rest/client/__init__.py b/tests/rest/client/__init__.py
new file mode 100644
index 0000000000..1a84d94cd9
--- /dev/null
+++ b/tests/rest/client/__init__.py
@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+# Copyright 2015 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.
diff --git a/tests/rest/client/v1/__init__.py b/tests/rest/client/v1/__init__.py
new file mode 100644
index 0000000000..9bff9ec169
--- /dev/null
+++ b/tests/rest/client/v1/__init__.py
@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+# Copyright 2014 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.
+
diff --git a/tests/rest/test_events.py b/tests/rest/client/v1/test_events.py
index d3159e2cf4..f36340121d 100644
--- a/tests/rest/test_events.py
+++ b/tests/rest/client/v1/test_events.py
@@ -19,13 +19,12 @@ from tests import unittest
# twisted imports
from twisted.internet import defer
-import synapse.rest.events
-import synapse.rest.register
-import synapse.rest.room
+import synapse.rest.client.v1.events
+import synapse.rest.client.v1.register
+import synapse.rest.client.v1.room
-from synapse.server import HomeServer
-from ..utils import MockHttpResource, SQLiteMemoryDbPool, MockKey
+from ....utils import MockHttpResource, setup_test_homeserver
from .utils import RestTestCase
from mock import Mock, NonCallableMock
@@ -113,15 +112,7 @@ class EventStreamPermissionsTestCase(RestTestCase):
def setUp(self):
self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
- self.mock_config = NonCallableMock()
- self.mock_config.signing_key = [MockKey()]
-
- db_pool = SQLiteMemoryDbPool()
- yield db_pool.prepare()
-
- hs = HomeServer(
- "test",
- db_pool=db_pool,
+ hs = yield setup_test_homeserver(
http_client=None,
replication_layer=Mock(),
clock=Mock(spec=[
@@ -133,7 +124,6 @@ class EventStreamPermissionsTestCase(RestTestCase):
ratelimiter=NonCallableMock(spec_set=[
"send_message",
]),
- config=self.mock_config,
)
self.ratelimiter = hs.get_ratelimiter()
self.ratelimiter.send_message.return_value = (True, 0)
@@ -144,9 +134,9 @@ class EventStreamPermissionsTestCase(RestTestCase):
hs.get_clock().time_msec.return_value = 1000000
hs.get_clock().time.return_value = 1000
- synapse.rest.register.register_servlets(hs, self.mock_resource)
- synapse.rest.events.register_servlets(hs, self.mock_resource)
- synapse.rest.room.register_servlets(hs, self.mock_resource)
+ synapse.rest.client.v1.register.register_servlets(hs, self.mock_resource)
+ synapse.rest.client.v1.events.register_servlets(hs, self.mock_resource)
+ synapse.rest.client.v1.room.register_servlets(hs, self.mock_resource)
# register an account
self.user_id = "sid1"
diff --git a/tests/rest/test_presence.py b/tests/rest/client/v1/test_presence.py
index 769c7824bc..c1acba5a09 100644
--- a/tests/rest/test_presence.py
+++ b/tests/rest/client/v1/test_presence.py
@@ -20,11 +20,13 @@ from twisted.internet import defer
from mock import Mock
-from ..utils import MockHttpResource, MockKey
+from ....utils import MockHttpResource, setup_test_homeserver
from synapse.api.constants import PresenceState
from synapse.handlers.presence import PresenceHandler
-from synapse.server import HomeServer
+from synapse.rest.client.v1 import presence
+from synapse.rest.client.v1 import events
+from synapse.types import UserID
OFFLINE = PresenceState.OFFLINE
@@ -43,12 +45,10 @@ class JustPresenceHandlers(object):
class PresenceStateTestCase(unittest.TestCase):
+ @defer.inlineCallbacks
def setUp(self):
self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
- self.mock_config = Mock()
- self.mock_config.signing_key = [MockKey()]
- hs = HomeServer("test",
- db_pool=None,
+ hs = yield setup_test_homeserver(
datastore=Mock(spec=[
"get_presence_state",
"set_presence_state",
@@ -57,7 +57,6 @@ class PresenceStateTestCase(unittest.TestCase):
http_client=None,
resource_for_client=self.mock_resource,
resource_for_federation=self.mock_resource,
- config=self.mock_config,
)
hs.handlers = JustPresenceHandlers(hs)
@@ -69,9 +68,10 @@ class PresenceStateTestCase(unittest.TestCase):
def _get_user_by_token(token=None):
return {
- "user": hs.parse_userid(myid),
+ "user": UserID.from_string(myid),
"admin": False,
"device_id": None,
+ "token_id": 1,
}
hs.get_auth().get_user_by_token = _get_user_by_token
@@ -86,9 +86,9 @@ class PresenceStateTestCase(unittest.TestCase):
return defer.succeed([])
room_member_handler.get_rooms_for_user = get_rooms_for_user
- hs.register_servlets()
+ presence.register_servlets(hs, self.mock_resource)
- self.u_apple = hs.parse_userid(myid)
+ self.u_apple = UserID.from_string(myid)
@defer.inlineCallbacks
def test_get_my_status(self):
@@ -124,13 +124,11 @@ class PresenceStateTestCase(unittest.TestCase):
class PresenceListTestCase(unittest.TestCase):
+ @defer.inlineCallbacks
def setUp(self):
self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
- self.mock_config = Mock()
- self.mock_config.signing_key = [MockKey()]
- hs = HomeServer("test",
- db_pool=None,
+ hs = yield setup_test_homeserver(
datastore=Mock(spec=[
"has_presence_state",
"get_presence_state",
@@ -145,7 +143,6 @@ class PresenceListTestCase(unittest.TestCase):
http_client=None,
resource_for_client=self.mock_resource,
resource_for_federation=self.mock_resource,
- config=self.mock_config,
)
hs.handlers = JustPresenceHandlers(hs)
@@ -159,12 +156,13 @@ class PresenceListTestCase(unittest.TestCase):
def _get_user_by_token(token=None):
return {
- "user": hs.parse_userid(myid),
+ "user": UserID.from_string(myid),
"admin": False,
"device_id": None,
+ "token_id": 1,
}
- room_member_handler = hs.handlers.room_member_handler = Mock(
+ hs.handlers.room_member_handler = Mock(
spec=[
"get_rooms_for_user",
]
@@ -172,10 +170,10 @@ class PresenceListTestCase(unittest.TestCase):
hs.get_auth().get_user_by_token = _get_user_by_token
- hs.register_servlets()
+ presence.register_servlets(hs, self.mock_resource)
- self.u_apple = hs.parse_userid("@apple:test")
- self.u_banana = hs.parse_userid("@banana:test")
+ self.u_apple = UserID.from_string("@apple:test")
+ self.u_banana = UserID.from_string("@banana:test")
@defer.inlineCallbacks
def test_get_my_list(self):
@@ -237,12 +235,10 @@ class PresenceListTestCase(unittest.TestCase):
class PresenceEventStreamTestCase(unittest.TestCase):
+ @defer.inlineCallbacks
def setUp(self):
self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
- self.mock_config = Mock()
- self.mock_config.signing_key = [MockKey()]
-
# HIDEOUS HACKERY
# TODO(paul): This should be injected in via the HomeServer DI system
from synapse.streams.events import (
@@ -259,8 +255,7 @@ class PresenceEventStreamTestCase(unittest.TestCase):
}
EventSources.SOURCE_TYPES["presence"] = PresenceEventSource
- hs = HomeServer("test",
- db_pool=None,
+ hs = yield setup_test_homeserver(
http_client=None,
resource_for_client=self.mock_resource,
resource_for_federation=self.mock_resource,
@@ -273,17 +268,17 @@ class PresenceEventStreamTestCase(unittest.TestCase):
"cancel_call_later",
"time_msec",
]),
- config=self.mock_config,
)
hs.get_clock().time_msec.return_value = 1000000
def _get_user_by_req(req=None):
- return hs.parse_userid(myid)
+ return (UserID.from_string(myid), "")
hs.get_auth().get_user_by_req = _get_user_by_req
- hs.register_servlets()
+ presence.register_servlets(hs, self.mock_resource)
+ events.register_servlets(hs, self.mock_resource)
hs.handlers.room_member_handler = Mock(spec=[])
@@ -319,8 +314,8 @@ class PresenceEventStreamTestCase(unittest.TestCase):
self.presence = hs.get_handlers().presence_handler
- self.u_apple = hs.parse_userid("@apple:test")
- self.u_banana = hs.parse_userid("@banana:test")
+ self.u_apple = UserID.from_string("@apple:test")
+ self.u_banana = UserID.from_string("@banana:test")
@defer.inlineCallbacks
def test_shortpoll(self):
diff --git a/tests/rest/test_profile.py b/tests/rest/client/v1/test_profile.py
index 3a0d1e700a..5cd5767f2e 100644
--- a/tests/rest/test_profile.py
+++ b/tests/rest/client/v1/test_profile.py
@@ -20,10 +20,12 @@ from twisted.internet import defer
from mock import Mock, NonCallableMock
-from ..utils import MockHttpResource, MockKey
+from ....utils import MockHttpResource, setup_test_homeserver
from synapse.api.errors import SynapseError, AuthError
-from synapse.server import HomeServer
+from synapse.types import UserID
+
+from synapse.rest.client.v1 import profile
myid = "@1234ABCD:test"
PATH_PREFIX = "/_matrix/client/api/v1"
@@ -32,6 +34,7 @@ PATH_PREFIX = "/_matrix/client/api/v1"
class ProfileTestCase(unittest.TestCase):
""" Tests profile management. """
+ @defer.inlineCallbacks
def setUp(self):
self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
self.mock_handler = Mock(spec=[
@@ -41,27 +44,22 @@ class ProfileTestCase(unittest.TestCase):
"set_avatar_url",
])
- self.mock_config = NonCallableMock()
- self.mock_config.signing_key = [MockKey()]
-
- hs = HomeServer("test",
- db_pool=None,
+ hs = yield setup_test_homeserver(
+ "test",
http_client=None,
resource_for_client=self.mock_resource,
federation=Mock(),
replication_layer=Mock(),
- datastore=None,
- config=self.mock_config,
)
def _get_user_by_req(request=None):
- return hs.parse_userid(myid)
+ return (UserID.from_string(myid), "")
hs.get_auth().get_user_by_req = _get_user_by_req
hs.get_handlers().profile_handler = self.mock_handler
- hs.register_servlets()
+ profile.register_servlets(hs, self.mock_resource)
@defer.inlineCallbacks
def test_get_my_name(self):
diff --git a/tests/rest/test_rooms.py b/tests/rest/client/v1/test_rooms.py
index 84fd730afc..72fb4576b1 100644
--- a/tests/rest/test_rooms.py
+++ b/tests/rest/client/v1/test_rooms.py
@@ -18,19 +18,15 @@
# twisted imports
from twisted.internet import defer
-import synapse.rest.room
+import synapse.rest.client.v1.room
from synapse.api.constants import Membership
-from synapse.server import HomeServer
+from synapse.types import UserID
-from tests import unittest
-
-# python imports
import json
import urllib
-import types
-from ..utils import MockHttpResource, SQLiteMemoryDbPool, MockKey
+from ....utils import MockHttpResource, setup_test_homeserver
from .utils import RestTestCase
from mock import Mock, NonCallableMock
@@ -47,21 +43,11 @@ class RoomPermissionsTestCase(RestTestCase):
def setUp(self):
self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
- self.mock_config = NonCallableMock()
- self.mock_config.signing_key = [MockKey()]
-
- db_pool = SQLiteMemoryDbPool()
- yield db_pool.prepare()
-
- hs = HomeServer(
+ hs = yield setup_test_homeserver(
"red",
- db_pool=db_pool,
http_client=None,
replication_layer=Mock(),
- ratelimiter=NonCallableMock(spec_set=[
- "send_message",
- ]),
- config=self.mock_config,
+ ratelimiter=NonCallableMock(spec_set=["send_message"]),
)
self.ratelimiter = hs.get_ratelimiter()
self.ratelimiter.send_message.return_value = (True, 0)
@@ -70,9 +56,10 @@ class RoomPermissionsTestCase(RestTestCase):
def _get_user_by_token(token=None):
return {
- "user": hs.parse_userid(self.auth_user_id),
+ "user": UserID.from_string(self.auth_user_id),
"admin": False,
"device_id": None,
+ "token_id": 1,
}
hs.get_auth().get_user_by_token = _get_user_by_token
@@ -82,7 +69,7 @@ class RoomPermissionsTestCase(RestTestCase):
self.auth_user_id = self.rmcreator_id
- synapse.rest.room.register_servlets(hs, self.mock_resource)
+ synapse.rest.client.v1.room.register_servlets(hs, self.mock_resource)
self.auth = hs.get_auth()
@@ -294,7 +281,7 @@ class RoomPermissionsTestCase(RestTestCase):
# 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.join(room=room, user=usr, expect_code=403)
+ yield self.join(room=room, user=usr, expect_code=404)
yield self.leave(room=room, user=usr, expect_code=403)
@defer.inlineCallbacks
@@ -441,21 +428,11 @@ class RoomsMemberListTestCase(RestTestCase):
def setUp(self):
self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
- self.mock_config = NonCallableMock()
- self.mock_config.signing_key = [MockKey()]
-
- db_pool = SQLiteMemoryDbPool()
- yield db_pool.prepare()
-
- hs = HomeServer(
+ hs = yield setup_test_homeserver(
"red",
- db_pool=db_pool,
http_client=None,
replication_layer=Mock(),
- ratelimiter=NonCallableMock(spec_set=[
- "send_message",
- ]),
- config=self.mock_config,
+ ratelimiter=NonCallableMock(spec_set=["send_message"]),
)
self.ratelimiter = hs.get_ratelimiter()
self.ratelimiter.send_message.return_value = (True, 0)
@@ -466,9 +443,10 @@ class RoomsMemberListTestCase(RestTestCase):
def _get_user_by_token(token=None):
return {
- "user": hs.parse_userid(self.auth_user_id),
+ "user": UserID.from_string(self.auth_user_id),
"admin": False,
"device_id": None,
+ "token_id": 1,
}
hs.get_auth().get_user_by_token = _get_user_by_token
@@ -476,7 +454,7 @@ class RoomsMemberListTestCase(RestTestCase):
return defer.succeed(None)
hs.get_datastore().insert_client_ip = _insert_client_ip
- synapse.rest.room.register_servlets(hs, self.mock_resource)
+ synapse.rest.client.v1.room.register_servlets(hs, self.mock_resource)
def tearDown(self):
pass
@@ -532,21 +510,11 @@ class RoomsCreateTestCase(RestTestCase):
self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
self.auth_user_id = self.user_id
- self.mock_config = NonCallableMock()
- self.mock_config.signing_key = [MockKey()]
-
- db_pool = SQLiteMemoryDbPool()
- yield db_pool.prepare()
-
- hs = HomeServer(
+ hs = yield setup_test_homeserver(
"red",
- db_pool=db_pool,
http_client=None,
replication_layer=Mock(),
- ratelimiter=NonCallableMock(spec_set=[
- "send_message",
- ]),
- config=self.mock_config,
+ ratelimiter=NonCallableMock(spec_set=["send_message"]),
)
self.ratelimiter = hs.get_ratelimiter()
self.ratelimiter.send_message.return_value = (True, 0)
@@ -555,9 +523,10 @@ class RoomsCreateTestCase(RestTestCase):
def _get_user_by_token(token=None):
return {
- "user": hs.parse_userid(self.auth_user_id),
+ "user": UserID.from_string(self.auth_user_id),
"admin": False,
"device_id": None,
+ "token_id": 1,
}
hs.get_auth().get_user_by_token = _get_user_by_token
@@ -565,7 +534,7 @@ class RoomsCreateTestCase(RestTestCase):
return defer.succeed(None)
hs.get_datastore().insert_client_ip = _insert_client_ip
- synapse.rest.room.register_servlets(hs, self.mock_resource)
+ synapse.rest.client.v1.room.register_servlets(hs, self.mock_resource)
def tearDown(self):
pass
@@ -634,21 +603,11 @@ class RoomTopicTestCase(RestTestCase):
self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
self.auth_user_id = self.user_id
- self.mock_config = NonCallableMock()
- self.mock_config.signing_key = [MockKey()]
-
- db_pool = SQLiteMemoryDbPool()
- yield db_pool.prepare()
-
- hs = HomeServer(
+ hs = yield setup_test_homeserver(
"red",
- db_pool=db_pool,
http_client=None,
replication_layer=Mock(),
- ratelimiter=NonCallableMock(spec_set=[
- "send_message",
- ]),
- config=self.mock_config,
+ ratelimiter=NonCallableMock(spec_set=["send_message"]),
)
self.ratelimiter = hs.get_ratelimiter()
self.ratelimiter.send_message.return_value = (True, 0)
@@ -657,9 +616,10 @@ class RoomTopicTestCase(RestTestCase):
def _get_user_by_token(token=None):
return {
- "user": hs.parse_userid(self.auth_user_id),
+ "user": UserID.from_string(self.auth_user_id),
"admin": False,
"device_id": None,
+ "token_id": 1,
}
hs.get_auth().get_user_by_token = _get_user_by_token
@@ -668,7 +628,7 @@ class RoomTopicTestCase(RestTestCase):
return defer.succeed(None)
hs.get_datastore().insert_client_ip = _insert_client_ip
- synapse.rest.room.register_servlets(hs, self.mock_resource)
+ synapse.rest.client.v1.room.register_servlets(hs, self.mock_resource)
# create the room
self.room_id = yield self.create_room_as(self.user_id)
@@ -750,21 +710,11 @@ class RoomMemberStateTestCase(RestTestCase):
self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
self.auth_user_id = self.user_id
- self.mock_config = NonCallableMock()
- self.mock_config.signing_key = [MockKey()]
-
- db_pool = SQLiteMemoryDbPool()
- yield db_pool.prepare()
-
- hs = HomeServer(
+ hs = yield setup_test_homeserver(
"red",
- db_pool=db_pool,
http_client=None,
replication_layer=Mock(),
- ratelimiter=NonCallableMock(spec_set=[
- "send_message",
- ]),
- config=self.mock_config,
+ ratelimiter=NonCallableMock(spec_set=["send_message"]),
)
self.ratelimiter = hs.get_ratelimiter()
self.ratelimiter.send_message.return_value = (True, 0)
@@ -773,9 +723,10 @@ class RoomMemberStateTestCase(RestTestCase):
def _get_user_by_token(token=None):
return {
- "user": hs.parse_userid(self.auth_user_id),
+ "user": UserID.from_string(self.auth_user_id),
"admin": False,
"device_id": None,
+ "token_id": 1,
}
hs.get_auth().get_user_by_token = _get_user_by_token
@@ -783,7 +734,7 @@ class RoomMemberStateTestCase(RestTestCase):
return defer.succeed(None)
hs.get_datastore().insert_client_ip = _insert_client_ip
- synapse.rest.room.register_servlets(hs, self.mock_resource)
+ synapse.rest.client.v1.room.register_servlets(hs, self.mock_resource)
self.room_id = yield self.create_room_as(self.user_id)
@@ -886,21 +837,11 @@ class RoomMessagesTestCase(RestTestCase):
self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
self.auth_user_id = self.user_id
- self.mock_config = NonCallableMock()
- self.mock_config.signing_key = [MockKey()]
-
- db_pool = SQLiteMemoryDbPool()
- yield db_pool.prepare()
-
- hs = HomeServer(
+ hs = yield setup_test_homeserver(
"red",
- db_pool=db_pool,
http_client=None,
replication_layer=Mock(),
- ratelimiter=NonCallableMock(spec_set=[
- "send_message",
- ]),
- config=self.mock_config,
+ ratelimiter=NonCallableMock(spec_set=["send_message"]),
)
self.ratelimiter = hs.get_ratelimiter()
self.ratelimiter.send_message.return_value = (True, 0)
@@ -909,9 +850,10 @@ class RoomMessagesTestCase(RestTestCase):
def _get_user_by_token(token=None):
return {
- "user": hs.parse_userid(self.auth_user_id),
+ "user": UserID.from_string(self.auth_user_id),
"admin": False,
"device_id": None,
+ "token_id": 1,
}
hs.get_auth().get_user_by_token = _get_user_by_token
@@ -919,7 +861,7 @@ class RoomMessagesTestCase(RestTestCase):
return defer.succeed(None)
hs.get_datastore().insert_client_ip = _insert_client_ip
- synapse.rest.room.register_servlets(hs, self.mock_resource)
+ synapse.rest.client.v1.room.register_servlets(hs, self.mock_resource)
self.room_id = yield self.create_room_as(self.user_id)
@@ -990,21 +932,13 @@ class RoomInitialSyncTestCase(RestTestCase):
self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
self.auth_user_id = self.user_id
- self.mock_config = NonCallableMock()
- self.mock_config.signing_key = [MockKey()]
-
- db_pool = SQLiteMemoryDbPool()
- yield db_pool.prepare()
-
- hs = HomeServer(
+ hs = yield setup_test_homeserver(
"red",
- db_pool=db_pool,
http_client=None,
replication_layer=Mock(),
ratelimiter=NonCallableMock(spec_set=[
"send_message",
]),
- config=self.mock_config,
)
self.ratelimiter = hs.get_ratelimiter()
self.ratelimiter.send_message.return_value = (True, 0)
@@ -1013,9 +947,10 @@ class RoomInitialSyncTestCase(RestTestCase):
def _get_user_by_token(token=None):
return {
- "user": hs.parse_userid(self.auth_user_id),
+ "user": UserID.from_string(self.auth_user_id),
"admin": False,
"device_id": None,
+ "token_id": 1,
}
hs.get_auth().get_user_by_token = _get_user_by_token
@@ -1023,12 +958,12 @@ class RoomInitialSyncTestCase(RestTestCase):
return defer.succeed(None)
hs.get_datastore().insert_client_ip = _insert_client_ip
- synapse.rest.room.register_servlets(hs, self.mock_resource)
+ synapse.rest.client.v1.room.register_servlets(hs, self.mock_resource)
# Since I'm getting my own presence I need to exist as far as presence
# is concerned.
hs.get_handlers().presence_handler.registered_user(
- hs.parse_userid(self.user_id)
+ UserID.from_string(self.user_id)
)
# create the room
diff --git a/tests/rest/test_typing.py b/tests/rest/client/v1/test_typing.py
index c550294d59..80f2ec9ddf 100644
--- a/tests/rest/test_typing.py
+++ b/tests/rest/client/v1/test_typing.py
@@ -18,10 +18,10 @@
# twisted imports
from twisted.internet import defer
-import synapse.rest.room
-from synapse.server import HomeServer
+import synapse.rest.client.v1.room
+from synapse.types import UserID
-from ..utils import MockHttpResource, SQLiteMemoryDbPool, MockKey
+from ....utils import MockHttpResource, MockClock, setup_test_homeserver
from .utils import RestTestCase
from mock import Mock, NonCallableMock
@@ -36,24 +36,19 @@ class RoomTypingTestCase(RestTestCase):
@defer.inlineCallbacks
def setUp(self):
+ self.clock = MockClock()
+
self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
self.auth_user_id = self.user_id
- self.mock_config = NonCallableMock()
- self.mock_config.signing_key = [MockKey()]
-
- db_pool = SQLiteMemoryDbPool()
- yield db_pool.prepare()
-
- hs = HomeServer(
+ hs = yield setup_test_homeserver(
"red",
- db_pool=db_pool,
+ clock=self.clock,
http_client=None,
replication_layer=Mock(),
ratelimiter=NonCallableMock(spec_set=[
"send_message",
]),
- config=self.mock_config,
)
self.hs = hs
@@ -66,9 +61,10 @@ class RoomTypingTestCase(RestTestCase):
def _get_user_by_token(token=None):
return {
- "user": hs.parse_userid(self.auth_user_id),
+ "user": UserID.from_string(self.auth_user_id),
"admin": False,
"device_id": None,
+ "token_id": 1,
}
hs.get_auth().get_user_by_token = _get_user_by_token
@@ -77,7 +73,31 @@ class RoomTypingTestCase(RestTestCase):
return defer.succeed(None)
hs.get_datastore().insert_client_ip = _insert_client_ip
- synapse.rest.room.register_servlets(hs, self.mock_resource)
+ def get_room_members(room_id):
+ if room_id == self.room_id:
+ return defer.succeed([UserID.from_string(self.user_id)])
+ else:
+ return defer.succeed([])
+
+ @defer.inlineCallbacks
+ def fetch_room_distributions_into(room_id, localusers=None,
+ remotedomains=None, ignore_user=None):
+
+ members = yield get_room_members(room_id)
+ for member in members:
+ if ignore_user is not None and member == ignore_user:
+ continue
+
+ if hs.is_mine(member):
+ if localusers is not None:
+ localusers.add(member)
+ else:
+ if remotedomains is not None:
+ remotedomains.add(member.domain)
+ hs.get_handlers().room_member_handler.fetch_room_distributions_into = (
+ fetch_room_distributions_into)
+
+ synapse.rest.client.v1.room.register_servlets(hs, self.mock_resource)
self.room_id = yield self.create_room_as(self.user_id)
# Need another user to make notifications actually work
@@ -113,3 +133,25 @@ class RoomTypingTestCase(RestTestCase):
'{"typing": false}'
)
self.assertEquals(200, code)
+
+ @defer.inlineCallbacks
+ def test_typing_timeout(self):
+ (code, _) = yield self.mock_resource.trigger("PUT",
+ "/rooms/%s/typing/%s" % (self.room_id, self.user_id),
+ '{"typing": true, "timeout": 30000}'
+ )
+ self.assertEquals(200, code)
+
+ self.assertEquals(self.event_source.get_current_key(), 1)
+
+ self.clock.advance_time(31);
+
+ self.assertEquals(self.event_source.get_current_key(), 2)
+
+ (code, _) = yield self.mock_resource.trigger("PUT",
+ "/rooms/%s/typing/%s" % (self.room_id, self.user_id),
+ '{"typing": true, "timeout": 30000}'
+ )
+ self.assertEquals(200, code)
+
+ self.assertEquals(self.event_source.get_current_key(), 3)
diff --git a/tests/rest/utils.py b/tests/rest/client/v1/utils.py
index 579441fb4a..579441fb4a 100644
--- a/tests/rest/utils.py
+++ b/tests/rest/client/v1/utils.py
diff --git a/tests/rest/client/v2_alpha/__init__.py b/tests/rest/client/v2_alpha/__init__.py
new file mode 100644
index 0000000000..f5a5f780b4
--- /dev/null
+++ b/tests/rest/client/v2_alpha/__init__.py
@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+# Copyright 2015 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 tests import unittest
+
+from mock import Mock
+
+from ....utils import MockHttpResource, setup_test_homeserver
+
+from synapse.types import UserID
+
+from twisted.internet import defer
+
+
+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_token(token=None):
+ return {
+ "user": UserID.from_string(self.USER_ID),
+ "admin": False,
+ "device_id": None,
+ "token_id": 1,
+ }
+ hs.get_auth().get_user_by_token = _get_user_by_token
+
+ for r in self.TO_REGISTER:
+ r.register_servlets(hs, self.mock_resource)
+
+ def make_datastore_mock(self):
+ return Mock(spec=[
+ "insert_client_ip",
+ ])
diff --git a/tests/rest/client/v2_alpha/test_filter.py b/tests/rest/client/v2_alpha/test_filter.py
new file mode 100644
index 0000000000..80ddabf818
--- /dev/null
+++ b/tests/rest/client/v2_alpha/test_filter.py
@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+# Copyright 2015 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 mock import Mock
+
+from . import V2AlphaRestTestCase
+
+from synapse.rest.client.v2_alpha import filter
+
+from synapse.api.errors import StoreError
+
+
+class FilterTestCase(V2AlphaRestTestCase):
+ USER_ID = "@apple:test"
+ TO_REGISTER = [filter]
+
+ def make_datastore_mock(self):
+ datastore = super(FilterTestCase, self).make_datastore_mock()
+
+ self._user_filters = {}
+
+ def add_user_filter(user_localpart, definition):
+ filters = self._user_filters.setdefault(user_localpart, [])
+ filter_id = len(filters)
+ filters.append(definition)
+ return defer.succeed(filter_id)
+ datastore.add_user_filter = add_user_filter
+
+ def get_user_filter(user_localpart, filter_id):
+ if user_localpart not in self._user_filters:
+ raise StoreError(404, "No user")
+ filters = self._user_filters[user_localpart]
+ if filter_id >= len(filters):
+ raise StoreError(404, "No filter")
+ return defer.succeed(filters[filter_id])
+ datastore.get_user_filter = get_user_filter
+
+ return datastore
+
+ @defer.inlineCallbacks
+ def test_add_filter(self):
+ (code, response) = yield self.mock_resource.trigger("POST",
+ "/user/%s/filter" % (self.USER_ID),
+ '{"type": ["m.*"]}'
+ )
+ self.assertEquals(200, code)
+ self.assertEquals({"filter_id": "0"}, response)
+
+ self.assertIn("apple", self._user_filters)
+ self.assertEquals(len(self._user_filters["apple"]), 1)
+ self.assertEquals({"type": ["m.*"]}, self._user_filters["apple"][0])
+
+ @defer.inlineCallbacks
+ def test_get_filter(self):
+ self._user_filters["apple"] = [
+ {"type": ["m.*"]}
+ ]
+
+ (code, response) = yield self.mock_resource.trigger("GET",
+ "/user/%s/filter/0" % (self.USER_ID), None
+ )
+ self.assertEquals(200, code)
+ self.assertEquals({"type": ["m.*"]}, response)
+
+ @defer.inlineCallbacks
+ def test_get_filter_no_id(self):
+ self._user_filters["apple"] = [
+ {"type": ["m.*"]}
+ ]
+
+ (code, response) = yield self.mock_resource.trigger("GET",
+ "/user/%s/filter/2" % (self.USER_ID), None
+ )
+ self.assertEquals(404, code)
+
+ @defer.inlineCallbacks
+ def test_get_filter_no_user(self):
+ (code, response) = yield self.mock_resource.trigger("GET",
+ "/user/%s/filter/0" % (self.USER_ID), None
+ )
+ self.assertEquals(404, code)
diff --git a/tests/storage/TESTS_NEEDED_FOR b/tests/storage/TESTS_NEEDED_FOR
deleted file mode 100644
index 8e5d0cbdc4..0000000000
--- a/tests/storage/TESTS_NEEDED_FOR
+++ /dev/null
@@ -1,5 +0,0 @@
-synapse/storage/feedback.py
-synapse/storage/keys.py
-synapse/storage/pdu.py
-synapse/storage/stream.py
-synapse/storage/transactions.py
diff --git a/tests/storage/test_base.py b/tests/storage/test_base.py
index a6f1d6a333..55fbffa7a2 100644
--- a/tests/storage/test_base.py
+++ b/tests/storage/test_base.py
@@ -22,6 +22,7 @@ from mock import Mock, call
from collections import OrderedDict
from synapse.server import HomeServer
+
from synapse.storage._base import SQLBaseStore
@@ -37,8 +38,9 @@ class SQLBaseStoreTestCase(unittest.TestCase):
return defer.succeed(func(self.mock_txn, *args, **kwargs))
self.db_pool.runInteraction = runInteraction
- hs = HomeServer("test",
- db_pool=self.db_pool)
+ config = Mock()
+ config.event_cache_size = 1
+ hs = HomeServer("test", db_pool=self.db_pool, config=config)
self.datastore = SQLBaseStore(hs)
diff --git a/tests/storage/test_directory.py b/tests/storage/test_directory.py
index e9c242cc07..b9bfbc00e2 100644
--- a/tests/storage/test_directory.py
+++ b/tests/storage/test_directory.py
@@ -17,28 +17,22 @@
from tests import unittest
from twisted.internet import defer
-from synapse.server import HomeServer
from synapse.storage.directory import DirectoryStore
+from synapse.types import RoomID, RoomAlias
-from tests.utils import SQLiteMemoryDbPool
+from tests.utils import setup_test_homeserver
class DirectoryStoreTestCase(unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
- db_pool = SQLiteMemoryDbPool()
- yield db_pool.prepare()
-
- hs = HomeServer(
- "test",
- db_pool=db_pool,
- )
+ hs = yield setup_test_homeserver()
self.store = DirectoryStore(hs)
- self.room = hs.parse_roomid("!abcde:test")
- self.alias = hs.parse_roomalias("#my-room:test")
+ self.room = RoomID.from_string("!abcde:test")
+ self.alias = RoomAlias.from_string("#my-room:test")
@defer.inlineCallbacks
def test_room_to_alias(self):
diff --git a/tests/storage/test_presence.py b/tests/storage/test_presence.py
index 9655d3cf42..065eebdbcf 100644
--- a/tests/storage/test_presence.py
+++ b/tests/storage/test_presence.py
@@ -17,28 +17,22 @@
from tests import unittest
from twisted.internet import defer
-from synapse.server import HomeServer
from synapse.storage.presence import PresenceStore
+from synapse.types import UserID
-from tests.utils import SQLiteMemoryDbPool, MockClock
+from tests.utils import setup_test_homeserver, MockClock
class PresenceStoreTestCase(unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
- db_pool = SQLiteMemoryDbPool()
- yield db_pool.prepare()
-
- hs = HomeServer("test",
- clock=MockClock(),
- db_pool=db_pool,
- )
+ hs = yield setup_test_homeserver(clock=MockClock())
self.store = PresenceStore(hs)
- self.u_apple = hs.parse_userid("@apple:test")
- self.u_banana = hs.parse_userid("@banana:test")
+ self.u_apple = UserID.from_string("@apple:test")
+ self.u_banana = UserID.from_string("@banana:test")
@defer.inlineCallbacks
def test_state(self):
diff --git a/tests/storage/test_profile.py b/tests/storage/test_profile.py
index 5d36723c28..1fa783f313 100644
--- a/tests/storage/test_profile.py
+++ b/tests/storage/test_profile.py
@@ -17,26 +17,21 @@
from tests import unittest
from twisted.internet import defer
-from synapse.server import HomeServer
from synapse.storage.profile import ProfileStore
+from synapse.types import UserID
-from tests.utils import SQLiteMemoryDbPool
+from tests.utils import setup_test_homeserver
class ProfileStoreTestCase(unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
- db_pool = SQLiteMemoryDbPool()
- yield db_pool.prepare()
-
- hs = HomeServer("test",
- db_pool=db_pool,
- )
+ hs = yield setup_test_homeserver()
self.store = ProfileStore(hs)
- self.u_frank = hs.parse_userid("@frank:test")
+ self.u_frank = UserID.from_string("@frank:test")
@defer.inlineCallbacks
def test_displayname(self):
diff --git a/tests/storage/test_redaction.py b/tests/storage/test_redaction.py
index 9806fbc69b..b57006fcb4 100644
--- a/tests/storage/test_redaction.py
+++ b/tests/storage/test_redaction.py
@@ -17,10 +17,10 @@
from tests import unittest
from twisted.internet import defer
-from synapse.server import HomeServer
from synapse.api.constants import EventTypes, Membership
+from synapse.types import UserID, RoomID
-from tests.utils import SQLiteMemoryDbPool, MockKey
+from tests.utils import setup_test_homeserver
from mock import Mock
@@ -29,16 +29,7 @@ class RedactionTestCase(unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
- db_pool = SQLiteMemoryDbPool()
- yield db_pool.prepare()
-
- self.mock_config = Mock()
- self.mock_config.signing_key = [MockKey()]
-
- hs = HomeServer(
- "test",
- db_pool=db_pool,
- config=self.mock_config,
+ hs = yield setup_test_homeserver(
resource_for_federation=Mock(),
http_client=None,
)
@@ -48,10 +39,10 @@ class RedactionTestCase(unittest.TestCase):
self.handlers = hs.get_handlers()
self.message_handler = self.handlers.message_handler
- self.u_alice = hs.parse_userid("@alice:test")
- self.u_bob = hs.parse_userid("@bob:test")
+ self.u_alice = UserID.from_string("@alice:test")
+ self.u_bob = UserID.from_string("@bob:test")
- self.room1 = hs.parse_roomid("!abc123:test")
+ self.room1 = RoomID.from_string("!abc123:test")
self.depth = 1
diff --git a/tests/storage/test_registration.py b/tests/storage/test_registration.py
index 84bfde7568..e0b81f2b57 100644
--- a/tests/storage/test_registration.py
+++ b/tests/storage/test_registration.py
@@ -17,22 +17,16 @@
from tests import unittest
from twisted.internet import defer
-from synapse.server import HomeServer
from synapse.storage.registration import RegistrationStore
-from tests.utils import SQLiteMemoryDbPool
+from tests.utils import setup_test_homeserver
class RegistrationStoreTestCase(unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
- db_pool = SQLiteMemoryDbPool()
- yield db_pool.prepare()
-
- hs = HomeServer("test",
- db_pool=db_pool,
- )
+ hs = yield setup_test_homeserver()
self.store = RegistrationStore(hs)
@@ -53,7 +47,10 @@ class RegistrationStoreTestCase(unittest.TestCase):
)
self.assertEquals(
- {"admin": 0, "device_id": None, "name": self.user_id},
+ {"admin": 0,
+ "device_id": None,
+ "name": self.user_id,
+ "token_id": 1},
(yield self.store.get_user_by_token(self.tokens[0]))
)
@@ -63,7 +60,10 @@ class RegistrationStoreTestCase(unittest.TestCase):
yield self.store.add_access_token_to_user(self.user_id, self.tokens[1])
self.assertEquals(
- {"admin": 0, "device_id": None, "name": self.user_id},
+ {"admin": 0,
+ "device_id": None,
+ "name": self.user_id,
+ "token_id": 2},
(yield self.store.get_user_by_token(self.tokens[1]))
)
diff --git a/tests/storage/test_room.py b/tests/storage/test_room.py
index 11761fe29a..c88dd446fb 100644
--- a/tests/storage/test_room.py
+++ b/tests/storage/test_room.py
@@ -17,30 +17,25 @@
from tests import unittest
from twisted.internet import defer
-from synapse.server import HomeServer
from synapse.api.constants import EventTypes
+from synapse.types import UserID, RoomID, RoomAlias
-from tests.utils import SQLiteMemoryDbPool
+from tests.utils import setup_test_homeserver
class RoomStoreTestCase(unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
- db_pool = SQLiteMemoryDbPool()
- yield db_pool.prepare()
-
- hs = HomeServer("test",
- db_pool=db_pool,
- )
+ hs = yield setup_test_homeserver()
# We can't test RoomStore on its own without the DirectoryStore, for
# management of the 'room_aliases' table
self.store = hs.get_datastore()
- self.room = hs.parse_roomid("!abcde:test")
- self.alias = hs.parse_roomalias("#a-room-name:test")
- self.u_creator = hs.parse_userid("@creator:test")
+ self.room = RoomID.from_string("!abcde:test")
+ self.alias = RoomAlias.from_string("#a-room-name:test")
+ self.u_creator = UserID.from_string("@creator:test")
yield self.store.store_room(self.room.to_string(),
room_creator_user_id=self.u_creator.to_string(),
@@ -57,17 +52,6 @@ class RoomStoreTestCase(unittest.TestCase):
)
@defer.inlineCallbacks
- def test_store_room_config(self):
- yield self.store.store_room_config(self.room.to_string(),
- visibility=False
- )
-
- self.assertObjectHasAttributes(
- {"is_public": False},
- (yield self.store.get_room(self.room.to_string()))
- )
-
- @defer.inlineCallbacks
def test_get_rooms(self):
# get_rooms does an INNER JOIN on the room_aliases table :(
@@ -96,19 +80,14 @@ class RoomEventsStoreTestCase(unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
- db_pool = SQLiteMemoryDbPool()
- yield db_pool.prepare()
-
- hs = HomeServer("test",
- db_pool=db_pool,
- )
+ hs = setup_test_homeserver()
# Room events need the full datastore, for persist_event() and
# get_room_state()
self.store = hs.get_datastore()
self.event_factory = hs.get_event_factory();
- self.room = hs.parse_roomid("!abcde:test")
+ self.room = RoomID.from_string("!abcde:test")
yield self.store.store_room(self.room.to_string(),
room_creator_user_id="@creator:text",
diff --git a/tests/storage/test_roommember.py b/tests/storage/test_roommember.py
index a23a8189df..811fea544b 100644
--- a/tests/storage/test_roommember.py
+++ b/tests/storage/test_roommember.py
@@ -17,10 +17,10 @@
from tests import unittest
from twisted.internet import defer
-from synapse.server import HomeServer
from synapse.api.constants import EventTypes, Membership
+from synapse.types import UserID, RoomID
-from tests.utils import SQLiteMemoryDbPool, MockKey
+from tests.utils import setup_test_homeserver
from mock import Mock
@@ -29,16 +29,7 @@ class RoomMemberStoreTestCase(unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
- db_pool = SQLiteMemoryDbPool()
- yield db_pool.prepare()
-
- self.mock_config = Mock()
- self.mock_config.signing_key = [MockKey()]
-
- hs = HomeServer(
- "test",
- db_pool=db_pool,
- config=self.mock_config,
+ hs = yield setup_test_homeserver(
resource_for_federation=Mock(),
http_client=None,
)
@@ -49,13 +40,13 @@ class RoomMemberStoreTestCase(unittest.TestCase):
self.handlers = hs.get_handlers()
self.message_handler = self.handlers.message_handler
- self.u_alice = hs.parse_userid("@alice:test")
- self.u_bob = hs.parse_userid("@bob:test")
+ self.u_alice = UserID.from_string("@alice:test")
+ self.u_bob = UserID.from_string("@bob:test")
# User elsewhere on another host
- self.u_charlie = hs.parse_userid("@charlie:elsewhere")
+ self.u_charlie = UserID.from_string("@charlie:elsewhere")
- self.room = hs.parse_roomid("!abc123:test")
+ self.room = RoomID.from_string("!abc123:test")
@defer.inlineCallbacks
def inject_room_member(self, room, user, membership, replaces_state=None):
diff --git a/tests/storage/test_stream.py b/tests/storage/test_stream.py
index 9247fc579e..0c9b89d765 100644
--- a/tests/storage/test_stream.py
+++ b/tests/storage/test_stream.py
@@ -17,10 +17,10 @@
from tests import unittest
from twisted.internet import defer
-from synapse.server import HomeServer
from synapse.api.constants import EventTypes, Membership
+from synapse.types import UserID, RoomID
-from tests.utils import SQLiteMemoryDbPool, MockKey
+from tests.utils import setup_test_homeserver
from mock import Mock
@@ -29,16 +29,7 @@ class StreamStoreTestCase(unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
- db_pool = SQLiteMemoryDbPool()
- yield db_pool.prepare()
-
- self.mock_config = Mock()
- self.mock_config.signing_key = [MockKey()]
-
- hs = HomeServer(
- "test",
- db_pool=db_pool,
- config=self.mock_config,
+ hs = yield setup_test_homeserver(
resource_for_federation=Mock(),
http_client=None,
)
@@ -48,11 +39,11 @@ class StreamStoreTestCase(unittest.TestCase):
self.handlers = hs.get_handlers()
self.message_handler = self.handlers.message_handler
- self.u_alice = hs.parse_userid("@alice:test")
- self.u_bob = hs.parse_userid("@bob:test")
+ self.u_alice = UserID.from_string("@alice:test")
+ self.u_bob = UserID.from_string("@bob:test")
- self.room1 = hs.parse_roomid("!abc123:test")
- self.room2 = hs.parse_roomid("!xyx987:test")
+ self.room1 = RoomID.from_string("!abc123:test")
+ self.room2 = RoomID.from_string("!xyx987:test")
self.depth = 1
diff --git a/tests/test_state.py b/tests/test_state.py
index 98ad9e54cd..fea25f7021 100644
--- a/tests/test_state.py
+++ b/tests/test_state.py
@@ -16,11 +16,122 @@
from tests import unittest
from twisted.internet import defer
+from synapse.events import FrozenEvent
+from synapse.api.auth import Auth
+from synapse.api.constants import EventTypes, Membership
from synapse.state import StateHandler
+from .utils import MockClock
+
from mock import Mock
+_next_event_id = 1000
+
+
+def create_event(name=None, type=None, state_key=None, depth=2, event_id=None,
+ prev_events=[], **kwargs):
+ global _next_event_id
+
+ if not event_id:
+ _next_event_id += 1
+ event_id = str(_next_event_id)
+
+ if not name:
+ if state_key is not None:
+ name = "<%s-%s, %s>" % (type, state_key, event_id,)
+ else:
+ name = "<%s, %s>" % (type, event_id,)
+
+ d = {
+ "event_id": event_id,
+ "type": type,
+ "sender": "@user_id:example.com",
+ "room_id": "!room_id:example.com",
+ "depth": depth,
+ "prev_events": prev_events,
+ }
+
+ if state_key is not None:
+ d["state_key"] = state_key
+
+ d.update(kwargs)
+
+ event = FrozenEvent(d)
+
+ return event
+
+
+class StateGroupStore(object):
+ def __init__(self):
+ self._event_to_state_group = {}
+ self._group_to_state = {}
+
+ self._next_group = 1
+
+ def get_state_groups(self, event_ids):
+ groups = {}
+ for event_id in event_ids:
+ group = self._event_to_state_group.get(event_id)
+ if group:
+ groups[group] = self._group_to_state[group]
+
+ return defer.succeed(groups)
+
+ def store_state_groups(self, event, context):
+ if context.current_state is None:
+ return
+
+ state_events = context.current_state
+
+ if event.is_state():
+ state_events[(event.type, event.state_key)] = event
+
+ state_group = context.state_group
+ if not state_group:
+ state_group = self._next_group
+ self._next_group += 1
+
+ self._group_to_state[state_group] = state_events.values()
+
+ self._event_to_state_group[event.event_id] = state_group
+
+
+class DictObj(dict):
+ def __init__(self, **kwargs):
+ super(DictObj, self).__init__(kwargs)
+ self.__dict__ = self
+
+
+class Graph(object):
+ def __init__(self, nodes, edges):
+ events = {}
+ clobbered = set(events.keys())
+
+ for event_id, fields in nodes.items():
+ refs = edges.get(event_id)
+ if refs:
+ clobbered.difference_update(refs)
+ prev_events = [(r, {}) for r in refs]
+ else:
+ prev_events = []
+
+ events[event_id] = create_event(
+ event_id=event_id,
+ prev_events=prev_events,
+ **fields
+ )
+
+ self._leaves = clobbered
+ self._events = sorted(events.values(), key=lambda e: e.depth)
+
+ def walk(self):
+ return iter(self._events)
+
+ def get_leaves(self):
+ return (self._events[i] for i in self._leaves)
+
+
class StateTestCase(unittest.TestCase):
def setUp(self):
self.store = Mock(
@@ -29,20 +140,191 @@ class StateTestCase(unittest.TestCase):
"add_event_hashes",
]
)
- hs = Mock(spec=["get_datastore"])
+ hs = Mock(spec=[
+ "get_datastore", "get_auth", "get_state_handler", "get_clock",
+ ])
hs.get_datastore.return_value = self.store
+ hs.get_state_handler.return_value = None
+ hs.get_auth.return_value = Auth(hs)
+ hs.get_clock.return_value = MockClock()
self.state = StateHandler(hs)
self.event_id = 0
@defer.inlineCallbacks
+ def test_branch_no_conflict(self):
+ graph = Graph(
+ nodes={
+ "START": DictObj(
+ type=EventTypes.Create,
+ state_key="",
+ depth=1,
+ ),
+ "A": DictObj(
+ type=EventTypes.Message,
+ depth=2,
+ ),
+ "B": DictObj(
+ type=EventTypes.Message,
+ depth=3,
+ ),
+ "C": DictObj(
+ type=EventTypes.Name,
+ state_key="",
+ depth=3,
+ ),
+ "D": DictObj(
+ type=EventTypes.Message,
+ depth=4,
+ ),
+ },
+ edges={
+ "A": ["START"],
+ "B": ["A"],
+ "C": ["A"],
+ "D": ["B", "C"]
+ }
+ )
+
+ store = StateGroupStore()
+ self.store.get_state_groups.side_effect = store.get_state_groups
+
+ context_store = {}
+
+ for event in graph.walk():
+ context = yield self.state.compute_event_context(event)
+ store.store_state_groups(event, context)
+ context_store[event.event_id] = context
+
+ self.assertEqual(2, len(context_store["D"].current_state))
+
+ @defer.inlineCallbacks
+ def test_branch_basic_conflict(self):
+ graph = Graph(
+ nodes={
+ "START": DictObj(
+ type=EventTypes.Create,
+ state_key="creator",
+ content={"membership": "@user_id:example.com"},
+ depth=1,
+ ),
+ "A": DictObj(
+ type=EventTypes.Member,
+ state_key="@user_id:example.com",
+ content={"membership": Membership.JOIN},
+ membership=Membership.JOIN,
+ depth=2,
+ ),
+ "B": DictObj(
+ type=EventTypes.Name,
+ state_key="",
+ depth=3,
+ ),
+ "C": DictObj(
+ type=EventTypes.Name,
+ state_key="",
+ depth=4,
+ ),
+ "D": DictObj(
+ type=EventTypes.Message,
+ depth=5,
+ ),
+ },
+ edges={
+ "A": ["START"],
+ "B": ["A"],
+ "C": ["A"],
+ "D": ["B", "C"]
+ }
+ )
+
+ store = StateGroupStore()
+ self.store.get_state_groups.side_effect = store.get_state_groups
+
+ context_store = {}
+
+ for event in graph.walk():
+ context = yield self.state.compute_event_context(event)
+ store.store_state_groups(event, context)
+ context_store[event.event_id] = context
+
+ self.assertSetEqual(
+ {"START", "A", "C"},
+ {e.event_id for e in context_store["D"].current_state.values()}
+ )
+
+ @defer.inlineCallbacks
+ def test_branch_have_banned_conflict(self):
+ graph = Graph(
+ nodes={
+ "START": DictObj(
+ type=EventTypes.Create,
+ state_key="creator",
+ content={"membership": "@user_id:example.com"},
+ depth=1,
+ ),
+ "A": DictObj(
+ type=EventTypes.Member,
+ state_key="@user_id:example.com",
+ content={"membership": Membership.JOIN},
+ membership=Membership.JOIN,
+ depth=2,
+ ),
+ "B": DictObj(
+ type=EventTypes.Name,
+ state_key="",
+ depth=3,
+ ),
+ "C": DictObj(
+ type=EventTypes.Member,
+ state_key="@user_id_2:example.com",
+ content={"membership": Membership.BAN},
+ membership=Membership.BAN,
+ depth=4,
+ ),
+ "D": DictObj(
+ type=EventTypes.Name,
+ state_key="",
+ depth=4,
+ sender="@user_id_2:example.com",
+ ),
+ "E": DictObj(
+ type=EventTypes.Message,
+ depth=5,
+ ),
+ },
+ edges={
+ "A": ["START"],
+ "B": ["A"],
+ "C": ["B"],
+ "D": ["B"],
+ "E": ["C", "D"]
+ }
+ )
+
+ store = StateGroupStore()
+ self.store.get_state_groups.side_effect = store.get_state_groups
+
+ context_store = {}
+
+ for event in graph.walk():
+ context = yield self.state.compute_event_context(event)
+ store.store_state_groups(event, context)
+ context_store[event.event_id] = context
+
+ self.assertSetEqual(
+ {"START", "A", "B", "C"},
+ {e.event_id for e in context_store["E"].current_state.values()}
+ )
+
+ @defer.inlineCallbacks
def test_annotate_with_old_message(self):
- event = self.create_event(type="test_message", name="event")
+ event = create_event(type="test_message", name="event")
old_state = [
- self.create_event(type="test1", state_key="1"),
- self.create_event(type="test1", state_key="2"),
- self.create_event(type="test2", state_key=""),
+ create_event(type="test1", state_key="1"),
+ create_event(type="test1", state_key="2"),
+ create_event(type="test2", state_key=""),
]
context = yield self.state.compute_event_context(
@@ -62,12 +344,12 @@ class StateTestCase(unittest.TestCase):
@defer.inlineCallbacks
def test_annotate_with_old_state(self):
- event = self.create_event(type="state", state_key="", name="event")
+ event = create_event(type="state", state_key="", name="event")
old_state = [
- self.create_event(type="test1", state_key="1"),
- self.create_event(type="test1", state_key="2"),
- self.create_event(type="test2", state_key=""),
+ create_event(type="test1", state_key="1"),
+ create_event(type="test1", state_key="2"),
+ create_event(type="test2", state_key=""),
]
context = yield self.state.compute_event_context(
@@ -88,13 +370,12 @@ class StateTestCase(unittest.TestCase):
@defer.inlineCallbacks
def test_trivial_annotate_message(self):
- event = self.create_event(type="test_message", name="event")
- event.prev_events = []
+ event = create_event(type="test_message", name="event")
old_state = [
- self.create_event(type="test1", state_key="1"),
- self.create_event(type="test1", state_key="2"),
- self.create_event(type="test2", state_key=""),
+ create_event(type="test1", state_key="1"),
+ create_event(type="test1", state_key="2"),
+ create_event(type="test2", state_key=""),
]
group_name = "group_name_1"
@@ -119,13 +400,12 @@ class StateTestCase(unittest.TestCase):
@defer.inlineCallbacks
def test_trivial_annotate_state(self):
- event = self.create_event(type="state", state_key="", name="event")
- event.prev_events = []
+ event = create_event(type="state", state_key="", name="event")
old_state = [
- self.create_event(type="test1", state_key="1"),
- self.create_event(type="test1", state_key="2"),
- self.create_event(type="test2", state_key=""),
+ create_event(type="test1", state_key="1"),
+ create_event(type="test1", state_key="2"),
+ create_event(type="test2", state_key=""),
]
group_name = "group_name_1"
@@ -150,30 +430,21 @@ class StateTestCase(unittest.TestCase):
@defer.inlineCallbacks
def test_resolve_message_conflict(self):
- event = self.create_event(type="test_message", name="event")
- event.prev_events = []
+ event = create_event(type="test_message", name="event")
old_state_1 = [
- self.create_event(type="test1", state_key="1"),
- self.create_event(type="test1", state_key="2"),
- self.create_event(type="test2", state_key=""),
+ create_event(type="test1", state_key="1"),
+ create_event(type="test1", state_key="2"),
+ create_event(type="test2", state_key=""),
]
old_state_2 = [
- self.create_event(type="test1", state_key="1"),
- self.create_event(type="test3", state_key="2"),
- self.create_event(type="test4", state_key=""),
+ create_event(type="test1", state_key="1"),
+ create_event(type="test3", state_key="2"),
+ create_event(type="test4", state_key=""),
]
- group_name_1 = "group_name_1"
- group_name_2 = "group_name_2"
-
- self.store.get_state_groups.return_value = {
- group_name_1: old_state_1,
- group_name_2: old_state_2,
- }
-
- context = yield self.state.compute_event_context(event)
+ context = yield self._get_context(event, old_state_1, old_state_2)
self.assertEqual(len(context.current_state), 5)
@@ -181,56 +452,76 @@ class StateTestCase(unittest.TestCase):
@defer.inlineCallbacks
def test_resolve_state_conflict(self):
- event = self.create_event(type="test4", state_key="", name="event")
- event.prev_events = []
+ event = create_event(type="test4", state_key="", name="event")
old_state_1 = [
- self.create_event(type="test1", state_key="1"),
- self.create_event(type="test1", state_key="2"),
- self.create_event(type="test2", state_key=""),
+ create_event(type="test1", state_key="1"),
+ create_event(type="test1", state_key="2"),
+ create_event(type="test2", state_key=""),
]
old_state_2 = [
- self.create_event(type="test1", state_key="1"),
- self.create_event(type="test3", state_key="2"),
- self.create_event(type="test4", state_key=""),
+ create_event(type="test1", state_key="1"),
+ create_event(type="test3", state_key="2"),
+ create_event(type="test4", state_key=""),
]
- group_name_1 = "group_name_1"
- group_name_2 = "group_name_2"
-
- self.store.get_state_groups.return_value = {
- group_name_1: old_state_1,
- group_name_2: old_state_2,
- }
-
- context = yield self.state.compute_event_context(event)
+ context = yield self._get_context(event, old_state_1, old_state_2)
self.assertEqual(len(context.current_state), 5)
self.assertIsNone(context.state_group)
- def create_event(self, name=None, type=None, state_key=None):
- self.event_id += 1
- event_id = str(self.event_id)
+ @defer.inlineCallbacks
+ def test_standard_depth_conflict(self):
+ event = create_event(type="test4", name="event")
+
+ member_event = create_event(
+ type=EventTypes.Member,
+ state_key="@user_id:example.com",
+ content={
+ "membership": Membership.JOIN,
+ }
+ )
- if not name:
- if state_key is not None:
- name = "<%s-%s>" % (type, state_key)
- else:
- name = "<%s>" % (type, )
+ old_state_1 = [
+ member_event,
+ create_event(type="test1", state_key="1", depth=1),
+ ]
+
+ old_state_2 = [
+ member_event,
+ create_event(type="test1", state_key="1", depth=2),
+ ]
- event = Mock(name=name, spec=[])
- event.type = type
+ context = yield self._get_context(event, old_state_1, old_state_2)
- if state_key is not None:
- event.state_key = state_key
- event.event_id = event_id
+ self.assertEqual(old_state_2[1], context.current_state[("test1", "1")])
+
+ # Reverse the depth to make sure we are actually using the depths
+ # during state resolution.
+
+ old_state_1 = [
+ member_event,
+ create_event(type="test1", state_key="1", depth=2),
+ ]
+
+ old_state_2 = [
+ member_event,
+ create_event(type="test1", state_key="1", depth=1),
+ ]
+
+ context = yield self._get_context(event, old_state_1, old_state_2)
+
+ self.assertEqual(old_state_1[1], context.current_state[("test1", "1")])
- event.is_state = lambda: (state_key is not None)
- event.unsigned = {}
+ def _get_context(self, event, old_state_1, old_state_2):
+ group_name_1 = "group_name_1"
+ group_name_2 = "group_name_2"
- event.user_id = "@user_id:example.com"
- event.room_id = "!room_id:example.com"
+ self.store.get_state_groups.return_value = {
+ group_name_1: old_state_1,
+ group_name_2: old_state_2,
+ }
- return event
+ return self.state.compute_event_context(event)
diff --git a/tests/test_types.py b/tests/test_types.py
index bfb9e6f548..b29a8415b1 100644
--- a/tests/test_types.py
+++ b/tests/test_types.py
@@ -42,12 +42,6 @@ class UserIDTestCase(unittest.TestCase):
self.assertTrue(userA == userAagain)
self.assertTrue(userA != userB)
- def test_via_homeserver(self):
- user = mock_homeserver.parse_userid("@3456ijkl:my.domain")
-
- self.assertEquals("3456ijkl", user.localpart)
- self.assertEquals("my.domain", user.domain)
-
class RoomAliasTestCase(unittest.TestCase):
@@ -62,9 +56,3 @@ class RoomAliasTestCase(unittest.TestCase):
room = RoomAlias("channel", "my.domain")
self.assertEquals(room.to_string(), "#channel:my.domain")
-
- def test_via_homeserver(self):
- room = mock_homeserver.parse_roomalias("#elsewhere:my.domain")
-
- self.assertEquals("elsewhere", room.localpart)
- self.assertEquals("my.domain", room.domain)
diff --git a/tests/unittest.py b/tests/unittest.py
index a9c0e05541..fe26b7574f 100644
--- a/tests/unittest.py
+++ b/tests/unittest.py
@@ -69,6 +69,8 @@ class TestCase(unittest.TestCase):
return ret
logging.getLogger().setLevel(level)
+ # Don't set SQL logging
+ logging.getLogger("synapse.storage").setLevel(old_level)
return orig()
def assertObjectHasAttributes(self, attrs, obj):
diff --git a/tests/util/test_lrucache.py b/tests/util/test_lrucache.py
new file mode 100644
index 0000000000..ab934bf928
--- /dev/null
+++ b/tests/util/test_lrucache.py
@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+# Copyright 2015 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 .. import unittest
+
+from synapse.util.lrucache import LruCache
+
+class LruCacheTestCase(unittest.TestCase):
+
+ def test_get_set(self):
+ cache = LruCache(1)
+ cache["key"] = "value"
+ self.assertEquals(cache.get("key"), "value")
+ self.assertEquals(cache["key"], "value")
+
+ def test_eviction(self):
+ cache = LruCache(2)
+ cache[1] = 1
+ cache[2] = 2
+
+ self.assertEquals(cache.get(1), 1)
+ self.assertEquals(cache.get(2), 2)
+
+ cache[3] = 3
+
+ self.assertEquals(cache.get(1), None)
+ self.assertEquals(cache.get(2), 2)
+ self.assertEquals(cache.get(3), 3)
+
+ def test_setdefault(self):
+ cache = LruCache(1)
+ self.assertEquals(cache.setdefault("key", 1), 1)
+ self.assertEquals(cache.get("key"), 1)
+ self.assertEquals(cache.setdefault("key", 2), 1)
+ self.assertEquals(cache.get("key"), 1)
+
+ def test_pop(self):
+ cache = LruCache(1)
+ cache["key"] = 1
+ self.assertEquals(cache.pop("key"), 1)
+ self.assertEquals(cache.pop("key"), None)
+
+
diff --git a/tests/utils.py b/tests/utils.py
index 731e03f517..39895c739f 100644
--- a/tests/utils.py
+++ b/tests/utils.py
@@ -17,6 +17,7 @@ from synapse.http.server import HttpServer
from synapse.api.errors import cs_error, CodeMessageException, StoreError
from synapse.api.constants import EventTypes
from synapse.storage import prepare_database
+from synapse.server import HomeServer
from synapse.util.logcontext import LoggingContext
@@ -31,6 +32,29 @@ import urlparse
from inspect import getcallargs
+@defer.inlineCallbacks
+def setup_test_homeserver(name="test", datastore=None, config=None, **kargs):
+ """Setup a homeserver suitable for running tests against. Keyword arguments
+ are passed to the Homeserver constructor. If no datastore is supplied a
+ datastore backed by an in-memory sqlite db will be given to the HS.
+ """
+ if config is None:
+ config = Mock()
+ config.signing_key = [MockKey()]
+ config.event_cache_size = 1
+
+ if datastore is None:
+ db_pool = SQLiteMemoryDbPool()
+ yield db_pool.prepare()
+ hs = HomeServer(name, db_pool=db_pool, config=config, **kargs)
+ else:
+ hs = HomeServer(
+ name, db_pool=None, datastore=datastore, config=config, **kargs
+ )
+
+ defer.returnValue(hs)
+
+
def get_mock_call_args(pattern_func, mock_func):
""" Return the arguments the mock function was called with interpreted
by the pattern functions argument list.
@@ -138,7 +162,8 @@ class MockClock(object):
now = 1000
def __init__(self):
- # list of tuples of (absolute_time, callback) in no particular order
+ # list of lists of [absolute_time, callback, expired] in no particular
+ # order
self.timers = []
def time(self):
@@ -154,11 +179,16 @@ class MockClock(object):
LoggingContext.thread_local.current_context = current_context
callback()
- t = (self.now + delay, wrapped_callback)
+ t = [self.now + delay, wrapped_callback, False]
self.timers.append(t)
+
return t
def cancel_call_later(self, timer):
+ if timer[2]:
+ raise Exception("Cannot cancel an expired timer")
+
+ timer[2] = True
self.timers = [t for t in self.timers if t != timer]
# For unit testing
@@ -168,11 +198,17 @@ class MockClock(object):
timers = self.timers
self.timers = []
- for time, callback in timers:
+ for t in timers:
+ time, callback, expired = t
+
+ if expired:
+ raise Exception("Timer already expired")
+
if self.now >= time:
+ t[2] = True
callback()
else:
- self.timers.append((time, callback))
+ self.timers.append(t)
class SQLiteMemoryDbPool(ConnectionPool, object):
|
