"+roomList[i].room_id+"" +
- "| "+roomList[i].membership+" | " +
- ""+roomList[i].latest_message+" | " +
- "";
- rows += row;
- }
-
- $("#rooms").append(rows);
-
- $('#rooms').find("tr").click(function(){
- var roomId = $(this).find('td:eq(0)').text();
- var membership = $(this).find('td:eq(1)').text();
- if (membership !== "join") {
- console.log("Joining room " + roomId);
- var url = "http://localhost:8008/_matrix/client/api/v1/rooms/$roomid/join?access_token=$token";
- url = url.replace("$token", accountInfo.access_token);
- url = url.replace("$roomid", encodeURIComponent(roomId));
- $.ajax({
- url: url,
- type: "POST",
- contentType: "application/json; charset=utf-8",
- data: JSON.stringify({membership: "join"}),
- dataType: "json",
- success: function(data) {
- loadRoomContent(roomId);
- getCurrentRoomList();
- },
- error: function(err) {
- alert(JSON.stringify($.parseJSON(err.responseText)));
- }
- });
- }
- else {
- loadRoomContent(roomId);
- }
- });
-};
-
-var addMessage = function(data) {
-
- var msg = data.content.body;
- if (data.type === "m.room.member") {
- if (data.content.membership === undefined) {
- return;
- }
- if (data.content.membership === "invite") {
- msg = "invited " + data.state_key + " to the room";
- }
- else if (data.content.membership === "join") {
- msg = "joined the room";
- }
- else if (data.content.membership === "leave") {
- msg = "left the room";
- }
- else if (data.content.membership === "ban") {
- msg = "was banned from the room";
- }
- }
- if (msg === undefined) {
- return;
- }
-
- var row = "" +
- "| "+data.user_id+" | " +
- ""+msg+" | " +
- "
";
- $("#messages").append(row);
-};
-
-var addMember = function(data) {
- var row = "" +
- "| "+data.state_key+" | " +
- ""+data.content.membership+" | " +
- "
";
- $("#members").append(row);
-};
-
diff --git a/jsfiddles/register_login/demo.css b/jsfiddles/register_login/demo.css
deleted file mode 100644
index 11781c250f..0000000000
--- a/jsfiddles/register_login/demo.css
+++ /dev/null
@@ -1,7 +0,0 @@
-.loggedin {
- visibility: hidden;
-}
-
-p {
- font-family: monospace;
-}
diff --git a/jsfiddles/register_login/demo.html b/jsfiddles/register_login/demo.html
deleted file mode 100644
index fcac453ac2..0000000000
--- a/jsfiddles/register_login/demo.html
+++ /dev/null
@@ -1,20 +0,0 @@
-
-
This registration/login demo requires a home server to be running on http://localhost:8008
-
-
This room membership demo requires a home server to be running on http://localhost:8008
-
-
-
-
-
-
-
- | Room ID |
- My state |
- Room Alias |
-
-
-
-
"+data.membership+" | " +
- ""+data.room_alias+" | " +
- "";
- $("#rooms").append(row);
-};
-
-$('.changeMembership').live('click', function() {
- var roomId = $("#roomId").val();
- var member = $("#targetUser").val();
- var membership = $("#membership").val();
-
- if (roomId.length === 0) {
- return;
- }
-
- var url = "http://localhost:8008/_matrix/client/api/v1/rooms/$roomid/$membership?access_token=$token";
- url = url.replace("$token", accountInfo.access_token);
- url = url.replace("$roomid", encodeURIComponent(roomId));
- url = url.replace("$membership", membership);
-
- var data = {};
-
- if (membership === "invite") {
- data = {
- user_id: member
- };
- }
-
- $.ajax({
- url: url,
- type: "POST",
- contentType: "application/json; charset=utf-8",
- data: JSON.stringify(data),
- dataType: "json",
- success: function(data) {
- getCurrentRoomList();
- },
- error: function(err) {
- alert(JSON.stringify($.parseJSON(err.responseText)));
- }
- });
-});
-
-$('.joinAlias').live('click', function() {
- var roomAlias = $("#roomAlias").val();
- var url = "http://localhost:8008/_matrix/client/api/v1/join/$roomalias?access_token=$token";
- url = url.replace("$token", accountInfo.access_token);
- url = url.replace("$roomalias", encodeURIComponent(roomAlias));
- $.ajax({
- url: url,
- type: "POST",
- contentType: "application/json; charset=utf-8",
- data: JSON.stringify({}),
- dataType: "json",
- success: function(data) {
- getCurrentRoomList();
- },
- error: function(err) {
- alert(JSON.stringify($.parseJSON(err.responseText)));
- }
- });
-});
diff --git a/scripts/copyrighter-sql.pl b/scripts/copyrighter-sql.pl
new file mode 100755
index 0000000000..890e51e587
--- /dev/null
+++ b/scripts/copyrighter-sql.pl
@@ -0,0 +1,33 @@
+#!/usr/bin/perl -pi
+# 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.
+
+$copyright = <=14.0.0": ["twisted>=14.0.0"],
+ "service_identity>=1.0.0": ["service_identity>=1.0.0"],
+ "pyopenssl>=0.14": ["OpenSSL>=0.14"],
+ "pyyaml": ["yaml"],
+ "pyasn1": ["pyasn1"],
+ "pynacl": ["nacl"],
+ "daemonize": ["daemonize"],
+ "py-bcrypt": ["bcrypt"],
+ "frozendict>=0.4": ["frozendict"],
+ "pillow": ["PIL"],
+}
+
+
+class MissingRequirementError(Exception):
+ pass
+
+
+def check_requirements():
+ """Checks that all the modules needed by synapse have been correctly
+ installed and are at the correct version"""
+ for dependency, module_requirements in REQUIREMENTS.items():
+ for module_requirement in module_requirements:
+ if ">=" in module_requirement:
+ module_name, required_version = module_requirement.split(">=")
+ version_test = ">="
+ elif "==" in module_requirement:
+ module_name, required_version = module_requirement.split("==")
+ version_test = "=="
+ else:
+ module_name = module_requirement
+ version_test = None
+
+ try:
+ module = __import__(module_name)
+ except ImportError:
+ logging.exception(
+ "Can't import %r which is part of %r",
+ module_name, dependency
+ )
+ raise MissingRequirementError(
+ "Can't import %r which is part of %r"
+ % (module_name, dependency)
+ )
+ version = getattr(module, "__version__", None)
+ file_path = getattr(module, "__file__", None)
+ logger.info(
+ "Using %r version %r from %r to satisfy %r",
+ module_name, version, file_path, dependency
+ )
+
+ if version_test == ">=":
+ if version is None:
+ raise MissingRequirementError(
+ "Version of %r isn't set as __version__ of module %r"
+ % (dependency, module_name)
+ )
+ if LooseVersion(version) < LooseVersion(required_version):
+ raise MissingRequirementError(
+ "Version of %r in %r is too old. %r < %r"
+ % (dependency, file_path, version, required_version)
+ )
+ elif version_test == "==":
+ if version is None:
+ raise MissingRequirementError(
+ "Version of %r isn't set as __version__ of module %r"
+ % (dependency, module_name)
+ )
+ if LooseVersion(version) != LooseVersion(required_version):
+ raise MissingRequirementError(
+ "Unexpected version of %r in %r. %r != %r"
+ % (dependency, file_path, version, required_version)
+ )
diff --git a/synapse/rest/events.py b/synapse/rest/events.py
index cf6d13f817..bedcb2bcc6 100644
--- a/synapse/rest/events.py
+++ b/synapse/rest/events.py
@@ -44,8 +44,11 @@ class EventStreamRestServlet(RestServlet):
except ValueError:
raise SynapseError(400, "timeout must be in milliseconds.")
+ as_client_event = "raw" not in request.args
+
chunk = yield handler.get_stream(
- auth_user.to_string(), pagin_config, timeout=timeout
+ auth_user.to_string(), pagin_config, timeout=timeout,
+ as_client_event=as_client_event
)
except:
logger.exception("Event stream failed")
diff --git a/synapse/rest/initial_sync.py b/synapse/rest/initial_sync.py
index a571589581..b13d56b286 100644
--- a/synapse/rest/initial_sync.py
+++ b/synapse/rest/initial_sync.py
@@ -27,12 +27,15 @@ class InitialSyncRestServlet(RestServlet):
def on_GET(self, request):
user = yield self.auth.get_user_by_req(request)
with_feedback = "feedback" in request.args
+ as_client_event = "raw" not in request.args
pagination_config = PaginationConfig.from_request(request)
handler = self.handlers.message_handler
content = yield handler.snapshot_all_rooms(
user_id=user.to_string(),
pagin_config=pagination_config,
- feedback=with_feedback)
+ feedback=with_feedback,
+ as_client_event=as_client_event
+ )
defer.returnValue((200, content))
diff --git a/synapse/rest/room.py b/synapse/rest/room.py
index e40773758a..48bba2a5f3 100644
--- a/synapse/rest/room.py
+++ b/synapse/rest/room.py
@@ -246,7 +246,7 @@ class JoinRoomAliasServlet(RestServlet):
}
)
- defer.returnValue((200, {}))
+ defer.returnValue((200, {"room_id": identifier.to_string()}))
@defer.inlineCallbacks
def on_PUT(self, request, room_identifier, txn_id):
@@ -314,12 +314,15 @@ class RoomMessageListRestServlet(RestServlet):
request, default_limit=10,
)
with_feedback = "feedback" in request.args
+ as_client_event = "raw" not in request.args
handler = self.handlers.message_handler
msgs = yield handler.get_messages(
room_id=room_id,
user_id=user.to_string(),
pagin_config=pagination_config,
- feedback=with_feedback)
+ feedback=with_feedback,
+ as_client_event=as_client_event
+ )
defer.returnValue((200, msgs))
diff --git a/synapse/server.py b/synapse/server.py
index c3bf46abbf..d861efd2fd 100644
--- a/synapse/server.py
+++ b/synapse/server.py
@@ -149,8 +149,8 @@ class BaseHomeServer(object):
object."""
return EventID.from_string(s)
- def serialize_event(self, e):
- return serialize_event(self, e)
+ def serialize_event(self, e, as_client_event=True):
+ return serialize_event(self, e, as_client_event)
def get_ip_from_request(self, request):
# May be an X-Forwarding-For header depending on config
diff --git a/synapse/storage/room.py b/synapse/storage/room.py
index 978b2c4a48..6542f8e4f8 100644
--- a/synapse/storage/room.py
+++ b/synapse/storage/room.py
@@ -58,13 +58,6 @@ class RoomStore(SQLBaseStore):
logger.error("store_room with room_id=%s failed: %s", room_id, e)
raise StoreError(500, "Problem creating room.")
- def store_room_config(self, room_id, visibility):
- return self._simple_update_one(
- table=RoomsTable.table_name,
- keyvalues={"room_id": room_id},
- updatevalues={"is_public": visibility}
- )
-
def get_room(self, room_id):
"""Retrieve a room.
diff --git a/synapse/storage/state.py b/synapse/storage/state.py
index 5327517704..71db16d0e5 100644
--- a/synapse/storage/state.py
+++ b/synapse/storage/state.py
@@ -78,12 +78,6 @@ class StateStore(SQLBaseStore):
f,
)
- def store_state_groups(self, event):
- return self.runInteraction(
- "store_state_groups",
- self._store_state_groups_txn, event
- )
-
def _store_state_groups_txn(self, txn, event, context):
if context.current_state is None:
return
diff --git a/synapse/storage/stream.py b/synapse/storage/stream.py
index bedc3c6c52..8ac2adab05 100644
--- a/synapse/storage/stream.py
+++ b/synapse/storage/stream.py
@@ -39,6 +39,8 @@ from ._base import SQLBaseStore
from synapse.api.errors import SynapseError
from synapse.util.logutils import log_function
+from collections import namedtuple
+
import logging
@@ -52,91 +54,79 @@ _STREAM_TOKEN = "stream"
_TOPOLOGICAL_TOKEN = "topological"
-def _parse_stream_token(string):
- try:
- if string[0] != 's':
- raise
- return int(string[1:])
- except:
- raise SynapseError(400, "Invalid token")
+class _StreamToken(namedtuple("_StreamToken", "topological stream")):
+ """Tokens are positions between events. The token "s1" comes after event 1.
+ s0 s1
+ | |
+ [0] V [1] V [2]
-def _parse_topological_token(string):
- try:
- if string[0] != 't':
- raise
- parts = string[1:].split('-', 1)
- return (int(parts[0]), int(parts[1]))
- except:
- raise SynapseError(400, "Invalid token")
+ Tokens can either be a point in the live event stream or a cursor going
+ through historic events.
+ When traversing the live event stream events are ordered by when they
+ arrived at the homeserver.
-def is_stream_token(string):
- try:
- _parse_stream_token(string)
- return True
- except:
- return False
+ When traversing historic events the events are ordered by their depth in
+ the event graph "topological_ordering" and then by when they arrived at the
+ homeserver "stream_ordering".
+ Live tokens start with an "s" followed by the "stream_ordering" id of the
+ event it comes after. Historic tokens start with a "t" followed by the
+ "topological_ordering" id of the event it comes after, follewed by "-",
+ followed by the "stream_ordering" id of the event it comes after.
+ """
+ __slots__ = []
-def is_topological_token(string):
- try:
- _parse_topological_token(string)
- return True
- except:
- return False
+ @classmethod
+ def parse(cls, string):
+ try:
+ if string[0] == 's':
+ return cls(None, int(string[1:]))
+ if string[0] == 't':
+ parts = string[1:].split('-', 1)
+ return cls(int(parts[1]), int(parts[0]))
+ except:
+ pass
+ raise SynapseError(400, "Invalid token %r" % (string,))
+ @classmethod
+ def parse_stream_token(cls, string):
+ try:
+ if string[0] == 's':
+ return cls(None, int(string[1:]))
+ except:
+ pass
+ raise SynapseError(400, "Invalid token %r" % (string,))
-def _get_token_bound(token, comparison):
- try:
- s = _parse_stream_token(token)
- return "%s %s %d" % ("stream_ordering", comparison, s)
- except:
- pass
+ def __str__(self):
+ if self.topological is not None:
+ return "t%d-%d" % (self.topological, self.stream)
+ else:
+ return "s%d" % (self.stream,)
- try:
- top, stream = _parse_topological_token(token)
- return "%s %s %d AND %s %s %d" % (
- "topological_ordering", comparison, top,
- "stream_ordering", comparison, stream,
- )
- except:
- pass
+ def lower_bound(self):
+ if self.topological is None:
+ return "(%d < %s)" % (self.stream, "stream_ordering")
+ else:
+ return "(%d < %s OR (%d == %s AND %d < %s))" % (
+ self.topological, "topological_ordering",
+ self.topological, "topological_ordering",
+ self.stream, "stream_ordering",
+ )
- raise SynapseError(400, "Invalid token")
+ def upper_bound(self):
+ if self.topological is None:
+ return "(%d >= %s)" % (self.stream, "stream_ordering")
+ else:
+ return "(%d > %s OR (%d == %s AND %d >= %s))" % (
+ self.topological, "topological_ordering",
+ self.topological, "topological_ordering",
+ self.stream, "stream_ordering",
+ )
class StreamStore(SQLBaseStore):
- @log_function
- def get_room_events(self, user_id, from_key, to_key, room_id, limit=0,
- direction='f', with_feedback=False):
- # We deal with events request in two different ways depending on if
- # this looks like an /events request or a pagination request.
- is_events = (
- direction == 'f'
- and user_id
- and is_stream_token(from_key)
- and to_key and is_stream_token(to_key)
- )
-
- if is_events:
- return self.get_room_events_stream(
- user_id=user_id,
- from_key=from_key,
- to_key=to_key,
- room_id=room_id,
- limit=limit,
- with_feedback=with_feedback,
- )
- else:
- return self.paginate_room_events(
- from_key=from_key,
- to_key=to_key,
- room_id=room_id,
- limit=limit,
- with_feedback=with_feedback,
- )
-
@log_function
def get_room_events_stream(self, user_id, from_key, to_key, room_id,
limit=0, with_feedback=False):
@@ -162,8 +152,8 @@ class StreamStore(SQLBaseStore):
limit = MAX_STREAM_SIZE
# From and to keys should be integers from ordering.
- from_id = _parse_stream_token(from_key)
- to_id = _parse_stream_token(to_key)
+ from_id = _StreamToken.parse_stream_token(from_key)
+ to_id = _StreamToken.parse_stream_token(to_key)
if from_key == to_key:
return defer.succeed(([], to_key))
@@ -181,7 +171,7 @@ class StreamStore(SQLBaseStore):
}
def f(txn):
- txn.execute(sql, (user_id, user_id, from_id, to_id,))
+ txn.execute(sql, (user_id, user_id, from_id.stream, to_id.stream,))
rows = self.cursor_to_dict(txn)
@@ -211,17 +201,21 @@ class StreamStore(SQLBaseStore):
# Tokens really represent positions between elements, but we use
# the convention of pointing to the event before the gap. Hence
# we have a bit of asymmetry when it comes to equalities.
- from_comp = '<=' if direction == 'b' else '>'
- to_comp = '>' if direction == 'b' else '<='
- order = "DESC" if direction == 'b' else "ASC"
-
args = [room_id]
-
- bounds = _get_token_bound(from_key, from_comp)
- if to_key:
- bounds = "%s AND %s" % (
- bounds, _get_token_bound(to_key, to_comp)
- )
+ if direction == 'b':
+ order = "DESC"
+ bounds = _StreamToken.parse(from_key).upper_bound()
+ if to_key:
+ bounds = "%s AND %s" % (
+ bounds, _StreamToken.parse(to_key).lower_bound()
+ )
+ else:
+ order = "ASC"
+ bounds = _StreamToken.parse(from_key).lower_bound()
+ if to_key:
+ bounds = "%s AND %s" % (
+ bounds, _StreamToken.parse(to_key).upper_bound()
+ )
if int(limit) > 0:
args.append(int(limit))
@@ -249,9 +243,13 @@ class StreamStore(SQLBaseStore):
topo = rows[-1]["topological_ordering"]
toke = rows[-1]["stream_ordering"]
if direction == 'b':
- topo -= 1
+ # Tokens are positions between events.
+ # This token points *after* the last event in the chunk.
+ # We need it to point to the event before it in the chunk
+ # when we are going backwards so we subtract one from the
+ # stream part.
toke -= 1
- next_token = "t%s-%s" % (topo, toke)
+ next_token = str(_StreamToken(topo, toke))
else:
# TODO (erikj): We should work out what to do here instead.
next_token = to_key if to_key else from_key
@@ -284,9 +282,14 @@ class StreamStore(SQLBaseStore):
rows.reverse() # As we selected with reverse ordering
if rows:
+ # Tokens are positions between events.
+ # This token points *after* the last event in the chunk.
+ # We need it to point to the event before it in the chunk
+ # since we are going backwards so we subtract one from the
+ # stream part.
topo = rows[0]["topological_ordering"]
- toke = rows[0]["stream_ordering"]
- start_token = "t%s-%s" % (topo, toke)
+ toke = rows[0]["stream_ordering"] - 1
+ start_token = str(_StreamToken(topo, toke))
token = (start_token, end_token)
else:
diff --git a/tests/handlers/test_presence.py b/tests/handlers/test_presence.py
index b85a89052a..c309fbb054 100644
--- a/tests/handlers/test_presence.py
+++ b/tests/handlers/test_presence.py
@@ -59,23 +59,29 @@ 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()
+
+ self.mock_http_client = Mock(spec=[])
+ self.mock_http_client.put_json = DeferredMockCallable()
+
hs = HomeServer("test",
- clock=MockClock(),
+ clock=self.clock,
db_pool=db_pool,
handlers=None,
- resource_for_federation=Mock(),
- http_client=None,
+ resource_for_federation=self.mock_federation_resource,
+ http_client=self.mock_http_client,
config=self.mock_config,
keyring=Mock(),
)
@@ -92,24 +98,33 @@ class PresenceStateTestCase(unittest.TestCase):
self.u_banana = hs.parse_userid("@banana:test")
self.u_clementine = hs.parse_userid("@clementine:test")
- yield self.store.create_presence(self.u_apple.localpart)
+ for u in self.u_apple, self.u_banana, self.u_clementine:
+ yield self.store.create_presence(u.localpart)
+
yield self.store.set_presence_state(
self.u_apple.localpart, {"state": ONLINE, "status_msg": "Online"}
)
+ # 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
+ self.room_id = "a-room"
self.room_members = []
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([])
@@ -128,6 +143,10 @@ class PresenceStateTestCase(unittest.TestCase):
self.handler.start_polling_presence = self.mock_start
self.handler.stop_polling_presence = self.mock_stop
+
+class PresenceStateTestCase(PresenceTestCase):
+ """ Tests presence management. """
+
@defer.inlineCallbacks
def test_get_my_state(self):
state = yield self.handler.get_state(
@@ -206,56 +225,9 @@ 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
-
- self.mock_start = Mock()
- self.mock_stop = Mock()
-
- self.handler.start_polling_presence = self.mock_start
- self.handler.stop_polling_presence = self.mock_stop
-
@defer.inlineCallbacks
def test_invite_local(self):
# TODO(paul): This test will likely break if/when real auth permissions
@@ -558,24 +530,25 @@ class PresencePushTestCase(unittest.TestCase):
])
self.room_member_handler = hs.handlers.room_member_handler
+ self.room_id = "a-room"
self.room_members = []
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([])
self.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([])
self.room_member_handler.get_room_members = get_room_members
def get_room_hosts(room_id):
- if room_id == "a-room":
+ if room_id == self.room_id:
hosts = set([u.domain for u in self.room_members])
return defer.succeed(hosts)
else:
@@ -911,7 +884,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 +947,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,7 +976,7 @@ 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()
diff --git a/tests/handlers/test_room.py b/tests/handlers/test_room.py
index 0cb8aa4fbc..d3253b48b8 100644
--- a/tests/handlers/test_room.py
+++ b/tests/handlers/test_room.py
@@ -223,7 +223,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(
@@ -301,7 +301,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(
diff --git a/tests/handlers/test_typing.py b/tests/handlers/test_typing.py
index 0d4b368a43..6a498b23a4 100644
--- a/tests/handlers/test_typing.py
+++ b/tests/handlers/test_typing.py
@@ -352,3 +352,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/test_rooms.py b/tests/rest/test_rooms.py
index 84fd730afc..8e65ff9a1c 100644
--- a/tests/rest/test_rooms.py
+++ b/tests/rest/test_rooms.py
@@ -294,7 +294,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
diff --git a/tests/rest/test_typing.py b/tests/rest/test_typing.py
index c550294d59..18138af1b5 100644
--- a/tests/rest/test_typing.py
+++ b/tests/rest/test_typing.py
@@ -21,7 +21,7 @@ from twisted.internet import defer
import synapse.rest.room
from synapse.server import HomeServer
-from ..utils import MockHttpResource, SQLiteMemoryDbPool, MockKey
+from ..utils import MockHttpResource, MockClock, SQLiteMemoryDbPool, MockKey
from .utils import RestTestCase
from mock import Mock, NonCallableMock
@@ -36,6 +36,8 @@ 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
@@ -47,6 +49,7 @@ class RoomTypingTestCase(RestTestCase):
hs = HomeServer(
"red",
+ clock=self.clock,
db_pool=db_pool,
http_client=None,
replication_layer=Mock(),
@@ -77,6 +80,30 @@ class RoomTypingTestCase(RestTestCase):
return defer.succeed(None)
hs.get_datastore().insert_client_ip = _insert_client_ip
+ def get_room_members(room_id):
+ if room_id == self.room_id:
+ return defer.succeed([hs.parse_userid(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.room.register_servlets(hs, self.mock_resource)
self.room_id = yield self.create_room_as(self.user_id)
@@ -113,3 +140,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/storage/test_room.py b/tests/storage/test_room.py
index 11761fe29a..e7739776ec 100644
--- a/tests/storage/test_room.py
+++ b/tests/storage/test_room.py
@@ -56,17 +56,6 @@ class RoomStoreTestCase(unittest.TestCase):
(yield self.store.get_room(self.room.to_string()))
)
- @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 :(
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/utils.py b/tests/utils.py
index 731e03f517..97fa8d8181 100644
--- a/tests/utils.py
+++ b/tests/utils.py
@@ -138,7 +138,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 +155,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 +174,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):