Fix some tests

tests/handlers/test_typing.py

@@ -131,7 +131,7 @@ class TypingNotificationsTestCase(unittest.TestCase):
                 if ignore_user is not None and member == ignore_user:
                     continue
 
-                if member.is_mine:
+                if hs.is_mine(member):
                     if localusers is not None:
                         localusers.add(member)
                 else:

tests/storage/test_redaction.py

@@ -23,7 +23,9 @@ from synapse.api.events.room import (
     RoomMemberEvent, MessageEvent, RoomRedactionEvent,
 )
 
-from tests.utils import SQLiteMemoryDbPool
+from tests.utils import SQLiteMemoryDbPool, MockKey
+
+from mock import Mock
 
 
 class RedactionTestCase(unittest.TestCase):
@@ -33,13 +35,21 @@ class RedactionTestCase(unittest.TestCase):
         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_factory = hs.get_event_factory()
+        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")
@@ -49,35 +59,23 @@ class RedactionTestCase(unittest.TestCase):
         self.depth = 1
 
     @defer.inlineCallbacks
-    def inject_room_member(self, room, user, membership, prev_state=None,
+    def inject_room_member(self, room, user, membership, replaces_state=None,
                            extra_content={}):
-        self.depth += 1
+        content = {"membership": membership}
+        content.update(extra_content)
+        builder = self.event_builder_factory.new({
+            "type": RoomMemberEvent.TYPE,
+            "sender": user.to_string(),
+            "state_key": user.to_string(),
+            "room_id": room.to_string(),
+            "content": content,
+        })
 
-        event = self.event_factory.create_event(
+        event, context = yield self.message_handler._create_new_client_event(
-            etype=RoomMemberEvent.TYPE,
+            builder
-            user_id=user.to_string(),
-            state_key=user.to_string(),
-            room_id=room.to_string(),
-            membership=membership,
-            content={"membership": membership},
-            depth=self.depth,
-            prev_events=[],
         )
 
-        event.content.update(extra_content)
+        yield self.store.persist_event(event, context)
-
-        if prev_state:
-            event.prev_state = prev_state
-
-        event.state_events = None
-        event.hashes = {}
-        event.prev_state = []
-        event.auth_events = []
-
-        # Have to create a join event using the eventfactory
-        yield self.store.persist_event(
-            event
-        )
 
         defer.returnValue(event)
 
@@ -85,46 +83,38 @@ class RedactionTestCase(unittest.TestCase):
     def inject_message(self, room, user, body):
         self.depth += 1
 
-        event = self.event_factory.create_event(
+        builder = self.event_builder_factory.new({
-            etype=MessageEvent.TYPE,
+            "type": MessageEvent.TYPE,
-            user_id=user.to_string(),
+            "sender": user.to_string(),
-            room_id=room.to_string(),
+            "state_key": user.to_string(),
-            content={"body": body, "msgtype": u"message"},
+            "room_id": room.to_string(),
-            depth=self.depth,
+            "content": {"body": body, "msgtype": u"message"},
-            prev_events=[],
+        })
+
+        event, context = yield self.message_handler._create_new_client_event(
+            builder
         )
 
-        event.state_events = None
+        yield self.store.persist_event(event, context)
-        event.hashes = {}
-        event.auth_events = []
-
-        yield self.store.persist_event(
-            event
-        )
 
         defer.returnValue(event)
 
     @defer.inlineCallbacks
     def inject_redaction(self, room, event_id, user, reason):
-        event = self.event_factory.create_event(
+        builder = self.event_builder_factory.new({
-            etype=RoomRedactionEvent.TYPE,
+            "type": MessageEvent.TYPE,
-            user_id=user.to_string(),
+            "sender": user.to_string(),
-            room_id=room.to_string(),
+            "state_key": user.to_string(),
-            content={"reason": reason},
+            "room_id": room.to_string(),
-            depth=self.depth,
+            "content": {"reason": reason},
-            redacts=event_id,
+            "redacts": event_id,
-            prev_events=[],
+        })
+
+        event, context = yield self.message_handler._create_new_client_event(
+            builder
         )
 
-        event.state_events = None
+        yield self.store.persist_event(event, context)
-        event.hashes = {}
-        event.auth_events = []
-
-        yield self.store.persist_event(
-            event
-        )
-
-        defer.returnValue(event)
 
     @defer.inlineCallbacks
     def test_redact(self):

tests/storage/test_roommember.py

@@ -21,7 +21,9 @@ from synapse.server import HomeServer
 from synapse.api.constants import Membership
 from synapse.api.events.room import RoomMemberEvent
 
-from tests.utils import SQLiteMemoryDbPool
+from tests.utils import SQLiteMemoryDbPool, MockKey
+
+from mock import Mock
 
 
 class RoomMemberStoreTestCase(unittest.TestCase):
@@ -31,14 +33,22 @@ class RoomMemberStoreTestCase(unittest.TestCase):
         db_pool = SQLiteMemoryDbPool()
         yield db_pool.prepare()
 
-        hs = HomeServer("test",
+        self.mock_config = Mock()
-            db_pool=db_pool,
+        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_factory = hs.get_event_factory()
+        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")
@@ -49,27 +59,22 @@ class RoomMemberStoreTestCase(unittest.TestCase):
         self.room = hs.parse_roomid("!abc123:test")
 
     @defer.inlineCallbacks
-    def inject_room_member(self, room, user, membership):
+    def inject_room_member(self, room, user, membership, replaces_state=None):
-        # Have to create a join event using the eventfactory
+        builder = self.event_builder_factory.new({
-        event = self.event_factory.create_event(
+            "type": RoomMemberEvent.TYPE,
-            etype=RoomMemberEvent.TYPE,
+            "sender": user.to_string(),
-            user_id=user.to_string(),
+            "state_key": user.to_string(),
-            state_key=user.to_string(),
+            "room_id": room.to_string(),
-            room_id=room.to_string(),
+            "content": {"membership": membership},
-            membership=membership,
+        })
-            content={"membership": membership},
+
-            depth=1,
+        event, context = yield self.message_handler._create_new_client_event(
-            prev_events=[],
+            builder
         )
 
-        event.state_events = None
+        yield self.store.persist_event(event, context)
-        event.hashes = {}
-        event.prev_state = {}
-        event.auth_events = {}
 
-        yield self.store.persist_event(
+        defer.returnValue(event)
-            event
-        )
 
     @defer.inlineCallbacks
     def test_one_member(self):

tests/storage/test_stream.py

@@ -21,7 +21,9 @@ from synapse.server import HomeServer
 from synapse.api.constants import Membership
 from synapse.api.events.room import RoomMemberEvent, MessageEvent
 
-from tests.utils import SQLiteMemoryDbPool
+from tests.utils import SQLiteMemoryDbPool, MockKey
+
+from mock import Mock
 
 
 class StreamStoreTestCase(unittest.TestCase):
@@ -31,13 +33,21 @@ class StreamStoreTestCase(unittest.TestCase):
         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_factory = hs.get_event_factory()
+        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")
@@ -51,30 +61,19 @@ class StreamStoreTestCase(unittest.TestCase):
     def inject_room_member(self, room, user, membership, replaces_state=None):
         self.depth += 1
 
-        event = self.event_factory.create_event(
+        builder = self.event_builder_factory.new({
-            etype=RoomMemberEvent.TYPE,
+            "type": RoomMemberEvent.TYPE,
-            user_id=user.to_string(),
+            "sender": user.to_string(),
-            state_key=user.to_string(),
+            "state_key": user.to_string(),
-            room_id=room.to_string(),
+            "room_id": room.to_string(),
-            membership=membership,
+            "content": {"membership": membership},
-            content={"membership": membership},
+        })
-            depth=self.depth,
+
-            prev_events=[],
+        event, context = yield self.message_handler._create_new_client_event(
+            builder
         )
 
-        event.state_events = None
+        yield self.store.persist_event(event, context)
-        event.hashes = {}
-        event.prev_state = []
-        event.auth_events = []
-
-        if replaces_state:
-            event.prev_state = [(replaces_state, "hash")]
-            event.replaces_state = replaces_state
-
-        # Have to create a join event using the eventfactory
-        yield self.store.persist_event(
-            event
-        )
 
         defer.returnValue(event)
 
@@ -82,23 +81,19 @@ class StreamStoreTestCase(unittest.TestCase):
     def inject_message(self, room, user, body):
         self.depth += 1
 
-        event = self.event_factory.create_event(
+        builder = self.event_builder_factory.new({
-            etype=MessageEvent.TYPE,
+            "type": MessageEvent.TYPE,
-            user_id=user.to_string(),
+            "sender": user.to_string(),
-            room_id=room.to_string(),
+            "state_key": user.to_string(),
-            content={"body": body, "msgtype": u"message"},
+            "room_id": room.to_string(),
-            depth=self.depth,
+            "content": {"body": body, "msgtype": u"message"},
-            prev_events=[],
+        })
+
+        event, context = yield self.message_handler._create_new_client_event(
+            builder
         )
 
-        event.state_events = None
+        yield self.store.persist_event(event, context)
-        event.hashes = {}
-        event.auth_events = []
-
-        # Have to create a join event using the eventfactory
-        yield self.store.persist_event(
-            event
-        )
 
     @defer.inlineCallbacks
     def test_event_stream_get_other(self):

tests/test_types.py

@@ -23,21 +23,21 @@ mock_homeserver = BaseHomeServer(hostname="my.domain")
 class UserIDTestCase(unittest.TestCase):
 
     def test_parse(self):
-        user = UserID.from_string("@1234abcd:my.domain", hs=mock_homeserver)
+        user = UserID.from_string("@1234abcd:my.domain")
 
         self.assertEquals("1234abcd", user.localpart)
         self.assertEquals("my.domain", user.domain)
-        self.assertEquals(True, user.is_mine)
+        self.assertEquals(True, mock_homeserver.is_mine(user))
 
     def test_build(self):
-        user = UserID("5678efgh", "my.domain", True)
+        user = UserID("5678efgh", "my.domain")
 
         self.assertEquals(user.to_string(), "@5678efgh:my.domain")
 
     def test_compare(self):
-        userA = UserID.from_string("@userA:my.domain", hs=mock_homeserver)
+        userA = UserID.from_string("@userA:my.domain")
-        userAagain = UserID.from_string("@userA:my.domain", hs=mock_homeserver)
+        userAagain = UserID.from_string("@userA:my.domain")
-        userB = UserID.from_string("@userB:my.domain", hs=mock_homeserver)
+        userB = UserID.from_string("@userB:my.domain")
 
         self.assertTrue(userA == userAagain)
         self.assertTrue(userA != userB)
@@ -52,14 +52,14 @@ class UserIDTestCase(unittest.TestCase):
 class RoomAliasTestCase(unittest.TestCase):
 
     def test_parse(self):
-        room = RoomAlias.from_string("#channel:my.domain", hs=mock_homeserver)
+        room = RoomAlias.from_string("#channel:my.domain")
 
         self.assertEquals("channel", room.localpart)
         self.assertEquals("my.domain", room.domain)
-        self.assertEquals(True, room.is_mine)
+        self.assertEquals(True, mock_homeserver.is_mine(room))
 
     def test_build(self):
-        room = RoomAlias("channel", "my.domain", True)
+        room = RoomAlias("channel", "my.domain")
 
         self.assertEquals(room.to_string(), "#channel:my.domain")