dandri/synapse
1
0
Fork 0
mirror of https://github.com/element-hq/synapse.git synced 2026-08-28 17:58:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove some failing tests of items scoped out and documented in https://github.com/element-hq/synapse/issues/19981

Browse Source
This commit is contained in:
Jason Robinson
2026-07-21 18:48:31 +03:00
parent aaf502a242
commit 09501cf701
3 changed files with 6 additions and 257 deletions
Download Patch File Download Diff File Expand all files Collapse all files
synapse/storage/databases/main/events.py
+6
View File
@@ -2147,6 +2147,12 @@ class PersistEventsStore:
if profile_update_additions:
# Write the profile updates for additions to the room, from either
# a join, knock, invite, etc.
# FIXME this will add rows also when a display name changes due to
# the facts that `sliding_sync_table_changes` contains a JOIN
# membership event in that case. We should aim to filter these
# unnecessary rows out, as we're also generating an UPDATE profile
# update action row for the actual display name change itself.
# See https://github.com/element-hq/synapse/issues/19981
self.store.record_profile_updates_for_user_joined_room_txn(
txn=txn,
room_id=room_id,
tests/handlers/test_profile.py
-74
View File
@@ -670,80 +670,6 @@ class ProfileTestCase(unittest.HomeserverTestCase):
],
)
@override_config({"include_profile_updates_in_sync": True})
def test_display_name_change_does_not_generate_join_action_rows_for_profile_updates(
self,
) -> None:
"""Test that changing ones display name doesn't generate "joined_room"
profile updates to the stream, due to room state membership event changes,
if MSC4429 is enabled.
"""
self.register_user("roger", "password")
roger_token = self.login("roger", "password")
room_id = self.helper.create_room_as(
room_creator=self.frank.to_string(),
tok=self.frank_token,
)
self.helper.join(room_id, "@roger:test", tok=roger_token)
per_user_updates = self.get_success(
self.store.get_profile_updates_for_user_and_fields(
from_id=0,
to_id=10,
user_id=self.frank.to_string(),
field_names={"displayname"},
)
)
# Starting situation
self.assertEqual(
per_user_updates,
[
ProfileUpdate(
stream_id=2,
user_id="@roger:test",
action="joined_room",
field_name=None,
),
],
)
# Change rogers display name
self.get_success(
self.handler.set_field(
target_user=UserID.from_string("@roger:test"),
requester=synapse.types.create_requester("@roger:test"),
field_name="displayname",
new_value="Roger new name",
)
)
per_user_updates = self.get_success(
self.store.get_profile_updates_for_user_and_fields(
from_id=0,
to_id=10,
user_id=self.frank.to_string(),
field_names={"displayname"},
)
)
# Only the displayname change should appear, no extra "room join" due to
# membership state event changes.
self.assertEqual(
per_user_updates,
[
ProfileUpdate(
stream_id=2,
user_id="@roger:test",
action="joined_room",
field_name=None,
),
ProfileUpdate(
stream_id=3,
user_id="@roger:test",
action="update",
field_name="displayname",
),
],
)
@parameterized.expand(
[
["displayname", "Frank"],
tests/handlers/test_sync.py
-183
View File
@@ -2423,189 +2423,6 @@ class SyncProfileUpdatesTestCase(tests.unittest.HomeserverTestCase):
incremental_result.profile_updates["@third_user:test"],
)
@parameterized.expand([[True, False], [True, True], [False, False], [False, True]])
@override_config({"include_profile_updates_in_sync": True})
def test_incremental_sync_join_leave_join_leave_includes_room_members(
self,
eager_sync: bool,
is_lazy: bool,
) -> None:
"""Test that with MSC4429 enabled the incremental sync response
correctly handles multiple join / leave / join / leave in a row.
In the first variant we sync and check after each iteration of join/leave.
In the second variant we only sync at the end of all the join/leaves.
We do both of these as lazy and not-lazy variants.
This test checks that as a syncing user we get the current members of the room,
or at least the expected count when being lazy.
"""
third_user = self.register_user("third_user", "password")
third_tok = self.login("third_user", "password")
self.helper.join(self.joined_room, third_user, tok=third_tok)
syncing_user = self.register_user("syncing_user", "password")
syncing_tok = self.login("syncing_user", "password")
filter_json: dict[str, dict] = {
"org.matrix.msc4429.profile_fields": {"ids": ["displayname", "avatar_url"]}
}
if is_lazy:
filter_json["room"] = {
"state": {
"lazy_load_members": True,
},
}
requester = create_requester(syncing_user)
initial_result = self.get_success(
self.sync_handler.wait_for_sync_for_user(
requester,
sync_config=generate_sync_config(
user_id=syncing_user,
filter_collection=FilterCollection(
hs=self.hs,
filter_json=filter_json,
),
),
request_key=generate_request_key(),
)
)
# Join the room
self.helper.join(
room=self.joined_room,
user=syncing_user,
tok=syncing_tok,
)
next_token = initial_result.next_batch
if eager_sync:
incremental_result = self.get_success(
self.sync_handler.wait_for_sync_for_user(
requester,
since_token=next_token,
sync_config=generate_sync_config(
user_id=syncing_user,
filter_collection=FilterCollection(
hs=self.hs,
filter_json=filter_json,
),
),
request_key=generate_request_key(),
)
)
# We expect there to be the users profiles
self.assertIsNotNone(
incremental_result.profile_updates["@user:test"],
)
self.assertIsNotNone(
incremental_result.profile_updates["@other_user:test"],
)
self.assertIsNotNone(
incremental_result.profile_updates["@third_user:test"],
)
next_token = incremental_result.next_batch
# Leave the room
self.helper.leave(
room=self.joined_room,
user=syncing_user,
tok=syncing_tok,
)
if eager_sync:
# Ensure we don't get caught by the cache
self.reactor.advance((LAZY_LOADED_PROFILE_FIELDS_CACHE_MAX_AGE / 1000) + 1)
incremental_result = self.get_success(
self.sync_handler.wait_for_sync_for_user(
requester,
since_token=next_token,
sync_config=generate_sync_config(
user_id=syncing_user,
filter_collection=FilterCollection(
hs=self.hs,
filter_json=filter_json,
),
),
request_key=generate_request_key(),
)
)
# We expect there to be no changes, the server doesn't send us
# null profiles when we leave the room
self.assertIsNone(
incremental_result.profile_updates.get("@user:test"),
)
self.assertIsNone(
incremental_result.profile_updates.get("@other_user:test"),
)
self.assertIsNone(
incremental_result.profile_updates.get("@third_user:test"),
)
next_token = incremental_result.next_batch
# Join the room
self.helper.join(
room=self.joined_room,
user=syncing_user,
tok=syncing_tok,
)
if eager_sync:
# Ensure we don't get caught by the cache
self.reactor.advance((LAZY_LOADED_PROFILE_FIELDS_CACHE_MAX_AGE / 1000) + 1)
incremental_result = self.get_success(
self.sync_handler.wait_for_sync_for_user(
requester,
since_token=next_token,
sync_config=generate_sync_config(
user_id=syncing_user,
filter_collection=FilterCollection(
hs=self.hs,
filter_json=filter_json,
),
),
request_key=generate_request_key(),
)
)
# We expect there to be the users profiles
self.assertIsNotNone(
incremental_result.profile_updates["@user:test"],
)
self.assertIsNotNone(
incremental_result.profile_updates["@other_user:test"],
)
self.assertIsNotNone(
incremental_result.profile_updates["@third_user:test"],
)
next_token = incremental_result.next_batch
# Leave the room
self.helper.leave(
room=self.joined_room,
user=syncing_user,
tok=syncing_tok,
)
# Ensure we don't get caught by the cache
self.reactor.advance((LAZY_LOADED_PROFILE_FIELDS_CACHE_MAX_AGE / 1000) + 1)
incremental_result = self.get_success(
self.sync_handler.wait_for_sync_for_user(
requester,
since_token=next_token,
sync_config=generate_sync_config(
user_id=syncing_user,
filter_collection=FilterCollection(
hs=self.hs,
filter_json=filter_json,
),
),
request_key=generate_request_key(),
)
)
# We expect there to be no changes, the server doesn't send us
# null profiles when we leave the room
self.assertIsNone(
incremental_result.profile_updates.get("@user:test"),
)
self.assertIsNone(
incremental_result.profile_updates.get("@other_user:test"),
)
self.assertIsNone(
incremental_result.profile_updates.get("@third_user:test"),
)
@parameterized.expand(
[
["string value", "new string value"],