# Copyright 2020 The Matrix.org Foundation C.I.C. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from typing import Dict, List, Optional, Set, Union, cast import frozendict from twisted.test.proto_helpers import MemoryReactor import synapse.rest.admin from synapse.api.constants import EventTypes, HistoryVisibility, Membership from synapse.api.room_versions import RoomVersions from synapse.appservice import ApplicationService from synapse.events import FrozenEvent from synapse.push.bulk_push_rule_evaluator import _flatten_dict from synapse.push.httppusher import tweaks_for_actions from synapse.rest import admin from synapse.rest.client import login, register, room from synapse.server import HomeServer from synapse.storage.databases.main.appservice import _make_exclusive_regex from synapse.synapse_rust.push import PushRuleEvaluator from synapse.types import JsonDict, JsonMapping, UserID from synapse.util import Clock from tests import unittest from tests.test_utils.event_injection import create_event, inject_member_event class PushRuleEvaluatorTestCase(unittest.TestCase): def _get_evaluator( self, content: JsonMapping, *, user_mentions: Optional[Set[str]] = None, room_mention: bool = False, related_events: Optional[JsonDict] = None, ) -> PushRuleEvaluator: event = FrozenEvent( { "event_id": "$event_id", "type": "m.room.history_visibility", "sender": "@user:test", "state_key": "", "room_id": "#room:test", "content": content, }, RoomVersions.V1, ) room_member_count = 0 sender_power_level = 0 power_levels: Dict[str, Union[int, Dict[str, int]]] = {} return PushRuleEvaluator( _flatten_dict(event), user_mentions or set(), room_mention, room_member_count, sender_power_level, cast(Dict[str, int], power_levels.get("notifications", {})), {} if related_events is None else related_events, related_event_match_enabled=True, room_version_feature_flags=event.room_version.msc3931_push_features, msc3931_enabled=True, ) def test_display_name(self) -> None: """Check for a matching display name in the body of the event.""" evaluator = self._get_evaluator({"body": "foo bar baz"}) condition = {"kind": "contains_display_name"} # Blank names are skipped. self.assertFalse(evaluator.matches(condition, "@user:test", "")) # Check a display name that doesn't match. self.assertFalse(evaluator.matches(condition, "@user:test", "not found")) # Check a display name which matches. self.assertTrue(evaluator.matches(condition, "@user:test", "foo")) # A display name that matches, but not a full word does not result in a match. self.assertFalse(evaluator.matches(condition, "@user:test", "ba")) # A display name should not be interpreted as a regular expression. self.assertFalse(evaluator.matches(condition, "@user:test", "ba[rz]")) # A display name with spaces should work fine. self.assertTrue(evaluator.matches(condition, "@user:test", "foo bar")) def test_user_mentions(self) -> None: """Check for user mentions.""" condition = {"kind": "org.matrix.msc3952.is_user_mention"} # No mentions shouldn't match. evaluator = self._get_evaluator({}) self.assertFalse(evaluator.matches(condition, "@user:test", None)) # An empty set shouldn't match evaluator = self._get_evaluator({}, user_mentions=set()) self.assertFalse(evaluator.matches(condition, "@user:test", None)) # The Matrix ID appearing anywhere in the mentions list should match evaluator = self._get_evaluator({}, user_mentions={"@user:test"}) self.assertTrue(evaluator.matches(condition, "@user:test", None)) evaluator = self._get_evaluator( {}, user_mentions={"@another:test", "@user:test"} ) self.assertTrue(evaluator.matches(condition, "@user:test", None)) # Note that invalid data is tested at tests.push.test_bulk_push_rule_evaluator.TestBulkPushRuleEvaluator.test_mentions # since the BulkPushRuleEvaluator is what handles data sanitisation. def test_room_mentions(self) -> None: """Check for room mentions.""" condition = {"kind": "org.matrix.msc3952.is_room_mention"} # No room mention shouldn't match. evaluator = self._get_evaluator({}) self.assertFalse(evaluator.matches(condition, None, None)) # Room mention should match. evaluator = self._get_evaluator({}, room_mention=True) self.assertTrue(evaluator.matches(condition, None, None)) # A room mention and user mention is valid. evaluator = self._get_evaluator( {}, user_mentions={"@another:test"}, room_mention=True ) self.assertTrue(evaluator.matches(condition, None, None)) # Note that invalid data is tested at tests.push.test_bulk_push_rule_evaluator.TestBulkPushRuleEvaluator.test_mentions # since the BulkPushRuleEvaluator is what handles data sanitisation. def _assert_matches( self, condition: JsonDict, content: JsonMapping, msg: Optional[str] = None ) -> None: evaluator = self._get_evaluator(content) self.assertTrue(evaluator.matches(condition, "@user:test", "display_name"), msg) def _assert_not_matches( self, condition: JsonDict, content: JsonDict, msg: Optional[str] = None ) -> None: evaluator = self._get_evaluator(content) self.assertFalse( evaluator.matches(condition, "@user:test", "display_name"), msg ) def test_event_match_body(self) -> None: """Check that event_match conditions on content.body work as expected""" # if the key is `content.body`, the pattern matches substrings. # non-wildcards should match condition = { "kind": "event_match", "key": "content.body", "pattern": "foobaz", } self._assert_matches( condition, {"body": "aaa FoobaZ zzz"}, "patterns should match and be case-insensitive", ) self._assert_not_matches( condition, {"body": "aa xFoobaZ yy"}, "pattern should only match at word boundaries", ) self._assert_not_matches( condition, {"body": "aa foobazx yy"}, "pattern should only match at word boundaries", ) # wildcards should match condition = { "kind": "event_match", "key": "content.body", "pattern": "f?o*baz", } self._assert_matches( condition, {"body": "aaa FoobarbaZ zzz"}, "* should match string and pattern should be case-insensitive", ) self._assert_matches( condition, {"body": "aa foobaz yy"}, "* should match 0 characters" ) self._assert_not_matches( condition, {"body": "aa fobbaz yy"}, "? should not match 0 characters" ) self._assert_not_matches( condition, {"body": "aa fiiobaz yy"}, "? should not match 2 characters" ) self._assert_not_matches( condition, {"body": "aa xfooxbaz yy"}, "pattern should only match at word boundaries", ) self._assert_not_matches( condition, {"body": "aa fooxbazx yy"}, "pattern should only match at word boundaries", ) # test backslashes condition = { "kind": "event_match", "key": "content.body", "pattern": r"f\oobaz", } self._assert_matches( condition, {"body": r"F\oobaz"}, "backslash should match itself", ) condition = { "kind": "event_match", "key": "content.body", "pattern": r"f\?obaz", } self._assert_matches( condition, {"body": r"F\oobaz"}, r"? after \ should match any character", ) def test_event_match_non_body(self) -> None: """Check that event_match conditions on other keys work as expected""" # if the key is anything other than 'content.body', the pattern must match the # whole value. # non-wildcards should match condition = { "kind": "event_match", "key": "content.value", "pattern": "foobaz", } self._assert_matches( condition, {"value": "FoobaZ"}, "patterns should match and be case-insensitive", ) self._assert_not_matches( condition, {"value": "xFoobaZ"}, "pattern should only match at the start/end of the value", ) self._assert_not_matches( condition, {"value": "FoobaZz"}, "pattern should only match at the start/end of the value", ) # it should work on frozendicts too self._assert_matches( condition, frozendict.frozendict({"value": "FoobaZ"}), "patterns should match on frozendicts", ) # wildcards should match condition = { "kind": "event_match", "key": "content.value", "pattern": "f?o*baz", } self._assert_matches( condition, {"value": "FoobarbaZ"}, "* should match string and pattern should be case-insensitive", ) self._assert_matches( condition, {"value": "foobaz"}, "* should match 0 characters" ) self._assert_not_matches( condition, {"value": "fobbaz"}, "? should not match 0 characters" ) self._assert_not_matches( condition, {"value": "fiiobaz"}, "? should not match 2 characters" ) self._assert_not_matches( condition, {"value": "xfooxbaz"}, "pattern should only match at the start/end of the value", ) self._assert_not_matches( condition, {"value": "fooxbazx"}, "pattern should only match at the start/end of the value", ) self._assert_not_matches( condition, {"value": "x\nfooxbaz"}, "pattern should not match after a newline", ) self._assert_not_matches( condition, {"value": "fooxbaz\nx"}, "pattern should not match before a newline", ) def test_no_body(self) -> None: """Not having a body shouldn't break the evaluator.""" evaluator = self._get_evaluator({}) condition = { "kind": "contains_display_name", } self.assertFalse(evaluator.matches(condition, "@user:test", "foo")) def test_invalid_body(self) -> None: """A non-string body should not break the evaluator.""" condition = { "kind": "contains_display_name", } for body in (1, True, {"foo": "bar"}): evaluator = self._get_evaluator({"body": body}) self.assertFalse(evaluator.matches(condition, "@user:test", "foo")) def test_tweaks_for_actions(self) -> None: """ This tests the behaviour of tweaks_for_actions. """ actions: List[Union[Dict[str, str], str]] = [ {"set_tweak": "sound", "value": "default"}, {"set_tweak": "highlight"}, "notify", ] self.assertEqual( tweaks_for_actions(actions), {"sound": "default", "highlight": True}, ) def test_related_event_match(self) -> None: evaluator = self._get_evaluator( { "m.relates_to": { "event_id": "$parent_event_id", "key": "😀", "rel_type": "m.annotation", "m.in_reply_to": { "event_id": "$parent_event_id", }, } }, related_events={ "m.in_reply_to": { "event_id": "$parent_event_id", "type": "m.room.message", "sender": "@other_user:test", "room_id": "!room:test", "content.msgtype": "m.text", "content.body": "Original message", }, "m.annotation": { "event_id": "$parent_event_id", "type": "m.room.message", "sender": "@other_user:test", "room_id": "!room:test", "content.msgtype": "m.text", "content.body": "Original message", }, }, ) self.assertTrue( evaluator.matches( { "kind": "im.nheko.msc3664.related_event_match", "key": "sender", "rel_type": "m.in_reply_to", "pattern": "@other_user:test", }, "@user:test", "display_name", ) ) self.assertFalse( evaluator.matches( { "kind": "im.nheko.msc3664.related_event_match", "key": "sender", "rel_type": "m.in_reply_to", "pattern": "@user:test", }, "@other_user:test", "display_name", ) ) self.assertTrue( evaluator.matches( { "kind": "im.nheko.msc3664.related_event_match", "key": "sender", "rel_type": "m.annotation", "pattern": "@other_user:test", }, "@other_user:test", "display_name", ) ) self.assertFalse( evaluator.matches( { "kind": "im.nheko.msc3664.related_event_match", "key": "sender", "rel_type": "m.in_reply_to", }, "@user:test", "display_name", ) ) self.assertTrue( evaluator.matches( { "kind": "im.nheko.msc3664.related_event_match", "rel_type": "m.in_reply_to", }, "@user:test", "display_name", ) ) self.assertFalse( evaluator.matches( { "kind": "im.nheko.msc3664.related_event_match", "rel_type": "m.replace", }, "@other_user:test", "display_name", ) ) def test_related_event_match_with_fallback(self) -> None: evaluator = self._get_evaluator( { "m.relates_to": { "event_id": "$parent_event_id", "key": "😀", "rel_type": "m.thread", "is_falling_back": True, "m.in_reply_to": { "event_id": "$parent_event_id", }, } }, related_events={ "m.in_reply_to": { "event_id": "$parent_event_id", "type": "m.room.message", "sender": "@other_user:test", "room_id": "!room:test", "content.msgtype": "m.text", "content.body": "Original message", "im.vector.is_falling_back": "", }, "m.thread": { "event_id": "$parent_event_id", "type": "m.room.message", "sender": "@other_user:test", "room_id": "!room:test", "content.msgtype": "m.text", "content.body": "Original message", }, }, ) self.assertTrue( evaluator.matches( { "kind": "im.nheko.msc3664.related_event_match", "key": "sender", "rel_type": "m.in_reply_to", "pattern": "@other_user:test", "include_fallbacks": True, }, "@user:test", "display_name", ) ) self.assertFalse( evaluator.matches( { "kind": "im.nheko.msc3664.related_event_match", "key": "sender", "rel_type": "m.in_reply_to", "pattern": "@other_user:test", "include_fallbacks": False, }, "@user:test", "display_name", ) ) self.assertFalse( evaluator.matches( { "kind": "im.nheko.msc3664.related_event_match", "key": "sender", "rel_type": "m.in_reply_to", "pattern": "@other_user:test", }, "@user:test", "display_name", ) ) def test_related_event_match_no_related_event(self) -> None: evaluator = self._get_evaluator( {"msgtype": "m.text", "body": "Message without related event"} ) self.assertFalse( evaluator.matches( { "kind": "im.nheko.msc3664.related_event_match", "key": "sender", "rel_type": "m.in_reply_to", "pattern": "@other_user:test", }, "@user:test", "display_name", ) ) self.assertFalse( evaluator.matches( { "kind": "im.nheko.msc3664.related_event_match", "key": "sender", "rel_type": "m.in_reply_to", }, "@user:test", "display_name", ) ) self.assertFalse( evaluator.matches( { "kind": "im.nheko.msc3664.related_event_match", "rel_type": "m.in_reply_to", }, "@user:test", "display_name", ) ) class TestBulkPushRuleEvaluator(unittest.HomeserverTestCase): """Tests for the bulk push rule evaluator""" servlets = [ synapse.rest.admin.register_servlets_for_client_rest_resource, login.register_servlets, register.register_servlets, room.register_servlets, ] def prepare( self, reactor: MemoryReactor, clock: Clock, homeserver: HomeServer ) -> None: # Define an application service so that we can register appservice users self._service_token = "some_token" self._service = ApplicationService( self._service_token, "as1", "@as.sender:test", namespaces={ "users": [ {"regex": "@_as_.*:test", "exclusive": True}, {"regex": "@as.sender:test", "exclusive": True}, ] }, msc3202_transaction_extensions=True, ) self.hs.get_datastores().main.services_cache = [self._service] self.hs.get_datastores().main.exclusive_user_regex = _make_exclusive_regex( [self._service] ) self._as_user, _ = self.register_appservice_user( "_as_user", self._service_token ) self.evaluator = self.hs.get_bulk_push_rule_evaluator() def test_ignore_appservice_users(self) -> None: "Test that we don't generate push for appservice users" user_id = self.register_user("user", "pass") token = self.login("user", "pass") room_id = self.helper.create_room_as(user_id, tok=token) self.get_success( inject_member_event(self.hs, room_id, self._as_user, Membership.JOIN) ) event, context = self.get_success( create_event( self.hs, type=EventTypes.Message, room_id=room_id, sender=user_id, content={"body": "test", "msgtype": "m.text"}, ) ) # Assert the returned push rules do not contain the app service user rules = self.get_success(self.evaluator._get_rules_for_event(event)) self.assertTrue(self._as_user not in rules) # Assert that no push actions have been added to the staging table (the # sender should not be pushed for the event) users_with_push_actions = self.get_success( self.hs.get_datastores().main.db_pool.simple_select_onecol( table="event_push_actions_staging", keyvalues={"event_id": event.event_id}, retcol="user_id", desc="test_ignore_appservice_users", ) ) self.assertEqual(len(users_with_push_actions), 0) class BulkPushRuleEvaluatorTestCase(unittest.HomeserverTestCase): servlets = [ admin.register_servlets, login.register_servlets, room.register_servlets, ] def prepare( self, reactor: MemoryReactor, clock: Clock, homeserver: HomeServer ) -> None: self.main_store = homeserver.get_datastores().main self.user_id1 = self.register_user("user1", "password") self.tok1 = self.login(self.user_id1, "password") self.user_id2 = self.register_user("user2", "password") self.tok2 = self.login(self.user_id2, "password") self.room_id = self.helper.create_room_as(tok=self.tok1) # We want to test history visibility works correctly. self.helper.send_state( self.room_id, EventTypes.RoomHistoryVisibility, {"history_visibility": HistoryVisibility.JOINED}, tok=self.tok1, ) def get_notif_count(self, user_id: str) -> int: return self.get_success( self.main_store.db_pool.simple_select_one_onecol( table="event_push_actions", keyvalues={"user_id": user_id}, retcol="COALESCE(SUM(notif), 0)", desc="get_staging_notif_count", ) ) def test_plain_message(self) -> None: """Test that sending a normal message in a room will trigger a notification """ # Have user2 join the room and cle self.helper.join(self.room_id, self.user_id2, tok=self.tok2) # They start off with no notifications, but get them when messages are # sent. self.assertEqual(self.get_notif_count(self.user_id2), 0) user1 = UserID.from_string(self.user_id1) self.create_and_send_event(self.room_id, user1) self.assertEqual(self.get_notif_count(self.user_id2), 1) def test_delayed_message(self) -> None: """Test that a delayed message that was from before a user joined doesn't cause a notification for the joined user. """ user1 = UserID.from_string(self.user_id1) # Send a message before user2 joins event_id1 = self.create_and_send_event(self.room_id, user1) # Have user2 join the room self.helper.join(self.room_id, self.user_id2, tok=self.tok2) # They start off with no notifications self.assertEqual(self.get_notif_count(self.user_id2), 0) # Send another message that references the event before the join to # simulate a "delayed" event self.create_and_send_event(self.room_id, user1, prev_event_ids=[event_id1]) # user2 should not be notified about it, because they can't see it. self.assertEqual(self.get_notif_count(self.user_id2), 0)