def setUp(self): 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( "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) hs.get_handlers().federation_handler = Mock() def _get_user_by_token(token=None): return { "user": hs.parse_userid(self.auth_user_id), "admin": False, "device_id": None, } hs.get_auth().get_user_by_token = _get_user_by_token def _insert_client_ip(*args, **kwargs): return defer.succeed(None) hs.get_datastore().insert_client_ip = _insert_client_ip synapse.rest.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)) # create the room self.room_id = yield self.create_room_as(self.user_id)
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) self.auth_user_id = self.user_id state_handler = Mock(spec=["handle_new_event"]) state_handler.handle_new_event.return_value = True persistence_service = Mock(spec=["get_latest_pdus_in_context"]) persistence_service.get_latest_pdus_in_context.return_value = [] hs = HomeServer( "red", db_pool=None, http_client=None, datastore=MemoryDataStore(), replication_layer=Mock(), state_handler=state_handler, persistence_service=persistence_service, ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), config=NonCallableMock(), ) self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0) hs.get_handlers().federation_handler = Mock() def _get_user_by_token(token=None): return hs.parse_userid(self.auth_user_id) hs.get_auth().get_user_by_token = _get_user_by_token synapse.rest.room.register_servlets(hs, self.mock_resource) self.room_id = yield self.create_room_as(self.user_id)
def setUp(self): self.mock_federation = Mock(spec=[ "make_query", ]) self.query_handlers = {} def register_query_handler(query_type, handler): self.query_handlers[query_type] = handler self.mock_federation.register_query_handler = register_query_handler db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer("test", db_pool=db_pool, http_client=None, handlers=None, resource_for_federation=Mock(), replication_layer=self.mock_federation, ) hs.handlers = ProfileHandlers(hs) 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") yield self.store.create_profile(self.frank.localpart) self.handler = hs.get_handlers().profile_handler # TODO(paul): Icky signal declarings.. booo hs.get_distributor().declare("changed_presencelike_data")
def setUp(self): self.mock_federation = Mock(spec=[ "make_query", ]) self.query_handlers = {} def register_query_handler(query_type, handler): self.query_handlers[query_type] = handler self.mock_federation.register_query_handler = register_query_handler db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer("test", db_pool=db_pool, http_client=None, resource_for_federation=Mock(), replication_layer=self.mock_federation, ) hs.handlers = DirectoryHandlers(hs) self.handler = hs.get_handlers().directory_handler 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")
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) self.mock_handler = Mock(spec=[ "get_displayname", "set_displayname", "get_avatar_url", "set_avatar_url", ]) self.mock_config = NonCallableMock() self.mock_config.signing_key = [MockKey()] hs = HomeServer("test", db_pool=None, 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) hs.get_auth().get_user_by_req = _get_user_by_req hs.get_handlers().profile_handler = self.mock_handler hs.register_servlets()
def setUp(self): self.mock_federation = Mock(spec=[ "make_query", ]) self.query_handlers = {} def register_query_handler(query_type, handler): self.query_handlers[query_type] = handler self.mock_federation.register_query_handler = register_query_handler hs = HomeServer("test", db_pool=None, http_client=None, datastore=Mock(spec=[ "get_profile_displayname", "set_profile_displayname", "get_profile_avatar_url", "set_profile_avatar_url", ]), handlers=None, resource_for_federation=Mock(), replication_layer=self.mock_federation, ) hs.handlers = ProfileHandlers(hs) self.datastore = 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.handler = hs.get_handlers().profile_handler # TODO(paul): Icky signal declarings.. booo hs.get_distributor().declare("changed_presencelike_data")
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) self.mock_handler = Mock(spec=[ "get_displayname", "set_displayname", "get_avatar_url", "set_avatar_url", ]) self.mock_config = NonCallableMock() self.mock_config.signing_key = [MockKey()] hs = HomeServer( "test", db_pool=None, 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) hs.get_auth().get_user_by_req = _get_user_by_req hs.get_handlers().profile_handler = self.mock_handler hs.register_servlets()
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, resource_for_federation=Mock(), http_client=None, ) # We can't test the RoomMemberStore on its own without the other event # storage logic self.store = hs.get_datastore() self.event_builder_factory = hs.get_event_builder_factory() 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") # User elsewhere on another host self.u_charlie = hs.parse_userid("@charlie:elsewhere") self.room = hs.parse_roomid("!abc123:test")
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, resource_for_federation=Mock(), http_client=None, ) self.store = hs.get_datastore() self.event_builder_factory = hs.get_event_builder_factory() 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.room1 = hs.parse_roomid("!abc123:test") self.room2 = hs.parse_roomid("!xyx987:test") self.depth = 1
def setUp(self): self.mock_federation = Mock(spec=[ "make_query", ]) self.query_handlers = {} def register_query_handler(query_type, handler): self.query_handlers[query_type] = handler self.mock_federation.register_query_handler = register_query_handler hs = HomeServer("test", datastore=Mock(spec=[ "get_association_from_room_alias", "get_joined_hosts_for_room", ]), http_client=None, resource_for_federation=Mock(), replication_layer=self.mock_federation, ) hs.handlers = DirectoryHandlers(hs) self.handler = hs.get_handlers().directory_handler self.datastore = hs.get_datastore() def hosts(room_id): return defer.succeed([]) self.datastore.get_joined_hosts_for_room.side_effect = hosts self.my_room = hs.parse_roomalias("#my-room:test") self.remote_room = hs.parse_roomalias("#another:remote")
def setUp(self): self.hostname = "test" hs = HomeServer( self.hostname, db_pool=None, datastore=NonCallableMock(spec_set=[ "persist_event", "store_room", "get_room", ]), resource_for_federation=NonCallableMock(), http_client=NonCallableMock(spec_set=[]), notifier=NonCallableMock(spec_set=["on_new_room_event"]), handlers=NonCallableMock(spec_set=[ "room_member_handler", "federation_handler", ]), ) self.datastore = hs.get_datastore() self.handlers = hs.get_handlers() self.notifier = hs.get_notifier() self.hs = hs self.handlers.federation_handler = FederationHandler(self.hs)
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) self.mock_handler = Mock(spec=[ "get_displayname", "set_displayname", "get_avatar_url", "set_avatar_url", ]) hs = HomeServer("test", db_pool=None, http_client=None, resource_for_client=self.mock_resource, federation=Mock(), replication_layer=Mock(), datastore=None, ) def _get_user_by_token(token=None): return hs.parse_userid(myid) hs.get_auth().get_user_by_token = _get_user_by_token hs.get_handlers().profile_handler = self.mock_handler hs.register_servlets()
def setUp(self): self.hostname = "test" hs = HomeServer( self.hostname, db_pool=None, datastore=NonCallableMock(spec_set=[ "persist_event", "store_room", "get_room", ]), resource_for_federation=NonCallableMock(), http_client=NonCallableMock(spec_set=[]), notifier=NonCallableMock(spec_set=["on_new_room_event"]), handlers=NonCallableMock(spec_set=[ "room_member_handler", "federation_handler", ]), ) self.datastore = hs.get_datastore() self.handlers = hs.get_handlers() self.notifier = hs.get_notifier() self.hs = hs self.handlers.federation_handler = FederationHandler(self.hs)
def setUp(self): self.mock_federation = Mock(spec=[ "make_query", ]) self.query_handlers = {} def register_query_handler(query_type, handler): 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, resource_for_federation=Mock(), replication_layer=self.mock_federation, config=self.mock_config, ) hs.handlers = DirectoryHandlers(hs) self.handler = hs.get_handlers().directory_handler 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")
def setUp(self): 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( "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) hs.get_handlers().federation_handler = Mock() def _get_user_by_token(token=None): return { "user": hs.parse_userid(self.auth_user_id), "admin": False, "device_id": None, } hs.get_auth().get_user_by_token = _get_user_by_token def _insert_client_ip(*args, **kwargs): return defer.succeed(None) hs.get_datastore().insert_client_ip = _insert_client_ip synapse.rest.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) ) # create the room self.room_id = yield self.create_room_as(self.user_id)
def setUp(self): db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer("test", clock=MockClock(), db_pool=db_pool, handlers=None, resource_for_federation=Mock(), http_client=None, ) hs.handlers = JustPresenceHandlers(hs) self.store = hs.get_datastore() # Mock the RoomMemberHandler room_member_handler = Mock(spec=[]) hs.handlers.room_member_handler = room_member_handler # 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") 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.handler = hs.get_handlers().presence_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([]) 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([]) room_member_handler.get_room_members = get_room_members 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 self.mock_start = Mock() self.mock_stop = Mock() self.handler.start_polling_presence = self.mock_start self.handler.stop_polling_presence = self.mock_stop
def setUp(self): self.mock_config = NonCallableMock() self.mock_config.signing_key = [MockKey()] self.hostname = "red" hs = HomeServer( self.hostname, db_pool=None, ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), datastore=NonCallableMock(spec_set=[ "persist_event", "get_joined_hosts_for_room", "get_room_member", "get_room", "store_room", "snapshot_room", ]), resource_for_federation=NonCallableMock(), http_client=NonCallableMock(spec_set=[]), notifier=NonCallableMock(spec_set=["on_new_room_event"]), handlers=NonCallableMock(spec_set=[ "room_member_handler", "profile_handler", "federation_handler", ]), auth=NonCallableMock(spec_set=["check"]), state_handler=NonCallableMock(spec_set=["handle_new_event"]), config=self.mock_config, ) self.federation = NonCallableMock(spec_set=[ "handle_new_event", "get_state_for_room", ]) self.datastore = hs.get_datastore() self.handlers = hs.get_handlers() self.notifier = hs.get_notifier() self.state_handler = hs.get_state_handler() self.distributor = hs.get_distributor() self.hs = hs self.handlers.federation_handler = self.federation self.distributor.declare("collect_presencelike_data") self.handlers.room_member_handler = RoomMemberHandler(self.hs) self.handlers.profile_handler = ProfileHandler(self.hs) self.room_member_handler = self.handlers.room_member_handler self.snapshot = Mock() self.datastore.snapshot_room.return_value = self.snapshot self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0)
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) persistence_service = Mock(spec=["get_latest_pdus_in_context"]) persistence_service.get_latest_pdus_in_context.return_value = [] self.mock_config = NonCallableMock() self.mock_config.signing_key = [MockKey()] db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer( "test", db_pool=db_pool, http_client=None, replication_layer=Mock(), persistence_service=persistence_service, clock=Mock(spec=[ "call_later", "cancel_call_later", "time_msec", "time" ]), ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), config=self.mock_config, ) self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0) hs.config.enable_registration_captcha = False hs.get_handlers().federation_handler = Mock() 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) # register an account self.user_id = "sid1" response = yield self.register(self.user_id) self.token = response["access_token"] self.user_id = response["user_id"] # register a 2nd account self.other_user = "******" response = yield self.register(self.other_user) self.other_token = response["access_token"] self.other_user = response["user_id"]
def setUp(self): self.hostname = "red" hs = HomeServer( self.hostname, db_pool=None, datastore=NonCallableMock(spec_set=[ "store_room", "snapshot_room", "persist_event", "get_joined_hosts_for_room", ]), http_client=NonCallableMock(spec_set=[]), notifier=NonCallableMock(spec_set=["on_new_room_event"]), handlers=NonCallableMock(spec_set=[ "room_creation_handler", "room_member_handler", "federation_handler", ]), auth=NonCallableMock(spec_set=["check"]), state_handler=NonCallableMock(spec_set=["handle_new_event"]), ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), config=NonCallableMock(), ) self.federation = NonCallableMock(spec_set=[ "handle_new_event", ]) self.datastore = hs.get_datastore() self.handlers = hs.get_handlers() self.notifier = hs.get_notifier() self.state_handler = hs.get_state_handler() self.hs = hs self.handlers.federation_handler = self.federation self.handlers.room_creation_handler = RoomCreationHandler(self.hs) self.room_creation_handler = self.handlers.room_creation_handler self.handlers.room_member_handler = NonCallableMock(spec_set=[ "change_membership" ]) self.room_member_handler = self.handlers.room_member_handler def hosts(room): return defer.succeed([]) self.datastore.get_joined_hosts_for_room.side_effect = hosts self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0)
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, http_client=None, replication_layer=Mock(), clock=Mock(spec=[ "call_later", "cancel_call_later", "time_msec", "time" ]), ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), config=self.mock_config, ) self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0) hs.config.enable_registration_captcha = False hs.get_handlers().federation_handler = Mock() 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) # register an account self.user_id = "sid1" response = yield self.register(self.user_id) self.token = response["access_token"] self.user_id = response["user_id"] # register a 2nd account self.other_user = "******" response = yield self.register(self.other_user) self.other_token = response["access_token"] self.other_user = response["user_id"]
def setUp(self): 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( "red", db_pool=db_pool, http_client=None, replication_layer=Mock(), ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), config=self.mock_config, ) self.hs = hs self.event_source = hs.get_event_sources().sources["typing"] self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0) hs.get_handlers().federation_handler = Mock() def _get_user_by_token(token=None): return { "user": hs.parse_userid(self.auth_user_id), "admin": False, "device_id": None, } hs.get_auth().get_user_by_token = _get_user_by_token def _insert_client_ip(*args, **kwargs): return defer.succeed(None) hs.get_datastore().insert_client_ip = _insert_client_ip synapse.rest.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 yield self.join(self.room_id, user="******")
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) state_handler = Mock(spec=["handle_new_event"]) state_handler.handle_new_event.return_value = True persistence_service = Mock(spec=["get_latest_pdus_in_context"]) persistence_service.get_latest_pdus_in_context.return_value = [] hs = HomeServer( "test", db_pool=None, http_client=None, replication_layer=Mock(), state_handler=state_handler, datastore=MemoryDataStore(), persistence_service=persistence_service, clock=Mock( spec=["call_later", "cancel_call_later", "time_msec", "time"]), ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), config=NonCallableMock(), ) self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0) hs.config.enable_registration_captcha = False hs.get_handlers().federation_handler = Mock() hs.get_clock().time_msec.return_value = 1000000 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) # register an account self.user_id = "sid1" response = yield self.register(self.user_id) self.token = response["access_token"] self.user_id = response["user_id"] # register a 2nd account self.other_user = "******" response = yield self.register(self.other_user) self.other_token = response["access_token"] self.other_user = response["user_id"]
def setUp(self): self.mock_federation = Mock(spec=[ "make_query", ]) self.query_handlers = {} def register_query_handler(query_type, handler): 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", ])) self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0) hs.handlers = ProfileHandlers(hs) 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") yield self.store.create_profile(self.frank.localpart) self.handler = hs.get_handlers().profile_handler # TODO(paul): Icky signal declarings.. booo hs.get_distributor().declare("changed_presencelike_data")
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
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
def setUp(self): self.mock_config = NonCallableMock() self.mock_config.signing_key = [MockKey()] self.state_handler = NonCallableMock(spec_set=[ "compute_event_context", ]) self.auth = NonCallableMock(spec_set=[ "check", "check_host_in_room", ]) self.hostname = "test" hs = HomeServer( self.hostname, db_pool=None, datastore=NonCallableMock(spec_set=[ "persist_event", "store_room", "get_room", "get_destination_retry_timings", "set_destination_retry_timings", ]), resource_for_federation=NonCallableMock(), http_client=NonCallableMock(spec_set=[]), notifier=NonCallableMock(spec_set=["on_new_room_event"]), handlers=NonCallableMock(spec_set=[ "room_member_handler", "federation_handler", ]), config=self.mock_config, auth=self.auth, state_handler=self.state_handler, keyring=Mock(), ) self.datastore = hs.get_datastore() self.handlers = hs.get_handlers() self.notifier = hs.get_notifier() self.hs = hs self.handlers.federation_handler = FederationHandler(self.hs)
def setUp(self): self.hostname = "red" self.mock_config = NonCallableMock() self.mock_config.signing_key = [MockKey()] hs = HomeServer( self.hostname, db_pool=None, datastore=NonCallableMock(spec_set=[ "store_room", "snapshot_room", "persist_event", "get_joined_hosts_for_room", ]), http_client=NonCallableMock(spec_set=[]), notifier=NonCallableMock(spec_set=["on_new_room_event"]), handlers=NonCallableMock(spec_set=[ "room_creation_handler", "message_handler", ]), auth=NonCallableMock(spec_set=["check", "add_auth_events"]), ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), config=self.mock_config, ) self.federation = NonCallableMock(spec_set=[ "handle_new_event", ]) self.handlers = hs.get_handlers() self.handlers.room_creation_handler = RoomCreationHandler(hs) self.room_creation_handler = self.handlers.room_creation_handler self.message_handler = self.handlers.message_handler self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0)
def setUp(self): self.hostname = "red" self.mock_config = NonCallableMock() self.mock_config.signing_key = [MockKey()] hs = HomeServer( self.hostname, db_pool=None, datastore=NonCallableMock(spec_set=[ "store_room", "snapshot_room", "persist_event", "get_joined_hosts_for_room", ]), http_client=NonCallableMock(spec_set=[]), notifier=NonCallableMock(spec_set=["on_new_room_event"]), handlers=NonCallableMock(spec_set=[ "room_creation_handler", "message_handler", ]), auth=NonCallableMock(spec_set=["check", "add_auth_events"]), ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), config=self.mock_config, ) self.federation = NonCallableMock(spec_set=[ "handle_new_event", ]) self.handlers = hs.get_handlers() self.handlers.room_creation_handler = RoomCreationHandler(hs) self.room_creation_handler = self.handlers.room_creation_handler self.message_handler = self.handlers.message_handler self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0)
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) # HIDEOUS HACKERY # TODO(paul): This should be injected in via the HomeServer DI system from synapse.streams.events import ( PresenceEventSource, NullSource, EventSources ) old_SOURCE_TYPES = EventSources.SOURCE_TYPES def tearDown(): EventSources.SOURCE_TYPES = old_SOURCE_TYPES self.tearDown = tearDown EventSources.SOURCE_TYPES = { k: NullSource for k in old_SOURCE_TYPES.keys() } EventSources.SOURCE_TYPES["presence"] = PresenceEventSource hs = HomeServer("test", db_pool=None, http_client=None, resource_for_client=self.mock_resource, resource_for_federation=self.mock_resource, datastore=Mock(spec=[ "set_presence_state", "get_presence_list", ]), clock=Mock(spec=[ "call_later", "cancel_call_later", "time_msec", ]), ) hs.get_clock().time_msec.return_value = 1000000 def _get_user_by_req(req=None): return hs.parse_userid(myid) hs.get_auth().get_user_by_req = _get_user_by_req hs.register_servlets() hs.handlers.room_member_handler = Mock(spec=[]) self.room_members = [] def get_rooms_for_user(user): if user in self.room_members: return ["a-room"] else: return [] hs.handlers.room_member_handler.get_rooms_for_user = get_rooms_for_user self.mock_datastore = hs.get_datastore() def get_profile_displayname(user_id): return defer.succeed("Frank") self.mock_datastore.get_profile_displayname = get_profile_displayname def get_profile_avatar_url(user_id): return defer.succeed(None) self.mock_datastore.get_profile_avatar_url = get_profile_avatar_url def user_rooms_intersect(user_list): room_member_ids = map(lambda u: u.to_string(), self.room_members) shared = all(map(lambda i: i in room_member_ids, user_list)) return defer.succeed(shared) self.mock_datastore.user_rooms_intersect = user_rooms_intersect def get_joined_hosts_for_room(room_id): return [] self.mock_datastore.get_joined_hosts_for_room = get_joined_hosts_for_room self.presence = hs.get_handlers().presence_handler self.u_apple = hs.parse_userid("@apple:test") self.u_banana = hs.parse_userid("@banana:test")
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) state_handler = Mock(spec=["handle_new_event"]) state_handler.handle_new_event.return_value = True persistence_service = Mock(spec=["get_latest_pdus_in_context"]) persistence_service.get_latest_pdus_in_context.return_value = [] hs = HomeServer( "red", db_pool=None, http_client=None, datastore=MemoryDataStore(), replication_layer=Mock(), state_handler=state_handler, persistence_service=persistence_service, ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), config=NonCallableMock(), ) self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0) hs.get_handlers().federation_handler = Mock() def _get_user_by_token(token=None): return hs.parse_userid(self.auth_user_id) hs.get_auth().get_user_by_token = _get_user_by_token self.auth_user_id = self.rmcreator_id synapse.rest.room.register_servlets(hs, self.mock_resource) self.auth = hs.get_auth() # create some rooms under the name rmcreator_id self.uncreated_rmid = "!aa:test" self.created_rmid = yield self.create_room_as(self.rmcreator_id, is_public=False) self.created_public_rmid = yield self.create_room_as(self.rmcreator_id, is_public=True) # send a message in one of the rooms self.created_rmid_msg_path = ("/rooms/%s/send/m.room.message/a1" % (self.created_rmid)) (code, response) = yield self.mock_resource.trigger( "PUT", self.created_rmid_msg_path, '{"msgtype":"m.text","body":"test msg"}') self.assertEquals(200, code, msg=str(response)) # set topic for public room (code, response) = yield self.mock_resource.trigger( "PUT", "/rooms/%s/state/m.room.topic" % self.created_public_rmid, '{"topic":"Public Room Topic"}') self.assertEquals(200, code, msg=str(response)) # auth as user_id now self.auth_user_id = self.user_id
def setUp(self): self.clock = MockClock() self.mock_http_client = Mock(spec=[]) self.mock_http_client.put_json = DeferredMockCallable() self.mock_federation_resource = MockHttpResource() 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", ]), handlers=None, resource_for_client=Mock(), resource_for_federation=self.mock_federation_resource, http_client=self.mock_http_client, ) hs.handlers = JustPresenceHandlers(hs) self.datastore = hs.get_datastore() 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")
def setUp(self): db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer( "test", clock=MockClock(), db_pool=db_pool, handlers=None, resource_for_federation=Mock(), http_client=None, ) hs.handlers = JustPresenceHandlers(hs) self.store = hs.get_datastore() # Mock the RoomMemberHandler room_member_handler = Mock(spec=[]) hs.handlers.room_member_handler = room_member_handler # 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") 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.handler = hs.get_handlers().presence_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([]) 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([]) room_member_handler.get_room_members = get_room_members 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 self.mock_start = Mock() self.mock_stop = Mock() self.handler.start_polling_presence = self.mock_start self.handler.stop_polling_presence = self.mock_stop
def setUp(self): 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(), ) hs.handlers = PresenceAndProfileHandlers(hs) self.datastore = hs.get_datastore() self.replication = hs.get_replication_layer() self.replication.send_edu = Mock() def send_edu(*args, **kwargs): # print "send_edu: %s, %s" % (args, kwargs) return defer.succeed((200, "OK")) self.replication.send_edu.side_effect = send_edu def get_profile_displayname(user_localpart): return defer.succeed("Frank") self.datastore.get_profile_displayname = get_profile_displayname def is_presence_visible(*args, **kwargs): return defer.succeed(False) self.datastore.is_presence_visible = is_presence_visible def get_profile_avatar_url(user_localpart): return defer.succeed("http://foo") self.datastore.get_profile_avatar_url = get_profile_avatar_url self.presence_list = [ {"observed_user_id": "@banana:test"}, {"observed_user_id": "@clementine:test"}, ] def get_presence_list(user_localpart, accepted=None): return defer.succeed(self.presence_list) self.datastore.get_presence_list = get_presence_list def user_rooms_intersect(userlist): return defer.succeed(False) self.datastore.user_rooms_intersect = user_rooms_intersect self.handlers = hs.get_handlers() self.mock_update_client = Mock() def update(*args, **kwargs): # print "mock_update_client: %s, %s" %(args, kwargs) return defer.succeed(None) self.mock_update_client.side_effect = update self.handlers.presence_handler.push_update_to_clients = ( self.mock_update_client) hs.handlers.room_member_handler = Mock(spec=[ "get_rooms_for_user", ]) hs.handlers.room_member_handler.get_rooms_for_user = ( 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") # Remote user self.u_potato = hs.parse_userid("@potato:remote") self.mock_get_joined = ( self.datastore.get_rooms_for_user_where_membership_is )
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) # HIDEOUS HACKERY # TODO(paul): This should be injected in via the HomeServer DI system from synapse.streams.events import (PresenceEventSource, NullSource, EventSources) old_SOURCE_TYPES = EventSources.SOURCE_TYPES def tearDown(): EventSources.SOURCE_TYPES = old_SOURCE_TYPES self.tearDown = tearDown EventSources.SOURCE_TYPES = { k: NullSource for k in old_SOURCE_TYPES.keys() } EventSources.SOURCE_TYPES["presence"] = PresenceEventSource hs = HomeServer( "test", db_pool=None, http_client=None, resource_for_client=self.mock_resource, resource_for_federation=self.mock_resource, datastore=Mock(spec=[ "set_presence_state", "get_presence_list", ]), clock=Mock(spec=[ "call_later", "cancel_call_later", "time_msec", ]), ) hs.get_clock().time_msec.return_value = 1000000 def _get_user_by_req(req=None): return hs.parse_userid(myid) hs.get_auth().get_user_by_req = _get_user_by_req hs.register_servlets() hs.handlers.room_member_handler = Mock(spec=[]) self.room_members = [] def get_rooms_for_user(user): if user in self.room_members: return ["a-room"] else: return [] hs.handlers.room_member_handler.get_rooms_for_user = get_rooms_for_user self.mock_datastore = hs.get_datastore() def get_profile_displayname(user_id): return defer.succeed("Frank") self.mock_datastore.get_profile_displayname = get_profile_displayname def get_profile_avatar_url(user_id): return defer.succeed(None) self.mock_datastore.get_profile_avatar_url = get_profile_avatar_url def user_rooms_intersect(user_list): room_member_ids = map(lambda u: u.to_string(), self.room_members) shared = all(map(lambda i: i in room_member_ids, user_list)) return defer.succeed(shared) self.mock_datastore.user_rooms_intersect = user_rooms_intersect def get_joined_hosts_for_room(room_id): return [] self.mock_datastore.get_joined_hosts_for_room = get_joined_hosts_for_room self.presence = hs.get_handlers().presence_handler self.u_apple = hs.parse_userid("@apple:test") self.u_banana = hs.parse_userid("@banana:test")
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( "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) hs.get_handlers().federation_handler = Mock() def _get_user_by_token(token=None): return { "user": hs.parse_userid(self.auth_user_id), "admin": False, "device_id": None, } hs.get_auth().get_user_by_token = _get_user_by_token def _insert_client_ip(*args, **kwargs): return defer.succeed(None) hs.get_datastore().insert_client_ip = _insert_client_ip self.auth_user_id = self.rmcreator_id synapse.rest.room.register_servlets(hs, self.mock_resource) self.auth = hs.get_auth() # create some rooms under the name rmcreator_id self.uncreated_rmid = "!aa:test" self.created_rmid = yield self.create_room_as(self.rmcreator_id, is_public=False) self.created_public_rmid = yield self.create_room_as(self.rmcreator_id, is_public=True) # send a message in one of the rooms self.created_rmid_msg_path = ("/rooms/%s/send/m.room.message/a1" % (self.created_rmid)) (code, response) = yield self.mock_resource.trigger( "PUT", self.created_rmid_msg_path, '{"msgtype":"m.text","body":"test msg"}') self.assertEquals(200, code, msg=str(response)) # set topic for public room (code, response) = yield self.mock_resource.trigger( "PUT", "/rooms/%s/state/m.room.topic" % self.created_public_rmid, '{"topic":"Public Room Topic"}') self.assertEquals(200, code, msg=str(response)) # auth as user_id now self.auth_user_id = self.user_id
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 = 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.handlers = JustTypingNotificationHandlers(hs) self.handler = hs.get_handlers().typing_notification_handler self.event_source = hs.get_event_sources().sources["typing"] 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.room_id = "a-room" # Mock the RoomMemberHandler hs.handlers.room_member_handler = Mock(spec=[]) 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([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 == self.room_id: return defer.succeed(self.room_members) else: return defer.succeed([]) self.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 hs.is_mine(member): 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 check_joined_room(room_id, user_id): if user_id not in [u.to_string() for u in self.room_members]: raise AuthError(401, "User is not in the room") 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") # Remote user self.u_onion = hs.parse_userid("@onion:farm")
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 = 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.handlers = JustTypingNotificationHandlers(hs) self.handler = hs.get_handlers().typing_notification_handler self.event_source = hs.get_event_sources().sources["typing"] 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.room_id = "a-room" # Mock the RoomMemberHandler hs.handlers.room_member_handler = Mock(spec=[]) 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([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 == self.room_id: return defer.succeed(self.room_members) else: return defer.succeed([]) self.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 hs.is_mine(member): 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 check_joined_room(room_id, user_id): if user_id not in [u.to_string() for u in self.room_members]: raise AuthError(401, "User is not in the room") 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") # Remote user self.u_onion = hs.parse_userid("@onion:farm")
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", ]), 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() def get_received_txn_response(*args): return defer.succeed(None) self.datastore.get_received_txn_response = get_received_txn_response 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")
def setUp(self): self.mock_config = NonCallableMock() self.mock_config.signing_key = [MockKey()] self.hostname = "red" hs = HomeServer( self.hostname, db_pool=None, ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), datastore=NonCallableMock(spec_set=[ "persist_event", "get_room_member", "get_room", "store_room", "get_latest_events_in_room", ]), resource_for_federation=NonCallableMock(), http_client=NonCallableMock(spec_set=[]), notifier=NonCallableMock(spec_set=["on_new_room_event"]), handlers=NonCallableMock(spec_set=[ "room_member_handler", "profile_handler", "federation_handler", ]), auth=NonCallableMock(spec_set=[ "check", "add_auth_events", "check_host_in_room", ]), state_handler=NonCallableMock(spec_set=[ "compute_event_context", "get_current_state", ]), config=self.mock_config, ) self.federation = NonCallableMock(spec_set=[ "handle_new_event", "send_invite", "get_state_for_room", ]) self.datastore = hs.get_datastore() self.handlers = hs.get_handlers() self.notifier = hs.get_notifier() self.state_handler = hs.get_state_handler() self.distributor = hs.get_distributor() self.auth = hs.get_auth() self.hs = hs self.handlers.federation_handler = self.federation self.distributor.declare("collect_presencelike_data") self.handlers.room_member_handler = RoomMemberHandler(self.hs) self.handlers.profile_handler = ProfileHandler(self.hs) self.room_member_handler = self.handlers.room_member_handler self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0)
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 = Mock() self.mock_config.signing_key = [MockKey()] hs = HomeServer("test", 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", ]), 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 = JustTypingNotificationHandlers(hs) self.mock_update_client = Mock() self.mock_update_client.return_value = defer.succeed(None) self.handler = hs.get_handlers().typing_notification_handler self.handler.push_update_to_clients = self.mock_update_client self.datastore = hs.get_datastore() def get_received_txn_response(*args): return defer.succeed(None) self.datastore.get_received_txn_response = get_received_txn_response self.room_id = "a-room" # Mock the RoomMemberHandler hs.handlers.room_member_handler = Mock(spec=[]) 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([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 == self.room_id: return defer.succeed(self.room_members) else: return defer.succeed([]) self.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) self.room_member_handler.fetch_room_distributions_into = ( fetch_room_distributions_into) # Some local users to test with self.u_apple = hs.parse_userid("@apple:test") self.u_banana = hs.parse_userid("@banana:test") # Remote user self.u_onion = hs.parse_userid("@onion:farm")
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) state_handler = Mock(spec=["handle_new_event"]) state_handler.handle_new_event.return_value = True persistence_service = Mock(spec=["get_latest_pdus_in_context"]) persistence_service.get_latest_pdus_in_context.return_value = [] hs = HomeServer( "red", db_pool=None, http_client=None, datastore=MemoryDataStore(), replication_layer=Mock(), state_handler=state_handler, persistence_service=persistence_service, ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), config=NonCallableMock(), ) self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0) hs.get_handlers().federation_handler = Mock() def _get_user_by_token(token=None): return { "user": hs.parse_userid(self.auth_user_id), "admin": False, "device_id": None, } hs.get_auth().get_user_by_token = _get_user_by_token self.auth_user_id = self.rmcreator_id synapse.rest.room.register_servlets(hs, self.mock_resource) self.auth = hs.get_auth() # create some rooms under the name rmcreator_id self.uncreated_rmid = "!aa:test" self.created_rmid = yield self.create_room_as(self.rmcreator_id, is_public=False) self.created_public_rmid = yield self.create_room_as(self.rmcreator_id, is_public=True) # send a message in one of the rooms self.created_rmid_msg_path = ("/rooms/%s/send/m.room.message/a1" % (self.created_rmid)) (code, response) = yield self.mock_resource.trigger( "PUT", self.created_rmid_msg_path, '{"msgtype":"m.text","body":"test msg"}') self.assertEquals(200, code, msg=str(response)) # set topic for public room (code, response) = yield self.mock_resource.trigger( "PUT", "/rooms/%s/state/m.room.topic" % self.created_public_rmid, '{"topic":"Public Room Topic"}') self.assertEquals(200, code, msg=str(response)) # auth as user_id now self.auth_user_id = self.user_id
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( "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) hs.get_handlers().federation_handler = Mock() def _get_user_by_token(token=None): return { "user": hs.parse_userid(self.auth_user_id), "admin": False, "device_id": None, } hs.get_auth().get_user_by_token = _get_user_by_token def _insert_client_ip(*args, **kwargs): return defer.succeed(None) hs.get_datastore().insert_client_ip = _insert_client_ip self.auth_user_id = self.rmcreator_id synapse.rest.room.register_servlets(hs, self.mock_resource) self.auth = hs.get_auth() # create some rooms under the name rmcreator_id self.uncreated_rmid = "!aa:test" self.created_rmid = yield self.create_room_as(self.rmcreator_id, is_public=False) self.created_public_rmid = yield self.create_room_as(self.rmcreator_id, is_public=True) # send a message in one of the rooms self.created_rmid_msg_path = ("/rooms/%s/send/m.room.message/a1" % (self.created_rmid)) (code, response) = yield self.mock_resource.trigger( "PUT", self.created_rmid_msg_path, '{"msgtype":"m.text","body":"test msg"}') self.assertEquals(200, code, msg=str(response)) # set topic for public room (code, response) = yield self.mock_resource.trigger( "PUT", "/rooms/%s/state/m.room.topic" % self.created_public_rmid, '{"topic":"Public Room Topic"}') self.assertEquals(200, code, msg=str(response)) # auth as user_id now self.auth_user_id = self.user_id
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", ]), 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() 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")
def setUp(self): self.mock_http_client = Mock(spec=[]) self.mock_http_client.put_json = DeferredMockCallable() self.mock_federation_resource = MockHttpResource() 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", ]), handlers=None, resource_for_client=Mock(), resource_for_federation=self.mock_federation_resource, http_client=self.mock_http_client, ) hs.handlers = JustPresenceHandlers(hs) self.datastore = hs.get_datastore() def get_received_txn_response(*args): return defer.succeed(None) self.datastore.get_received_txn_response = get_received_txn_response 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")
def setUp(self): self.clock = MockClock() self.mock_http_client = Mock(spec=[]) self.mock_http_client.put_json = DeferredMockCallable() self.mock_federation_resource = MockHttpResource() hs = HomeServer( "test", 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", ]), handlers=None, resource_for_client=Mock(), resource_for_federation=self.mock_federation_resource, http_client=self.mock_http_client, ) hs.handlers = JustTypingNotificationHandlers(hs) self.mock_update_client = Mock() self.mock_update_client.return_value = defer.succeed(None) self.handler = hs.get_handlers().typing_notification_handler self.handler.push_update_to_clients = self.mock_update_client self.datastore = hs.get_datastore() def get_received_txn_response(*args): return defer.succeed(None) self.datastore.get_received_txn_response = get_received_txn_response self.room_id = "a-room" # Mock the RoomMemberHandler hs.handlers.room_member_handler = Mock(spec=[]) 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([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 == self.room_id: return defer.succeed(self.room_members) else: return defer.succeed([]) self.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) self.room_member_handler.fetch_room_distributions_into = ( fetch_room_distributions_into) # Some local users to test with self.u_apple = hs.parse_userid("@apple:test") self.u_banana = hs.parse_userid("@banana:test") # Remote user self.u_onion = hs.parse_userid("@onion:farm")