diff --git a/tests/handlers/test_e2e_keys.py b/tests/handlers/test_e2e_keys.py
index e0a24824cc..39e7b1ab25 100644
--- a/tests/handlers/test_e2e_keys.py
+++ b/tests/handlers/test_e2e_keys.py
@@ -47,12 +47,16 @@ class E2eKeysHandlerTestCase(unittest.HomeserverTestCase):
"alg2:k3": {"key": "key3"},
}
+ # Note that "signed_curve25519" is always returned in key count responses. This is necessary until
+ # https://github.com/matrix-org/matrix-doc/issues/3298 is fixed.
res = self.get_success(
self.handler.upload_keys_for_user(
local_user, device_id, {"one_time_keys": keys}
)
)
- self.assertDictEqual(res, {"one_time_key_counts": {"alg1": 1, "alg2": 2}})
+ self.assertDictEqual(
+ res, {"one_time_key_counts": {"alg1": 1, "alg2": 2, "signed_curve25519": 0}}
+ )
# we should be able to change the signature without a problem
keys["alg2:k2"]["signatures"]["k1"] = "sig2"
@@ -61,7 +65,9 @@ class E2eKeysHandlerTestCase(unittest.HomeserverTestCase):
local_user, device_id, {"one_time_keys": keys}
)
)
- self.assertDictEqual(res, {"one_time_key_counts": {"alg1": 1, "alg2": 2}})
+ self.assertDictEqual(
+ res, {"one_time_key_counts": {"alg1": 1, "alg2": 2, "signed_curve25519": 0}}
+ )
def test_change_one_time_keys(self):
"""attempts to change one-time-keys should be rejected"""
@@ -79,7 +85,9 @@ class E2eKeysHandlerTestCase(unittest.HomeserverTestCase):
local_user, device_id, {"one_time_keys": keys}
)
)
- self.assertDictEqual(res, {"one_time_key_counts": {"alg1": 1, "alg2": 2}})
+ self.assertDictEqual(
+ res, {"one_time_key_counts": {"alg1": 1, "alg2": 2, "signed_curve25519": 0}}
+ )
# Error when changing string key
self.get_failure(
@@ -89,7 +97,7 @@ class E2eKeysHandlerTestCase(unittest.HomeserverTestCase):
SynapseError,
)
- # Error when replacing dict key with strin
+ # Error when replacing dict key with string
self.get_failure(
self.handler.upload_keys_for_user(
local_user, device_id, {"one_time_keys": {"alg2:k3": "key2"}}
@@ -131,7 +139,9 @@ class E2eKeysHandlerTestCase(unittest.HomeserverTestCase):
local_user, device_id, {"one_time_keys": keys}
)
)
- self.assertDictEqual(res, {"one_time_key_counts": {"alg1": 1}})
+ self.assertDictEqual(
+ res, {"one_time_key_counts": {"alg1": 1, "signed_curve25519": 0}}
+ )
res2 = self.get_success(
self.handler.claim_one_time_keys(
diff --git a/tests/handlers/test_profile.py b/tests/handlers/test_profile.py
index cdb41101b3..2928c4f48c 100644
--- a/tests/handlers/test_profile.py
+++ b/tests/handlers/test_profile.py
@@ -103,7 +103,7 @@ class ProfileTestCase(unittest.HomeserverTestCase):
)
self.assertIsNone(
- (self.get_success(self.store.get_profile_displayname(self.frank.localpart)))
+ self.get_success(self.store.get_profile_displayname(self.frank.localpart))
)
def test_set_my_name_if_disabled(self):
diff --git a/tests/handlers/test_space_summary.py b/tests/handlers/test_space_summary.py
index 9771d3fb3b..3f73ad7f94 100644
--- a/tests/handlers/test_space_summary.py
+++ b/tests/handlers/test_space_summary.py
@@ -14,8 +14,18 @@
from typing import Any, Iterable, Optional, Tuple
from unittest import mock
-from synapse.api.constants import EventContentFields, RoomTypes
+from synapse.api.constants import (
+ EventContentFields,
+ EventTypes,
+ HistoryVisibility,
+ JoinRules,
+ Membership,
+ RestrictedJoinRuleTypes,
+ RoomTypes,
+)
from synapse.api.errors import AuthError
+from synapse.api.room_versions import RoomVersions
+from synapse.events import make_event_from_dict
from synapse.handlers.space_summary import _child_events_comparison_key
from synapse.rest import admin
from synapse.rest.client.v1 import login, room
@@ -117,7 +127,7 @@ class SpaceSummaryTestCase(unittest.HomeserverTestCase):
"""Add a child room to a space."""
self.helper.send_state(
space_id,
- event_type="m.space.child",
+ event_type=EventTypes.SpaceChild,
body={"via": [self.hs.hostname]},
tok=token,
state_key=room_id,
@@ -155,26 +165,379 @@ class SpaceSummaryTestCase(unittest.HomeserverTestCase):
# The user cannot see the space.
self.get_failure(self.handler.get_space_summary(user2, self.space), AuthError)
- # Joining the room causes it to be visible.
- self.helper.join(self.space, user2, tok=token2)
+ # If the space is made world-readable it should return a result.
+ self.helper.send_state(
+ self.space,
+ event_type=EventTypes.RoomHistoryVisibility,
+ body={"history_visibility": HistoryVisibility.WORLD_READABLE},
+ tok=self.token,
+ )
result = self.get_success(self.handler.get_space_summary(user2, self.space))
-
- # The result should only have the space, but includes the link to the room.
- self._assert_rooms(result, [self.space])
+ self._assert_rooms(result, [self.space, self.room])
self._assert_events(result, [(self.space, self.room)])
- def test_world_readable(self):
- """A world-readable room is visible to everyone."""
+ # Make it not world-readable again and confirm it results in an error.
self.helper.send_state(
self.space,
- event_type="m.room.history_visibility",
- body={"history_visibility": "world_readable"},
+ event_type=EventTypes.RoomHistoryVisibility,
+ body={"history_visibility": HistoryVisibility.JOINED},
+ tok=self.token,
+ )
+ self.get_failure(self.handler.get_space_summary(user2, self.space), AuthError)
+
+ # Join the space and results should be returned.
+ self.helper.join(self.space, user2, tok=token2)
+ result = self.get_success(self.handler.get_space_summary(user2, self.space))
+ self._assert_rooms(result, [self.space, self.room])
+ self._assert_events(result, [(self.space, self.room)])
+
+ def _create_room_with_join_rule(
+ self, join_rule: str, room_version: Optional[str] = None, **extra_content
+ ) -> str:
+ """Create a room with the given join rule and add it to the space."""
+ room_id = self.helper.create_room_as(
+ self.user,
+ room_version=room_version,
tok=self.token,
+ extra_content={
+ "initial_state": [
+ {
+ "type": EventTypes.JoinRules,
+ "state_key": "",
+ "content": {
+ "join_rule": join_rule,
+ **extra_content,
+ },
+ }
+ ]
+ },
)
+ self._add_child(self.space, room_id, self.token)
+ return room_id
+ def test_filtering(self):
+ """
+ Rooms should be properly filtered to only include rooms the user has access to.
+ """
user2 = self.register_user("user2", "pass")
+ token2 = self.login("user2", "pass")
- # The space should be visible, as well as the link to the room.
+ # Create a few rooms which will have different properties.
+ public_room = self._create_room_with_join_rule(JoinRules.PUBLIC)
+ knock_room = self._create_room_with_join_rule(
+ JoinRules.KNOCK, room_version=RoomVersions.V7.identifier
+ )
+ not_invited_room = self._create_room_with_join_rule(JoinRules.INVITE)
+ invited_room = self._create_room_with_join_rule(JoinRules.INVITE)
+ self.helper.invite(invited_room, targ=user2, tok=self.token)
+ restricted_room = self._create_room_with_join_rule(
+ JoinRules.MSC3083_RESTRICTED,
+ room_version=RoomVersions.MSC3083.identifier,
+ allow=[],
+ )
+ restricted_accessible_room = self._create_room_with_join_rule(
+ JoinRules.MSC3083_RESTRICTED,
+ room_version=RoomVersions.MSC3083.identifier,
+ allow=[
+ {
+ "type": RestrictedJoinRuleTypes.ROOM_MEMBERSHIP,
+ "room_id": self.space,
+ "via": [self.hs.hostname],
+ }
+ ],
+ )
+ world_readable_room = self._create_room_with_join_rule(JoinRules.INVITE)
+ self.helper.send_state(
+ world_readable_room,
+ event_type=EventTypes.RoomHistoryVisibility,
+ body={"history_visibility": HistoryVisibility.WORLD_READABLE},
+ tok=self.token,
+ )
+ joined_room = self._create_room_with_join_rule(JoinRules.INVITE)
+ self.helper.invite(joined_room, targ=user2, tok=self.token)
+ self.helper.join(joined_room, user2, tok=token2)
+
+ # Join the space.
+ self.helper.join(self.space, user2, tok=token2)
result = self.get_success(self.handler.get_space_summary(user2, self.space))
- self._assert_rooms(result, [self.space])
- self._assert_events(result, [(self.space, self.room)])
+
+ self._assert_rooms(
+ result,
+ [
+ self.space,
+ self.room,
+ public_room,
+ knock_room,
+ invited_room,
+ restricted_accessible_room,
+ world_readable_room,
+ joined_room,
+ ],
+ )
+ self._assert_events(
+ result,
+ [
+ (self.space, self.room),
+ (self.space, public_room),
+ (self.space, knock_room),
+ (self.space, not_invited_room),
+ (self.space, invited_room),
+ (self.space, restricted_room),
+ (self.space, restricted_accessible_room),
+ (self.space, world_readable_room),
+ (self.space, joined_room),
+ ],
+ )
+
+ def test_complex_space(self):
+ """
+ Create a "complex" space to see how it handles things like loops and subspaces.
+ """
+ # Create an inaccessible room.
+ user2 = self.register_user("user2", "pass")
+ token2 = self.login("user2", "pass")
+ room2 = self.helper.create_room_as(user2, is_public=False, tok=token2)
+ # This is a bit odd as "user" is adding a room they don't know about, but
+ # it works for the tests.
+ self._add_child(self.space, room2, self.token)
+
+ # Create a subspace under the space with an additional room in it.
+ subspace = self.helper.create_room_as(
+ self.user,
+ tok=self.token,
+ extra_content={
+ "creation_content": {EventContentFields.ROOM_TYPE: RoomTypes.SPACE}
+ },
+ )
+ subroom = self.helper.create_room_as(self.user, tok=self.token)
+ self._add_child(self.space, subspace, token=self.token)
+ self._add_child(subspace, subroom, token=self.token)
+ # Also add the two rooms from the space into this subspace (causing loops).
+ self._add_child(subspace, self.room, token=self.token)
+ self._add_child(subspace, room2, self.token)
+
+ result = self.get_success(self.handler.get_space_summary(self.user, self.space))
+
+ # The result should include each room a single time and each link.
+ self._assert_rooms(result, [self.space, self.room, subspace, subroom])
+ self._assert_events(
+ result,
+ [
+ (self.space, self.room),
+ (self.space, room2),
+ (self.space, subspace),
+ (subspace, subroom),
+ (subspace, self.room),
+ (subspace, room2),
+ ],
+ )
+
+ def test_fed_complex(self):
+ """
+ Return data over federation and ensure that it is handled properly.
+ """
+ fed_hostname = self.hs.hostname + "2"
+ subspace = "#subspace:" + fed_hostname
+ subroom = "#subroom:" + fed_hostname
+
+ async def summarize_remote_room(
+ _self, room, suggested_only, max_children, exclude_rooms
+ ):
+ # Return some good data, and some bad data:
+ #
+ # * Event *back* to the root room.
+ # * Unrelated events / rooms
+ # * Multiple levels of events (in a not-useful order, e.g. grandchild
+ # events before child events).
+
+ # Note that these entries are brief, but should contain enough info.
+ rooms = [
+ {
+ "room_id": subspace,
+ "world_readable": True,
+ "room_type": RoomTypes.SPACE,
+ },
+ {
+ "room_id": subroom,
+ "world_readable": True,
+ },
+ ]
+ event_content = {"via": [fed_hostname]}
+ events = [
+ {
+ "room_id": subspace,
+ "state_key": subroom,
+ "content": event_content,
+ },
+ ]
+ return rooms, events
+
+ # Add a room to the space which is on another server.
+ self._add_child(self.space, subspace, self.token)
+
+ with mock.patch(
+ "synapse.handlers.space_summary.SpaceSummaryHandler._summarize_remote_room",
+ new=summarize_remote_room,
+ ):
+ result = self.get_success(
+ self.handler.get_space_summary(self.user, self.space)
+ )
+
+ self._assert_rooms(result, [self.space, self.room, subspace, subroom])
+ self._assert_events(
+ result,
+ [
+ (self.space, self.room),
+ (self.space, subspace),
+ (subspace, subroom),
+ ],
+ )
+
+ def test_fed_filtering(self):
+ """
+ Rooms returned over federation should be properly filtered to only include
+ rooms the user has access to.
+ """
+ fed_hostname = self.hs.hostname + "2"
+ subspace = "#subspace:" + fed_hostname
+
+ # Create a few rooms which will have different properties.
+ public_room = "#public:" + fed_hostname
+ knock_room = "#knock:" + fed_hostname
+ not_invited_room = "#not_invited:" + fed_hostname
+ invited_room = "#invited:" + fed_hostname
+ restricted_room = "#restricted:" + fed_hostname
+ restricted_accessible_room = "#restricted_accessible:" + fed_hostname
+ world_readable_room = "#world_readable:" + fed_hostname
+ joined_room = self.helper.create_room_as(self.user, tok=self.token)
+
+ # Poke an invite over federation into the database.
+ fed_handler = self.hs.get_federation_handler()
+ event = make_event_from_dict(
+ {
+ "room_id": invited_room,
+ "event_id": "!abcd:" + fed_hostname,
+ "type": EventTypes.Member,
+ "sender": "@remote:" + fed_hostname,
+ "state_key": self.user,
+ "content": {"membership": Membership.INVITE},
+ "prev_events": [],
+ "auth_events": [],
+ "depth": 1,
+ "origin_server_ts": 1234,
+ }
+ )
+ self.get_success(
+ fed_handler.on_invite_request(fed_hostname, event, RoomVersions.V6)
+ )
+
+ async def summarize_remote_room(
+ _self, room, suggested_only, max_children, exclude_rooms
+ ):
+ # Note that these entries are brief, but should contain enough info.
+ rooms = [
+ {
+ "room_id": public_room,
+ "world_readable": False,
+ "join_rules": JoinRules.PUBLIC,
+ },
+ {
+ "room_id": knock_room,
+ "world_readable": False,
+ "join_rules": JoinRules.KNOCK,
+ },
+ {
+ "room_id": not_invited_room,
+ "world_readable": False,
+ "join_rules": JoinRules.INVITE,
+ },
+ {
+ "room_id": invited_room,
+ "world_readable": False,
+ "join_rules": JoinRules.INVITE,
+ },
+ {
+ "room_id": restricted_room,
+ "world_readable": False,
+ "join_rules": JoinRules.MSC3083_RESTRICTED,
+ "allowed_spaces": [],
+ },
+ {
+ "room_id": restricted_accessible_room,
+ "world_readable": False,
+ "join_rules": JoinRules.MSC3083_RESTRICTED,
+ "allowed_spaces": [self.room],
+ },
+ {
+ "room_id": world_readable_room,
+ "world_readable": True,
+ "join_rules": JoinRules.INVITE,
+ },
+ {
+ "room_id": joined_room,
+ "world_readable": False,
+ "join_rules": JoinRules.INVITE,
+ },
+ ]
+
+ # Place each room in the sub-space.
+ event_content = {"via": [fed_hostname]}
+ events = [
+ {
+ "room_id": subspace,
+ "state_key": room["room_id"],
+ "content": event_content,
+ }
+ for room in rooms
+ ]
+
+ # Also include the subspace.
+ rooms.insert(
+ 0,
+ {
+ "room_id": subspace,
+ "world_readable": True,
+ },
+ )
+ return rooms, events
+
+ # Add a room to the space which is on another server.
+ self._add_child(self.space, subspace, self.token)
+
+ with mock.patch(
+ "synapse.handlers.space_summary.SpaceSummaryHandler._summarize_remote_room",
+ new=summarize_remote_room,
+ ):
+ result = self.get_success(
+ self.handler.get_space_summary(self.user, self.space)
+ )
+
+ self._assert_rooms(
+ result,
+ [
+ self.space,
+ self.room,
+ subspace,
+ public_room,
+ knock_room,
+ invited_room,
+ restricted_accessible_room,
+ world_readable_room,
+ joined_room,
+ ],
+ )
+ self._assert_events(
+ result,
+ [
+ (self.space, self.room),
+ (self.space, subspace),
+ (subspace, public_room),
+ (subspace, knock_room),
+ (subspace, not_invited_room),
+ (subspace, invited_room),
+ (subspace, restricted_room),
+ (subspace, restricted_accessible_room),
+ (subspace, world_readable_room),
+ (subspace, joined_room),
+ ],
+ )
diff --git a/tests/handlers/test_stats.py b/tests/handlers/test_stats.py
index c9d4fd9336..e4059acda3 100644
--- a/tests/handlers/test_stats.py
+++ b/tests/handlers/test_stats.py
@@ -88,16 +88,12 @@ class StatsRoomTests(unittest.HomeserverTestCase):
def _get_current_stats(self, stats_type, stat_id):
table, id_col = stats.TYPE_TO_TABLE[stats_type]
- cols = list(stats.ABSOLUTE_STATS_FIELDS[stats_type]) + list(
- stats.PER_SLICE_FIELDS[stats_type]
- )
-
- end_ts = self.store.quantise_stats_time(self.reactor.seconds() * 1000)
+ cols = list(stats.ABSOLUTE_STATS_FIELDS[stats_type])
return self.get_success(
self.store.db_pool.simple_select_one(
- table + "_historical",
- {id_col: stat_id, end_ts: end_ts},
+ table + "_current",
+ {id_col: stat_id},
cols,
allow_none=True,
)
@@ -156,115 +152,6 @@ class StatsRoomTests(unittest.HomeserverTestCase):
self.assertEqual(len(r), 1)
self.assertEqual(r[0]["topic"], "foo")
- def test_initial_earliest_token(self):
- """
- Ingestion via notify_new_event will ignore tokens that the background
- update have already processed.
- """
-
- self.reactor.advance(86401)
-
- self.hs.config.stats_enabled = False
- self.handler.stats_enabled = False
-
- u1 = self.register_user("u1", "pass")
- u1_token = self.login("u1", "pass")
-
- u2 = self.register_user("u2", "pass")
- u2_token = self.login("u2", "pass")
-
- u3 = self.register_user("u3", "pass")
- u3_token = self.login("u3", "pass")
-
- room_1 = self.helper.create_room_as(u1, tok=u1_token)
- self.helper.send_state(
- room_1, event_type="m.room.topic", body={"topic": "foo"}, tok=u1_token
- )
-
- # Begin the ingestion by creating the temp tables. This will also store
- # the position that the deltas should begin at, once they take over.
- self.hs.config.stats_enabled = True
- self.handler.stats_enabled = True
- self.store.db_pool.updates._all_done = False
- self.get_success(
- self.store.db_pool.simple_update_one(
- table="stats_incremental_position",
- keyvalues={},
- updatevalues={"stream_id": 0},
- )
- )
-
- self.get_success(
- self.store.db_pool.simple_insert(
- "background_updates",
- {"update_name": "populate_stats_prepare", "progress_json": "{}"},
- )
- )
-
- while not self.get_success(
- self.store.db_pool.updates.has_completed_background_updates()
- ):
- self.get_success(
- self.store.db_pool.updates.do_next_background_update(100), by=0.1
- )
-
- # Now, before the table is actually ingested, add some more events.
- self.helper.invite(room=room_1, src=u1, targ=u2, tok=u1_token)
- self.helper.join(room=room_1, user=u2, tok=u2_token)
-
- # orig_delta_processor = self.store.
-
- # Now do the initial ingestion.
- self.get_success(
- self.store.db_pool.simple_insert(
- "background_updates",
- {"update_name": "populate_stats_process_rooms", "progress_json": "{}"},
- )
- )
- self.get_success(
- self.store.db_pool.simple_insert(
- "background_updates",
- {
- "update_name": "populate_stats_cleanup",
- "progress_json": "{}",
- "depends_on": "populate_stats_process_rooms",
- },
- )
- )
-
- self.store.db_pool.updates._all_done = False
- while not self.get_success(
- self.store.db_pool.updates.has_completed_background_updates()
- ):
- self.get_success(
- self.store.db_pool.updates.do_next_background_update(100), by=0.1
- )
-
- self.reactor.advance(86401)
-
- # Now add some more events, triggering ingestion. Because of the stream
- # position being set to before the events sent in the middle, a simpler
- # implementation would reprocess those events, and say there were four
- # users, not three.
- self.helper.invite(room=room_1, src=u1, targ=u3, tok=u1_token)
- self.helper.join(room=room_1, user=u3, tok=u3_token)
-
- # self.handler.notify_new_event()
-
- # We need to let the delta processor advance…
- self.reactor.advance(10 * 60)
-
- # Get the slices! There should be two -- day 1, and day 2.
- r = self.get_success(self.store.get_statistics_for_subject("room", room_1, 0))
-
- self.assertEqual(len(r), 2)
-
- # The oldest has 2 joined members
- self.assertEqual(r[-1]["joined_members"], 2)
-
- # The newest has 3
- self.assertEqual(r[0]["joined_members"], 3)
-
def test_create_user(self):
"""
When we create a user, it should have statistics already ready.
@@ -296,22 +183,6 @@ class StatsRoomTests(unittest.HomeserverTestCase):
self.assertIsNotNone(r1stats)
self.assertIsNotNone(r2stats)
- # contains the default things you'd expect in a fresh room
- self.assertEqual(
- r1stats["total_events"],
- EXPT_NUM_STATE_EVTS_IN_FRESH_PUBLIC_ROOM,
- "Wrong number of total_events in new room's stats!"
- " You may need to update this if more state events are added to"
- " the room creation process.",
- )
- self.assertEqual(
- r2stats["total_events"],
- EXPT_NUM_STATE_EVTS_IN_FRESH_PRIVATE_ROOM,
- "Wrong number of total_events in new room's stats!"
- " You may need to update this if more state events are added to"
- " the room creation process.",
- )
-
self.assertEqual(
r1stats["current_state_events"], EXPT_NUM_STATE_EVTS_IN_FRESH_PUBLIC_ROOM
)
@@ -327,24 +198,6 @@ class StatsRoomTests(unittest.HomeserverTestCase):
self.assertEqual(r2stats["invited_members"], 0)
self.assertEqual(r2stats["banned_members"], 0)
- def test_send_message_increments_total_events(self):
- """
- When we send a message, it increments total_events.
- """
-
- self._perform_background_initial_update()
-
- u1 = self.register_user("u1", "pass")
- u1token = self.login("u1", "pass")
- r1 = self.helper.create_room_as(u1, tok=u1token)
- r1stats_ante = self._get_current_stats("room", r1)
-
- self.helper.send(r1, "hiss", tok=u1token)
-
- r1stats_post = self._get_current_stats("room", r1)
-
- self.assertEqual(r1stats_post["total_events"] - r1stats_ante["total_events"], 1)
-
def test_updating_profile_information_does_not_increase_joined_members_count(self):
"""
Check that the joined_members count does not increase when a user changes their
@@ -378,7 +231,7 @@ class StatsRoomTests(unittest.HomeserverTestCase):
def test_send_state_event_nonoverwriting(self):
"""
- When we send a non-overwriting state event, it increments total_events AND current_state_events
+ When we send a non-overwriting state event, it increments current_state_events
"""
self._perform_background_initial_update()
@@ -399,44 +252,14 @@ class StatsRoomTests(unittest.HomeserverTestCase):
r1stats_post = self._get_current_stats("room", r1)
- self.assertEqual(r1stats_post["total_events"] - r1stats_ante["total_events"], 1)
self.assertEqual(
r1stats_post["current_state_events"] - r1stats_ante["current_state_events"],
1,
)
- def test_send_state_event_overwriting(self):
- """
- When we send an overwriting state event, it increments total_events ONLY
- """
-
- self._perform_background_initial_update()
-
- u1 = self.register_user("u1", "pass")
- u1token = self.login("u1", "pass")
- r1 = self.helper.create_room_as(u1, tok=u1token)
-
- self.helper.send_state(
- r1, "cat.hissing", {"value": True}, tok=u1token, state_key="tabby"
- )
-
- r1stats_ante = self._get_current_stats("room", r1)
-
- self.helper.send_state(
- r1, "cat.hissing", {"value": False}, tok=u1token, state_key="tabby"
- )
-
- r1stats_post = self._get_current_stats("room", r1)
-
- self.assertEqual(r1stats_post["total_events"] - r1stats_ante["total_events"], 1)
- self.assertEqual(
- r1stats_post["current_state_events"] - r1stats_ante["current_state_events"],
- 0,
- )
-
def test_join_first_time(self):
"""
- When a user joins a room for the first time, total_events, current_state_events and
+ When a user joins a room for the first time, current_state_events and
joined_members should increase by exactly 1.
"""
@@ -455,7 +278,6 @@ class StatsRoomTests(unittest.HomeserverTestCase):
r1stats_post = self._get_current_stats("room", r1)
- self.assertEqual(r1stats_post["total_events"] - r1stats_ante["total_events"], 1)
self.assertEqual(
r1stats_post["current_state_events"] - r1stats_ante["current_state_events"],
1,
@@ -466,7 +288,7 @@ class StatsRoomTests(unittest.HomeserverTestCase):
def test_join_after_leave(self):
"""
- When a user joins a room after being previously left, total_events and
+ When a user joins a room after being previously left,
joined_members should increase by exactly 1.
current_state_events should not increase.
left_members should decrease by exactly 1.
@@ -490,7 +312,6 @@ class StatsRoomTests(unittest.HomeserverTestCase):
r1stats_post = self._get_current_stats("room", r1)
- self.assertEqual(r1stats_post["total_events"] - r1stats_ante["total_events"], 1)
self.assertEqual(
r1stats_post["current_state_events"] - r1stats_ante["current_state_events"],
0,
@@ -504,7 +325,7 @@ class StatsRoomTests(unittest.HomeserverTestCase):
def test_invited(self):
"""
- When a user invites another user, current_state_events, total_events and
+ When a user invites another user, current_state_events and
invited_members should increase by exactly 1.
"""
@@ -522,7 +343,6 @@ class StatsRoomTests(unittest.HomeserverTestCase):
r1stats_post = self._get_current_stats("room", r1)
- self.assertEqual(r1stats_post["total_events"] - r1stats_ante["total_events"], 1)
self.assertEqual(
r1stats_post["current_state_events"] - r1stats_ante["current_state_events"],
1,
@@ -533,7 +353,7 @@ class StatsRoomTests(unittest.HomeserverTestCase):
def test_join_after_invite(self):
"""
- When a user joins a room after being invited, total_events and
+ When a user joins a room after being invited and
joined_members should increase by exactly 1.
current_state_events should not increase.
invited_members should decrease by exactly 1.
@@ -556,7 +376,6 @@ class StatsRoomTests(unittest.HomeserverTestCase):
r1stats_post = self._get_current_stats("room", r1)
- self.assertEqual(r1stats_post["total_events"] - r1stats_ante["total_events"], 1)
self.assertEqual(
r1stats_post["current_state_events"] - r1stats_ante["current_state_events"],
0,
@@ -570,7 +389,7 @@ class StatsRoomTests(unittest.HomeserverTestCase):
def test_left(self):
"""
- When a user leaves a room after joining, total_events and
+ When a user leaves a room after joining and
left_members should increase by exactly 1.
current_state_events should not increase.
joined_members should decrease by exactly 1.
@@ -593,7 +412,6 @@ class StatsRoomTests(unittest.HomeserverTestCase):
r1stats_post = self._get_current_stats("room", r1)
- self.assertEqual(r1stats_post["total_events"] - r1stats_ante["total_events"], 1)
self.assertEqual(
r1stats_post["current_state_events"] - r1stats_ante["current_state_events"],
0,
@@ -607,7 +425,7 @@ class StatsRoomTests(unittest.HomeserverTestCase):
def test_banned(self):
"""
- When a user is banned from a room after joining, total_events and
+ When a user is banned from a room after joining and
left_members should increase by exactly 1.
current_state_events should not increase.
banned_members should decrease by exactly 1.
@@ -630,7 +448,6 @@ class StatsRoomTests(unittest.HomeserverTestCase):
r1stats_post = self._get_current_stats("room", r1)
- self.assertEqual(r1stats_post["total_events"] - r1stats_ante["total_events"], 1)
self.assertEqual(
r1stats_post["current_state_events"] - r1stats_ante["current_state_events"],
0,
diff --git a/tests/handlers/test_typing.py b/tests/handlers/test_typing.py
index f58afbc244..fa3cff598e 100644
--- a/tests/handlers/test_typing.py
+++ b/tests/handlers/test_typing.py
@@ -38,6 +38,9 @@ U_ONION = UserID.from_string("@onion:farm")
# Test room id
ROOM_ID = "a-room"
+# Room we're not in
+OTHER_ROOM_ID = "another-room"
+
def _expect_edu_transaction(edu_type, content, origin="test"):
return {
@@ -115,6 +118,11 @@ class TypingNotificationsTestCase(unittest.HomeserverTestCase):
hs.get_auth().check_user_in_room = check_user_in_room
+ async def check_host_in_room(room_id, server_name):
+ return room_id == ROOM_ID
+
+ hs.get_event_auth_handler().check_host_in_room = check_host_in_room
+
def get_joined_hosts_for_room(room_id):
return {member.domain for member in self.room_members}
@@ -244,6 +252,35 @@ class TypingNotificationsTestCase(unittest.HomeserverTestCase):
],
)
+ def test_started_typing_remote_recv_not_in_room(self):
+ self.room_members = [U_APPLE, U_ONION]
+
+ self.assertEquals(self.event_source.get_current_key(), 0)
+
+ channel = self.make_request(
+ "PUT",
+ "/_matrix/federation/v1/send/1000000",
+ _make_edu_transaction_json(
+ "m.typing",
+ content={
+ "room_id": OTHER_ROOM_ID,
+ "user_id": U_ONION.to_string(),
+ "typing": True,
+ },
+ ),
+ federation_auth_origin=b"farm",
+ )
+ self.assertEqual(channel.code, 200)
+
+ self.on_new_event.assert_not_called()
+
+ self.assertEquals(self.event_source.get_current_key(), 0)
+ events = self.get_success(
+ self.event_source.get_new_events(room_ids=[OTHER_ROOM_ID], from_key=0)
+ )
+ self.assertEquals(events[0], [])
+ self.assertEquals(events[1], 0)
+
@override_config({"send_federation": True})
def test_stopped_typing(self):
self.room_members = [U_APPLE, U_BANANA, U_ONION]
|
