123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293 |
- # -*- 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.
- from tests import unittest
- from twisted.internet import defer, reactor
- from mock import Mock, call, ANY, NonCallableMock
- import json
- from tests.utils import (
- MockHttpResource, MockClock, DeferredMockCallable, setup_test_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
- ONLINE = PresenceState.ONLINE
- def _expect_edu(destination, edu_type, content, origin="test"):
- return {
- "origin": origin,
- "origin_server_ts": 1000000,
- "pdus": [],
- "edus": [
- {
- "edu_type": edu_type,
- "content": content,
- }
- ],
- "pdu_failures": [],
- }
- def _make_edu_json(origin, edu_type, content):
- return json.dumps(_expect_edu("test", edu_type, content, origin=origin))
- class JustPresenceHandlers(object):
- def __init__(self, hs):
- self.presence_handler = PresenceHandler(hs)
- class PresenceTestCase(unittest.TestCase):
- @defer.inlineCallbacks
- def setUp(self):
- self.clock = MockClock()
- self.mock_federation_resource = MockHttpResource()
- 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=self.mock_federation_resource,
- http_client=self.mock_http_client,
- keyring=Mock(),
- **hs_kwargs
- )
- hs.handlers = JustPresenceHandlers(hs)
- self.datastore = hs.get_datastore()
- self.setUp_roommemberhandler_mocks(hs.handlers)
- self.handler = hs.get_handlers().presence_handler
- self.event_source = hs.get_event_sources().sources["presence"]
- self.distributor = hs.get_distributor()
- self.distributor.declare("user_joined_room")
- 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_joined_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([self.room_id])
- else:
- return defer.succeed([])
- room_member_handler.get_joined_rooms_for_user = get_rooms_for_user
- def get_room_members(room_id):
- 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)
- 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):
- retry_timings_res = {
- "destination": "",
- "retry_last_ts": 0,
- "retry_interval": 0,
- }
- datastore.get_destination_retry_timings.return_value = (
- defer.succeed(retry_timings_res)
- )
- 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, "accepted": accepted} 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()
- self.handler.start_polling_presence = self.mock_start
- self.handler.stop_polling_presence = self.mock_stop
- @defer.inlineCallbacks
- def test_get_my_state(self):
- state = yield self.handler.get_state(
- target_user=self.u_apple, auth_user=self.u_apple
- )
- self.assertEquals(
- {"presence": ONLINE, "status_msg": "Online"},
- state
- )
- @defer.inlineCallbacks
- def test_get_allowed_state(self):
- yield self.datastore.allow_presence_visible(
- observed_localpart=self.u_apple.localpart,
- observer_userid=self.u_banana.to_string(),
- )
- state = yield self.handler.get_state(
- target_user=self.u_apple, auth_user=self.u_banana
- )
- self.assertEquals(
- {"presence": ONLINE, "status_msg": "Online"},
- state
- )
- @defer.inlineCallbacks
- def test_get_same_room_state(self):
- self.room_members = [self.u_apple, self.u_clementine]
- state = yield self.handler.get_state(
- target_user=self.u_apple, auth_user=self.u_clementine
- )
- self.assertEquals(
- {"presence": ONLINE, "status_msg": "Online"},
- state
- )
- @defer.inlineCallbacks
- def test_get_disallowed_state(self):
- self.room_members = []
- yield self.assertFailure(
- self.handler.get_state(
- target_user=self.u_apple, auth_user=self.u_clementine
- ),
- SynapseError
- )
- @defer.inlineCallbacks
- def test_set_my_state(self):
- yield self.handler.set_state(
- target_user=self.u_apple, auth_user=self.u_apple,
- state={"presence": UNAVAILABLE, "status_msg": "Away"})
- self.assertEquals(
- {"state": UNAVAILABLE,
- "status_msg": "Away",
- "mtime": 1000000},
- (yield self.datastore.get_presence_state(self.u_apple.localpart))
- )
- self.mock_start.assert_called_with(self.u_apple,
- state={
- "presence": UNAVAILABLE,
- "status_msg": "Away",
- "last_active": 1000000, # MockClock
- })
- yield self.handler.set_state(
- target_user=self.u_apple, auth_user=self.u_apple,
- state={"presence": OFFLINE})
- self.mock_stop.assert_called_with(self.u_apple)
- class PresenceInvitesTestCase(PresenceTestCase):
- """ Tests presence management. """
- @defer.inlineCallbacks
- def setUp(self):
- yield super(PresenceInvitesTestCase, self).setUp()
- 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
- # are added; for now the HS will always accept any invite
- yield self.handler.send_invite(
- observer_user=self.u_apple, observed_user=self.u_banana)
- self.assertEquals(
- [{"observed_user_id": "@banana:test", "accepted": 1}],
- (yield self.datastore.get_presence_list(self.u_apple.localpart))
- )
- self.assertTrue(
- (yield self.datastore.is_presence_visible(
- observed_localpart=self.u_banana.localpart,
- observer_userid=self.u_apple.to_string(),
- ))
- )
- self.mock_start.assert_called_with(
- self.u_apple, target_user=self.u_banana)
- @defer.inlineCallbacks
- def test_invite_local_nonexistant(self):
- yield self.handler.send_invite(
- observer_user=self.u_apple, observed_user=self.u_durian)
- self.assertEquals(
- [],
- (yield self.datastore.get_presence_list(self.u_apple.localpart))
- )
- @defer.inlineCallbacks
- def test_invite_remote(self):
- # Use a different destination, otherwise retry logic might fail the
- # request
- u_rocket = UserID.from_string("@rocket:there")
- put_json = self.mock_http_client.put_json
- put_json.expect_call_and_return(
- call("there",
- path="/_matrix/federation/v1/send/1000000/",
- data=_expect_edu("there", "m.presence_invite",
- content={
- "observer_user": "@apple:test",
- "observed_user": "@rocket:there",
- }
- ),
- json_data_callback=ANY,
- ),
- defer.succeed((200, "OK"))
- )
- yield self.handler.send_invite(
- observer_user=self.u_apple, observed_user=u_rocket)
- self.assertEquals(
- [{"observed_user_id": "@rocket:there", "accepted": 0}],
- (yield self.datastore.get_presence_list(self.u_apple.localpart))
- )
- yield put_json.await_calls()
- @defer.inlineCallbacks
- def test_accept_remote(self):
- # TODO(paul): This test will likely break if/when real auth permissions
- # are added; for now the HS will always accept any invite
- # Use a different destination, otherwise retry logic might fail the
- # request
- u_rocket = UserID.from_string("@rocket:moon")
- put_json = self.mock_http_client.put_json
- put_json.expect_call_and_return(
- call("moon",
- path="/_matrix/federation/v1/send/1000000/",
- data=_expect_edu("moon", "m.presence_accept",
- content={
- "observer_user": "@rocket:moon",
- "observed_user": "@apple:test",
- }
- ),
- json_data_callback=ANY,
- ),
- defer.succeed((200, "OK"))
- )
- yield self.mock_federation_resource.trigger("PUT",
- "/_matrix/federation/v1/send/1000000/",
- _make_edu_json("elsewhere", "m.presence_invite",
- content={
- "observer_user": "@rocket:moon",
- "observed_user": "@apple:test",
- }
- )
- )
- self.assertTrue(
- (yield self.datastore.is_presence_visible(
- observed_localpart=self.u_apple.localpart,
- observer_userid=u_rocket.to_string(),
- ))
- )
- yield put_json.await_calls()
- @defer.inlineCallbacks
- def test_invited_remote_nonexistant(self):
- # Use a different destination, otherwise retry logic might fail the
- # request
- u_rocket = UserID.from_string("@rocket:sun")
- put_json = self.mock_http_client.put_json
- put_json.expect_call_and_return(
- call("sun",
- path="/_matrix/federation/v1/send/1000000/",
- data=_expect_edu("sun", "m.presence_deny",
- content={
- "observer_user": "@rocket:sun",
- "observed_user": "@durian:test",
- }
- ),
- json_data_callback=ANY,
- ),
- defer.succeed((200, "OK"))
- )
- yield self.mock_federation_resource.trigger("PUT",
- "/_matrix/federation/v1/send/1000000/",
- _make_edu_json("sun", "m.presence_invite",
- content={
- "observer_user": "@rocket:sun",
- "observed_user": "@durian:test",
- }
- )
- )
- yield put_json.await_calls()
- @defer.inlineCallbacks
- def test_accepted_remote(self):
- yield self.datastore.add_presence_list_pending(
- observer_localpart=self.u_apple.localpart,
- observed_userid=self.u_cabbage.to_string(),
- )
- yield self.mock_federation_resource.trigger("PUT",
- "/_matrix/federation/v1/send/1000000/",
- _make_edu_json("elsewhere", "m.presence_accept",
- content={
- "observer_user": "@apple:test",
- "observed_user": "@cabbage:elsewhere",
- }
- )
- )
- self.assertEquals(
- [{"observed_user_id": "@cabbage:elsewhere", "accepted": 1}],
- (yield self.datastore.get_presence_list(self.u_apple.localpart))
- )
- self.mock_start.assert_called_with(
- self.u_apple, target_user=self.u_cabbage)
- @defer.inlineCallbacks
- def test_denied_remote(self):
- yield self.datastore.add_presence_list_pending(
- observer_localpart=self.u_apple.localpart,
- observed_userid="@eggplant:elsewhere",
- )
- yield self.mock_federation_resource.trigger("PUT",
- "/_matrix/federation/v1/send/1000000/",
- _make_edu_json("elsewhere", "m.presence_deny",
- content={
- "observer_user": "@apple:test",
- "observed_user": "@eggplant:elsewhere",
- }
- )
- )
- self.assertEquals(
- [],
- (yield self.datastore.get_presence_list(self.u_apple.localpart))
- )
- @defer.inlineCallbacks
- def test_drop_local(self):
- yield self.datastore.add_presence_list_pending(
- observer_localpart=self.u_apple.localpart,
- observed_userid=self.u_banana.to_string(),
- )
- yield self.datastore.set_presence_list_accepted(
- observer_localpart=self.u_apple.localpart,
- observed_userid=self.u_banana.to_string(),
- )
- yield self.handler.drop(
- observer_user=self.u_apple,
- observed_user=self.u_banana,
- )
- self.assertEquals(
- [],
- (yield self.datastore.get_presence_list(self.u_apple.localpart))
- )
- self.mock_stop.assert_called_with(
- self.u_apple, target_user=self.u_banana)
- @defer.inlineCallbacks
- def test_drop_remote(self):
- yield self.datastore.add_presence_list_pending(
- observer_localpart=self.u_apple.localpart,
- observed_userid=self.u_cabbage.to_string(),
- )
- yield self.datastore.set_presence_list_accepted(
- observer_localpart=self.u_apple.localpart,
- observed_userid=self.u_cabbage.to_string(),
- )
- yield self.handler.drop(
- observer_user=self.u_apple,
- observed_user=self.u_cabbage,
- )
- self.assertEquals(
- [],
- (yield self.datastore.get_presence_list(self.u_apple.localpart))
- )
- @defer.inlineCallbacks
- def test_get_presence_list(self):
- yield self.datastore.add_presence_list_pending(
- observer_localpart=self.u_apple.localpart,
- observed_userid=self.u_banana.to_string(),
- )
- yield self.datastore.set_presence_list_accepted(
- observer_localpart=self.u_apple.localpart,
- observed_userid=self.u_banana.to_string(),
- )
- presence = yield self.handler.get_presence_list(
- observer_user=self.u_apple)
- self.assertEquals([
- {"observed_user": self.u_banana,
- "presence": OFFLINE,
- "accepted": 1},
- ], presence)
- class PresencePushTestCase(MockedDatastorePresenceTestCase):
- """ Tests steady-state presence status updates.
- They assert that presence state update messages are pushed around the place
- when users change state, presuming that the watches are all established.
- These tests are MASSIVELY fragile currently as they poke internals of the
- presence handler; namely the _local_pushmap and _remote_recvmap.
- BE WARNED...
- """
- PRESENCE_LIST = {
- 'apple': [ "@banana:test", "@clementine:test" ],
- 'banana': [ "@apple:test" ],
- }
- @defer.inlineCallbacks
- def test_push_local(self):
- self.room_members = [self.u_apple, self.u_elderberry]
- self.datastore.set_presence_state.return_value = defer.succeed(
- {"state": ONLINE}
- )
- # TODO(paul): Gut-wrenching
- self.handler._user_cachemap[self.u_apple] = UserPresenceCache()
- self.handler._user_cachemap[self.u_apple].update(
- {"presence": OFFLINE}, serial=0
- )
- apple_set = self.handler._local_pushmap.setdefault("apple", set())
- apple_set.add(self.u_banana)
- apple_set.add(self.u_clementine)
- self.assertEquals(self.event_source.get_current_key(), 0)
- yield self.handler.set_state(self.u_apple, self.u_apple,
- {"presence": ONLINE}
- )
- # Apple sees self-reflection
- (events, _) = yield self.event_source.get_new_events_for_user(
- self.u_apple, 0, None
- )
- self.assertEquals(self.event_source.get_current_key(), 1)
- self.assertEquals(events,
- [
- {"type": "m.presence",
- "content": {
- "user_id": "@apple:test",
- "presence": ONLINE,
- "last_active_ago": 0,
- }},
- ],
- msg="Presence event should be visible to self-reflection"
- )
- config = SourcePaginationConfig(from_key=1, to_key=0)
- (chunk, _) = yield self.event_source.get_pagination_rows(
- self.u_apple, config, None
- )
- self.assertEquals(chunk,
- [
- {"type": "m.presence",
- "content": {
- "user_id": "@apple:test",
- "presence": ONLINE,
- "last_active_ago": 0,
- }},
- ]
- )
- # Banana sees it because of presence subscription
- (events, _) = yield self.event_source.get_new_events_for_user(
- self.u_banana, 0, None
- )
- self.assertEquals(self.event_source.get_current_key(), 1)
- self.assertEquals(events,
- [
- {"type": "m.presence",
- "content": {
- "user_id": "@apple:test",
- "presence": ONLINE,
- "last_active_ago": 0,
- }},
- ],
- msg="Presence event should be visible to explicit subscribers"
- )
- # Elderberry sees it because of same room
- (events, _) = yield self.event_source.get_new_events_for_user(
- self.u_elderberry, 0, None
- )
- self.assertEquals(self.event_source.get_current_key(), 1)
- self.assertEquals(events,
- [
- {"type": "m.presence",
- "content": {
- "user_id": "@apple:test",
- "presence": ONLINE,
- "last_active_ago": 0,
- }},
- ],
- msg="Presence event should be visible to other room members"
- )
- # Durian is not in the room, should not see this event
- (events, _) = yield self.event_source.get_new_events_for_user(
- self.u_durian, 0, None
- )
- self.assertEquals(self.event_source.get_current_key(), 1)
- self.assertEquals(events, [],
- msg="Presence event should not be visible to others"
- )
- presence = yield self.handler.get_presence_list(
- observer_user=self.u_apple, accepted=True)
- self.assertEquals(
- [
- {"observed_user": self.u_banana,
- "presence": OFFLINE,
- "accepted": True},
- {"observed_user": self.u_clementine,
- "presence": OFFLINE,
- "accepted": True},
- ],
- presence
- )
- # TODO(paul): Gut-wrenching
- banana_set = self.handler._local_pushmap.setdefault("banana", set())
- banana_set.add(self.u_apple)
- yield self.handler.set_state(self.u_banana, self.u_banana,
- {"presence": ONLINE}
- )
- self.clock.advance_time(2)
- presence = yield self.handler.get_presence_list(
- observer_user=self.u_apple, accepted=True)
- self.assertEquals([
- {"observed_user": self.u_banana,
- "presence": ONLINE,
- "last_active_ago": 2000,
- "accepted": True},
- {"observed_user": self.u_clementine,
- "presence": OFFLINE,
- "accepted": True},
- ], presence)
- (events, _) = yield self.event_source.get_new_events_for_user(
- self.u_apple, 1, None
- )
- self.assertEquals(self.event_source.get_current_key(), 2)
- self.assertEquals(events,
- [
- {"type": "m.presence",
- "content": {
- "user_id": "@banana:test",
- "presence": ONLINE,
- "last_active_ago": 2000
- }},
- ]
- )
- @defer.inlineCallbacks
- def test_push_remote(self):
- put_json = self.mock_http_client.put_json
- put_json.expect_call_and_return(
- call("farm",
- path=ANY, # Can't guarantee which txn ID will be which
- data=_expect_edu("farm", "m.presence",
- content={
- "push": [
- {"user_id": "@apple:test",
- "presence": u"online",
- "last_active_ago": 0},
- ],
- }
- ),
- json_data_callback=ANY,
- ),
- defer.succeed((200, "OK"))
- )
- put_json.expect_call_and_return(
- call("remote",
- path=ANY, # Can't guarantee which txn ID will be which
- data=_expect_edu("remote", "m.presence",
- content={
- "push": [
- {"user_id": "@apple:test",
- "presence": u"online",
- "last_active_ago": 0},
- ],
- }
- ),
- json_data_callback=ANY,
- ),
- defer.succeed((200, "OK"))
- )
- self.room_members = [self.u_apple, self.u_onion]
- self.datastore.set_presence_state.return_value = defer.succeed(
- {"state": ONLINE}
- )
- # TODO(paul): Gut-wrenching
- self.handler._user_cachemap[self.u_apple] = UserPresenceCache()
- self.handler._user_cachemap[self.u_apple].update(
- {"presence": OFFLINE}, serial=0
- )
- apple_set = self.handler._remote_sendmap.setdefault("apple", set())
- apple_set.add(self.u_potato.domain)
- yield self.handler.set_state(self.u_apple, self.u_apple,
- {"presence": ONLINE}
- )
- yield put_json.await_calls()
- @defer.inlineCallbacks
- def test_recv_remote(self):
- self.room_members = [self.u_apple, self.u_banana, self.u_potato]
- self.assertEquals(self.event_source.get_current_key(), 0)
- yield self.mock_federation_resource.trigger("PUT",
- "/_matrix/federation/v1/send/1000000/",
- _make_edu_json("elsewhere", "m.presence",
- content={
- "push": [
- {"user_id": "@potato:remote",
- "presence": "online",
- "last_active_ago": 1000},
- ],
- }
- )
- )
- (events, _) = yield self.event_source.get_new_events_for_user(
- self.u_apple, 0, None
- )
- self.assertEquals(self.event_source.get_current_key(), 1)
- self.assertEquals(events,
- [
- {"type": "m.presence",
- "content": {
- "user_id": "@potato:remote",
- "presence": ONLINE,
- "last_active_ago": 1000,
- }}
- ]
- )
- self.clock.advance_time(2)
- state = yield self.handler.get_state(self.u_potato, self.u_apple)
- self.assertEquals(
- {"presence": ONLINE, "last_active_ago": 3000},
- state
- )
- @defer.inlineCallbacks
- def test_recv_remote_offline(self):
- """ Various tests relating to SYN-261 """
- self.room_members = [self.u_apple, self.u_banana, self.u_potato]
- self.assertEquals(self.event_source.get_current_key(), 0)
- yield self.mock_federation_resource.trigger("PUT",
- "/_matrix/federation/v1/send/1000000/",
- _make_edu_json("elsewhere", "m.presence",
- content={
- "push": [
- {"user_id": "@potato:remote",
- "presence": "offline"},
- ],
- }
- )
- )
- self.assertEquals(self.event_source.get_current_key(), 1)
- (events, _) = yield self.event_source.get_new_events_for_user(
- self.u_apple, 0, None
- )
- self.assertEquals(events,
- [
- {"type": "m.presence",
- "content": {
- "user_id": "@potato:remote",
- "presence": OFFLINE,
- }}
- ]
- )
- yield self.mock_federation_resource.trigger("PUT",
- "/_matrix/federation/v1/send/1000001/",
- _make_edu_json("elsewhere", "m.presence",
- content={
- "push": [
- {"user_id": "@potato:remote",
- "presence": "online"},
- ],
- }
- )
- )
- self.assertEquals(self.event_source.get_current_key(), 2)
- (events, _) = yield self.event_source.get_new_events_for_user(
- self.u_apple, 0, None
- )
- self.assertEquals(events,
- [
- {"type": "m.presence",
- "content": {
- "user_id": "@potato:remote",
- "presence": ONLINE,
- }}
- ]
- )
- @defer.inlineCallbacks
- def test_join_room_local(self):
- self.room_members = [self.u_apple, self.u_banana]
- self.assertEquals(self.event_source.get_current_key(), 0)
- # TODO(paul): Gut-wrenching
- self.handler._user_cachemap[self.u_clementine] = UserPresenceCache()
- self.handler._user_cachemap[self.u_clementine].update(
- {
- "presence": PresenceState.ONLINE,
- "last_active": self.clock.time_msec(),
- }, self.u_clementine
- )
- yield self.distributor.fire("user_joined_room", self.u_clementine,
- self.room_id
- )
- self.room_members.append(self.u_clementine)
- (events, _) = yield self.event_source.get_new_events_for_user(
- self.u_apple, 0, None
- )
- self.assertEquals(self.event_source.get_current_key(), 1)
- self.assertEquals(events,
- [
- {"type": "m.presence",
- "content": {
- "user_id": "@clementine:test",
- "presence": ONLINE,
- "last_active_ago": 0,
- }}
- ]
- )
- @defer.inlineCallbacks
- def test_join_room_remote(self):
- ## Sending local user state to a newly-joined remote user
- put_json = self.mock_http_client.put_json
- put_json.expect_call_and_return(
- call("remote",
- path=ANY, # Can't guarantee which txn ID will be which
- data=_expect_edu("remote", "m.presence",
- content={
- "push": [
- {"user_id": "@apple:test",
- "presence": "online"},
- ],
- }
- ),
- json_data_callback=ANY,
- ),
- defer.succeed((200, "OK"))
- )
- put_json.expect_call_and_return(
- call("remote",
- path=ANY, # Can't guarantee which txn ID will be which
- data=_expect_edu("remote", "m.presence",
- content={
- "push": [
- {"user_id": "@banana:test",
- "presence": "offline"},
- ],
- }
- ),
- json_data_callback=ANY,
- ),
- defer.succeed((200, "OK"))
- )
- # TODO(paul): Gut-wrenching
- self.handler._user_cachemap[self.u_apple] = UserPresenceCache()
- self.handler._user_cachemap[self.u_apple].update(
- {"presence": PresenceState.ONLINE}, self.u_apple)
- self.room_members = [self.u_apple, self.u_banana]
- yield self.distributor.fire("user_joined_room", self.u_potato,
- self.room_id
- )
- yield put_json.await_calls()
- ## Sending newly-joined local user state to remote users
- put_json.expect_call_and_return(
- call("remote",
- path="/_matrix/federation/v1/send/1000002/",
- data=_expect_edu("remote", "m.presence",
- content={
- "push": [
- {"user_id": "@clementine:test",
- "presence": "online"},
- ],
- }
- ),
- json_data_callback=ANY,
- ),
- defer.succeed((200, "OK"))
- )
- self.handler._user_cachemap[self.u_clementine] = UserPresenceCache()
- self.handler._user_cachemap[self.u_clementine].update(
- {"presence": ONLINE}, self.u_clementine)
- self.room_members.append(self.u_potato)
- yield self.distributor.fire("user_joined_room", self.u_clementine,
- self.room_id
- )
- put_json.await_calls()
- class PresencePollingTestCase(MockedDatastorePresenceTestCase):
- """ Tests presence status polling. """
- # For this test, we have three local users; apple is watching and is
- # watched by the other two, but the others don't watch each other.
- # Additionally clementine is watching a remote user.
- PRESENCE_LIST = {
- 'apple': [ "@banana:test", "@clementine:test" ],
- 'banana': [ "@apple:test" ],
- 'clementine': [ "@apple:test", "@potato:remote" ],
- 'fig': [ "@potato:remote" ],
- }
- @defer.inlineCallbacks
- def setUp(self):
- yield super(PresencePollingTestCase, self).setUp()
- self.mock_update_client = Mock()
- def update(*args,**kwargs):
- return defer.succeed(None)
- self.mock_update_client.side_effect = update
- self.handler.push_update_to_clients = self.mock_update_client
- @defer.inlineCallbacks
- def test_push_local(self):
- # apple goes online
- yield self.handler.set_state(
- target_user=self.u_apple, auth_user=self.u_apple,
- state={"presence": ONLINE}
- )
- # apple should see both banana and clementine currently offline
- self.mock_update_client.assert_has_calls([
- call(users_to_push=[self.u_apple]),
- call(users_to_push=[self.u_apple]),
- ], any_order=True)
- # Gut-wrenching tests
- self.assertTrue("banana" in self.handler._local_pushmap)
- self.assertTrue(self.u_apple in self.handler._local_pushmap["banana"])
- self.assertTrue("clementine" in self.handler._local_pushmap)
- self.assertTrue(self.u_apple in self.handler._local_pushmap["clementine"])
- self.mock_update_client.reset_mock()
- # banana goes online
- yield self.handler.set_state(
- target_user=self.u_banana, auth_user=self.u_banana,
- state={"presence": ONLINE}
- )
- # apple and banana should now both see each other online
- self.mock_update_client.assert_has_calls([
- call(users_to_push=set([self.u_apple]), room_ids=[]),
- call(users_to_push=[self.u_banana]),
- ], any_order=True)
- self.assertTrue("apple" in self.handler._local_pushmap)
- self.assertTrue(self.u_banana in self.handler._local_pushmap["apple"])
- self.mock_update_client.reset_mock()
- # apple goes offline
- yield self.handler.set_state(
- target_user=self.u_apple, auth_user=self.u_apple,
- state={"presence": OFFLINE}
- )
- # banana should now be told apple is offline
- self.mock_update_client.assert_has_calls([
- call(users_to_push=set([self.u_banana, self.u_apple]), room_ids=[]),
- ], any_order=True)
- self.assertFalse("banana" in self.handler._local_pushmap)
- self.assertFalse("clementine" in self.handler._local_pushmap)
- @defer.inlineCallbacks
- def test_remote_poll_send(self):
- put_json = self.mock_http_client.put_json
- put_json.expect_call_and_return(
- call("remote",
- path=ANY,
- data=_expect_edu("remote", "m.presence",
- content={
- "poll": [ "@potato:remote" ],
- },
- ),
- json_data_callback=ANY,
- ),
- defer.succeed((200, "OK"))
- )
- put_json.expect_call_and_return(
- call("remote",
- path=ANY,
- data=_expect_edu("remote", "m.presence",
- content={
- "push": [ {
- "user_id": "@clementine:test",
- "presence": OFFLINE,
- }],
- },
- ),
- json_data_callback=ANY,
- ),
- defer.succeed((200, "OK"))
- )
- # clementine goes online
- yield self.handler.set_state(
- target_user=self.u_clementine, auth_user=self.u_clementine,
- state={"presence": ONLINE}
- )
- yield put_json.await_calls()
- # Gut-wrenching tests
- self.assertTrue(self.u_potato in self.handler._remote_recvmap,
- msg="expected potato to be in _remote_recvmap"
- )
- self.assertTrue(self.u_clementine in
- self.handler._remote_recvmap[self.u_potato])
- put_json.expect_call_and_return(
- call("remote",
- path=ANY,
- data=_expect_edu("remote", "m.presence",
- content={
- "push": [ {
- "user_id": "@fig:test",
- "presence": OFFLINE,
- }],
- },
- ),
- json_data_callback=ANY,
- ),
- defer.succeed((200, "OK"))
- )
- # fig goes online; shouldn't send a second poll
- yield self.handler.set_state(
- target_user=self.u_fig, auth_user=self.u_fig,
- state={"presence": ONLINE}
- )
- # reactor.iterate(delay=0)
- yield put_json.await_calls()
- # fig goes offline
- yield self.handler.set_state(
- target_user=self.u_fig, auth_user=self.u_fig,
- state={"presence": OFFLINE}
- )
- reactor.iterate(delay=0)
- put_json.assert_had_no_calls()
- put_json.expect_call_and_return(
- call("remote",
- path=ANY,
- data=_expect_edu("remote", "m.presence",
- content={
- "unpoll": [ "@potato:remote" ],
- },
- ),
- json_data_callback=ANY,
- ),
- defer.succeed((200, "OK"))
- )
- # clementine goes offline
- yield self.handler.set_state(
- target_user=self.u_clementine, auth_user=self.u_clementine,
- state={"presence": OFFLINE}
- )
- yield put_json.await_calls()
- self.assertFalse(self.u_potato in self.handler._remote_recvmap,
- msg="expected potato not to be in _remote_recvmap"
- )
- @defer.inlineCallbacks
- def test_remote_poll_receive(self):
- put_json = self.mock_http_client.put_json
- put_json.expect_call_and_return(
- call("remote",
- path="/_matrix/federation/v1/send/1000000/",
- data=_expect_edu("remote", "m.presence",
- content={
- "push": [
- {"user_id": "@banana:test",
- "presence": "offline",
- "status_msg": None},
- ],
- },
- ),
- json_data_callback=ANY,
- ),
- defer.succeed((200, "OK"))
- )
- yield self.mock_federation_resource.trigger("PUT",
- "/_matrix/federation/v1/send/1000000/",
- _make_edu_json("remote", "m.presence",
- content={
- "poll": [ "@banana:test" ],
- },
- )
- )
- yield put_json.await_calls()
- # Gut-wrenching tests
- self.assertTrue(self.u_banana in self.handler._remote_sendmap)
- yield self.mock_federation_resource.trigger("PUT",
- "/_matrix/federation/v1/send/1000001/",
- _make_edu_json("remote", "m.presence",
- content={
- "unpoll": [ "@banana:test" ],
- }
- )
- )
- # Gut-wrenching tests
- self.assertFalse(self.u_banana in self.handler._remote_sendmap)
|