Rewrite of PresenceHandler test to ensure it covers the interaction with Federation as well

1 files changed, 279 insertions, 149 deletions

diff --git a/tests/handlers/test_presence.py b/tests/handlers/test_presence.py
index a1856e46e2..8b88c49a0b 100644
--- a/tests/handlers/test_presence.py
+++ b/tests/handlers/test_presence.py
@@ -19,8 +19,9 @@ from twisted.internet import defer
 
 from mock import Mock, call, ANY
 import logging
+import json
 
-from ..utils import MockClock
+from ..utils import MockHttpResource, MockClock, DeferredMockCallable
 
 from synapse.server import HomeServer
 from synapse.api.constants import PresenceState
@@ -34,17 +35,27 @@ ONLINE = PresenceState.ONLINE
 
 
 logging.getLogger().addHandler(logging.NullHandler())
+#logging.getLogger().addHandler(logging.StreamHandler())
+#logging.getLogger().setLevel(logging.DEBUG)
+
+
+def _expect_edu(destination, edu_type, content, origin="test"):
+    return {
+        "origin": origin,
+        "ts": 1000000,
+        "pdus": [],
+        "edus": [
+            {
+                "origin": origin,
+                "destination": destination,
+                "edu_type": edu_type,
+                "content": content,
+            }
+        ],
+    }
 
-
-class MockReplication(object):
-    def __init__(self):
-        self.edu_handlers = {}
-
-    def register_edu_handler(self, edu_type, handler):
-        self.edu_handlers[edu_type] = handler
-
-    def received_edu(self, origin, edu_type, content):
-        self.edu_handlers[edu_type](origin, content)
+def _make_edu_json(origin, edu_type, content):
+    return json.dumps(_expect_edu("test", edu_type, content, origin=origin))
 
 
 class JustPresenceHandlers(object):
@@ -209,10 +220,13 @@ class PresenceInvitesTestCase(unittest.TestCase):
     """ Tests presence management. """
 
     def setUp(self):
-        self.replication = MockReplication()
-        self.replication.send_edu = Mock()
+        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=[
                     "has_presence_state",
@@ -221,11 +235,17 @@ class PresenceInvitesTestCase(unittest.TestCase):
                     "set_presence_list_accepted",
                     "get_presence_list",
                     "del_presence_list",
+
+                    # Bits that Federation needs
+                    "prep_send_transaction",
+                    "delivered_txn",
+                    "get_received_txn_response",
+                    "set_received_txn_response",
                 ]),
                 handlers=None,
                 resource_for_client=Mock(),
-                http_client=None,
-                replication_layer=self.replication
+                resource_for_federation=self.mock_federation_resource,
+                http_client=self.mock_http_client,
             )
         hs.handlers = JustPresenceHandlers(hs)
 
@@ -236,6 +256,10 @@ class PresenceInvitesTestCase(unittest.TestCase):
                 user_localpart in ("apple", "banana"))
         self.datastore.has_presence_state = has_presence_state
 
+        def get_received_txn_response(*args):
+            return defer.succeed(None)
+        self.datastore.get_received_txn_response = get_received_txn_response
+
         # Some local users to test with
         self.u_apple = hs.parse_userid("@apple:test")
         self.u_banana = hs.parse_userid("@banana:test")
@@ -283,7 +307,19 @@ class PresenceInvitesTestCase(unittest.TestCase):
 
     @defer.inlineCallbacks
     def test_invite_remote(self):
-        self.replication.send_edu.return_value = defer.succeed((200, "OK"))
+        put_json = self.mock_http_client.put_json
+        put_json.expect_call_and_return(
+            call("elsewhere",
+                path="/matrix/federation/v1/send/1000000/",
+                data=_expect_edu("elsewhere", "m.presence_invite",
+                    content={
+                        "observer_user": "@apple:test",
+                        "observed_user": "@cabbage:elsewhere",
+                    }
+                )
+            ),
+            defer.succeed((200, "OK"))
+        )
 
         yield self.handler.send_invite(
                 observer_user=self.u_apple, observed_user=self.u_cabbage)
@@ -291,67 +327,79 @@ class PresenceInvitesTestCase(unittest.TestCase):
         self.datastore.add_presence_list_pending.assert_called_with(
                 "apple", "@cabbage:elsewhere")
 
-        self.replication.send_edu.assert_called_with(
-                destination="elsewhere",
-                edu_type="m.presence_invite",
-                content={
-                    "observer_user": "@apple:test",
-                    "observed_user": "@cabbage:elsewhere",
-                }
-        )
+        yield put_json.await_calls()
 
     @defer.inlineCallbacks
     def test_accept_remote(self):
         # TODO(paul): This test will likely break if/when real auth permissions
         # are added; for now the HS will always accept any invite
-        self.replication.send_edu.return_value = defer.succeed((200, "OK"))
+        put_json = self.mock_http_client.put_json
+        put_json.expect_call_and_return(
+            call("elsewhere",
+                path="/matrix/federation/v1/send/1000000/",
+                data=_expect_edu("elsewhere", "m.presence_accept",
+                    content={
+                        "observer_user": "@cabbage:elsewhere",
+                        "observed_user": "@apple:test",
+                    }
+                )
+            ),
+            defer.succeed((200, "OK"))
+        )
 
-        yield self.replication.received_edu(
-                "elsewhere", "m.presence_invite", {
+        yield self.mock_federation_resource.trigger("PUT",
+            "/matrix/federation/v1/send/1000000/",
+            _make_edu_json("elsewhere", "m.presence_invite",
+                content={
                     "observer_user": "@cabbage:elsewhere",
                     "observed_user": "@apple:test",
                 }
+            )
         )
 
         self.datastore.allow_presence_visible.assert_called_with(
                 "apple", "@cabbage:elsewhere")
 
-        self.replication.send_edu.assert_called_with(
-                destination="elsewhere",
-                edu_type="m.presence_accept",
-                content={
-                    "observer_user": "@cabbage:elsewhere",
-                    "observed_user": "@apple:test",
-                }
-        )
+        yield put_json.await_calls()
 
     @defer.inlineCallbacks
     def test_invited_remote_nonexistant(self):
-        self.replication.send_edu.return_value = defer.succeed((200, "OK"))
-
-        yield self.replication.received_edu(
-                "elsewhere", "m.presence_invite", {
-                    "observer_user": "@cabbage:elsewhere",
-                    "observed_user": "@durian:test",
-                }
+        put_json = self.mock_http_client.put_json
+        put_json.expect_call_and_return(
+            call("elsewhere",
+                path="/matrix/federation/v1/send/1000000/",
+                data=_expect_edu("elsewhere", "m.presence_deny",
+                    content={
+                        "observer_user": "@cabbage:elsewhere",
+                        "observed_user": "@durian:test",
+                    }
+                )
+            ),
+            defer.succeed((200, "OK"))
         )
 
-        self.replication.send_edu.assert_called_with(
-                destination="elsewhere",
-                edu_type="m.presence_deny",
+        yield self.mock_federation_resource.trigger("PUT",
+            "/matrix/federation/v1/send/1000000/",
+            _make_edu_json("elsewhere", "m.presence_invite",
                 content={
                     "observer_user": "@cabbage:elsewhere",
                     "observed_user": "@durian:test",
                 }
+            )
         )
 
+        yield put_json.await_calls()
+
     @defer.inlineCallbacks
     def test_accepted_remote(self):
-        yield self.replication.received_edu(
-                "elsewhere", "m.presence_accept", {
+        yield self.mock_federation_resource.trigger("PUT",
+            "/matrix/federation/v1/send/1000000/",
+            _make_edu_json("elsewhere", "m.presence_accept",
+                content={
                     "observer_user": "@apple:test",
                     "observed_user": "@cabbage:elsewhere",
                 }
+            )
         )
 
         self.datastore.set_presence_list_accepted.assert_called_with(
@@ -362,11 +410,14 @@ class PresenceInvitesTestCase(unittest.TestCase):
 
     @defer.inlineCallbacks
     def test_denied_remote(self):
-        yield self.replication.received_edu(
-                "elsewhere", "m.presence_deny", {
+        yield self.mock_federation_resource.trigger("PUT",
+            "/matrix/federation/v1/send/1000000/",
+            _make_edu_json("elsewhere", "m.presence_deny",
+                content={
                     "observer_user": "@apple:test",
                     "observed_user": "@eggplant:elsewhere",
                 }
+            )
         )
 
         self.datastore.del_presence_list.assert_called_with(
@@ -432,22 +483,29 @@ class PresencePushTestCase(unittest.TestCase):
     BE WARNED...
     """
     def setUp(self):
-        self.replication = MockReplication()
-        self.replication.send_edu = Mock()
-        self.replication.send_edu.return_value = defer.succeed((200, "OK"))
-
         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",
+
+                    # Bits that Federation needs
+                    "prep_send_transaction",
+                    "delivered_txn",
+                    "get_received_txn_response",
+                    "set_received_txn_response",
                 ]),
                 handlers=None,
                 resource_for_client=Mock(),
-                http_client=None,
-                replication_layer=self.replication,
+                resource_for_federation=self.mock_federation_resource,
+                http_client=self.mock_http_client,
             )
         hs.handlers = JustPresenceHandlers(hs)
 
@@ -455,6 +513,11 @@ class PresencePushTestCase(unittest.TestCase):
         self.mock_update_client.return_value = defer.succeed(None)
 
         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.handler.push_update_to_clients = self.mock_update_client
 
@@ -593,41 +656,54 @@ class PresencePushTestCase(unittest.TestCase):
 
     @defer.inlineCallbacks
     def test_push_remote(self):
-        self.room_members = [self.u_apple, self.u_onion]
-
-        self.datastore.set_presence_state.return_value = defer.succeed(
-                {"state": ONLINE})
-
-        # TODO(paul): Gut-wrenching
-        self.handler._user_cachemap[self.u_apple] = UserPresenceCache()
-        apple_set = self.handler._remote_sendmap.setdefault("apple", set())
-        apple_set.add(self.u_potato.domain)
-
-        yield self.handler.set_state(self.u_apple, self.u_apple,
-                {"state": ONLINE})
-
-        self.replication.send_edu.assert_has_calls([
-                call(
-                    destination="remote",
-                    edu_type="m.presence",
+        put_json = self.mock_http_client.put_json
+        put_json.expect_call_and_return(
+            call("remote",
+                path=ANY,  # Can't guarantee which txn ID will be which
+                data=_expect_edu("remote", "m.presence",
                     content={
                         "push": [
                             {"user_id": "@apple:test",
                              "state": "online",
                              "mtime_age": 0},
                         ],
-                    }),
-                call(
-                    destination="farm",
-                    edu_type="m.presence",
+                    }
+                )
+            ),
+            defer.succeed((200, "OK"))
+        )
+        put_json.expect_call_and_return(
+            call("farm",
+                path=ANY,  # Can't guarantee which txn ID will be which
+                data=_expect_edu("farm", "m.presence",
                     content={
                         "push": [
                             {"user_id": "@apple:test",
                              "state": "online",
                              "mtime_age": 0},
                         ],
-                    })
-        ], any_order=True)
+                    }
+                )
+            ),
+            defer.succeed((200, "OK"))
+        )
+
+        self.room_members = [self.u_apple, self.u_onion]
+
+        self.datastore.set_presence_state.return_value = defer.succeed(
+            {"state": ONLINE}
+        )
+
+        # TODO(paul): Gut-wrenching
+        self.handler._user_cachemap[self.u_apple] = UserPresenceCache()
+        apple_set = self.handler._remote_sendmap.setdefault("apple", set())
+        apple_set.add(self.u_potato.domain)
+
+        yield self.handler.set_state(self.u_apple, self.u_apple,
+            {"state": ONLINE}
+        )
+
+        yield put_json.await_calls()
 
     @defer.inlineCallbacks
     def test_recv_remote(self):
@@ -638,14 +714,17 @@ class PresencePushTestCase(unittest.TestCase):
 
         self.room_members = [self.u_banana, self.u_potato]
 
-        yield self.replication.received_edu(
-                "remote", "m.presence", {
+        yield self.mock_federation_resource.trigger("PUT",
+            "/matrix/federation/v1/send/1000000/",
+            _make_edu_json("elsewhere", "m.presence",
+                content={
                     "push": [
                         {"user_id": "@potato:remote",
                          "state": "online",
                          "mtime_age": 1000},
                     ],
                 }
+            )
         )
 
         self.mock_update_client.assert_has_calls([
@@ -691,6 +770,35 @@ class PresencePushTestCase(unittest.TestCase):
     @defer.inlineCallbacks
     def test_join_room_remote(self):
         ## Sending local user state to a newly-joined remote user
+        put_json = self.mock_http_client.put_json
+        put_json.expect_call_and_return(
+            call("remote",
+                path=ANY,  # Can't guarantee which txn ID will be which
+                data=_expect_edu("remote", "m.presence",
+                    content={
+                        "push": [
+                            {"user_id": "@apple:test",
+                            "state": "online"},
+                        ],
+                    }
+                ),
+            ),
+            defer.succeed((200, "OK"))
+        )
+        put_json.expect_call_and_return(
+            call("remote",
+                path=ANY,  # Can't guarantee which txn ID will be which
+                data=_expect_edu("remote", "m.presence",
+                    content={
+                        "push": [
+                            {"user_id": "@banana:test",
+                            "state": "offline"},
+                        ],
+                    }
+                ),
+            ),
+            defer.succeed((200, "OK"))
+        )
 
         # TODO(paul): Gut-wrenching
         self.handler._user_cachemap[self.u_apple] = UserPresenceCache()
@@ -702,30 +810,24 @@ class PresencePushTestCase(unittest.TestCase):
             "a-room"
         )
 
-        self.replication.send_edu.assert_has_calls([
-                call(
-                    destination="remote",
-                    edu_type="m.presence",
+        yield put_json.await_calls()
+
+        ## Sending newly-joined local user state to remote users
+
+        put_json.expect_call_and_return(
+            call("remote",
+                path="/matrix/federation/v1/send/1000002/",
+                data=_expect_edu("remote", "m.presence",
                     content={
                         "push": [
-                            {"user_id": "@apple:test",
+                            {"user_id": "@clementine:test",
                             "state": "online"},
                         ],
-                    }),
-                call(
-                    destination="remote",
-                    edu_type="m.presence",
-                    content={
-                        "push": [
-                            {"user_id": "@banana:test",
-                            "state": "offline"},
-                        ],
-                    }),
-        ], any_order=True)
-
-        self.replication.send_edu.reset_mock()
-
-        ## Sending newly-joined local user state to remote users
+                    }
+                ),
+            ),
+            defer.succeed((200, "OK"))
+        )
 
         self.handler._user_cachemap[self.u_clementine] = UserPresenceCache()
         self.handler._user_cachemap[self.u_clementine].update(
@@ -736,17 +838,7 @@ class PresencePushTestCase(unittest.TestCase):
             "a-room"
         )
 
-        self.replication.send_edu.assert_has_calls(
-                call(
-                    destination="remote",
-                    edu_type="m.presence",
-                    content={
-                        "push": [
-                            {"user_id": "@clementine:test",
-                            "state": "online"},
-                        ],
-                    }),
-        )
+        put_json.await_calls()
 
 
 class PresencePollingTestCase(unittest.TestCase):
@@ -763,21 +855,34 @@ class PresencePollingTestCase(unittest.TestCase):
 
 
     def setUp(self):
-        self.replication = MockReplication()
-        self.replication.send_edu = Mock()
+        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=[]),
+                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(),
-                http_client=None,
-                replication_layer=self.replication,
+                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()
         self.mock_update_client.return_value = defer.succeed(None)
 
@@ -835,8 +940,9 @@ class PresencePollingTestCase(unittest.TestCase):
     def test_push_local(self):
         # apple goes online
         yield self.handler.set_state(
-                target_user=self.u_apple, auth_user=self.u_apple,
-                state={"state": ONLINE})
+            target_user=self.u_apple, auth_user=self.u_apple,
+            state={"state": ONLINE}
+        )
 
         # apple should see both banana and clementine currently offline
         self.mock_update_client.assert_has_calls([
@@ -893,68 +999,92 @@ class PresencePollingTestCase(unittest.TestCase):
 
     @defer.inlineCallbacks
     def test_remote_poll_send(self):
+        put_json = self.mock_http_client.put_json
+        put_json.expect_call_and_return(
+            call("remote",
+                path="/matrix/federation/v1/send/1000000/",
+                data=_expect_edu("remote", "m.presence",
+                    content={
+                        "poll": [ "@potato:remote" ],
+                    },
+                ),
+            ),
+            defer.succeed((200, "OK"))
+        )
+
         # clementine goes online
         yield self.handler.set_state(
                 target_user=self.u_clementine, auth_user=self.u_clementine,
                 state={"state": ONLINE})
 
-        self.replication.send_edu.assert_called_with(
-                destination="remote",
-                edu_type="m.presence",
-                content={
-                    "poll": [ "@potato:remote" ],
-                },
-        )
+        yield put_json.await_calls()
 
         # Gut-wrenching tests
         self.assertTrue(self.u_potato in self.handler._remote_recvmap)
         self.assertTrue(self.u_clementine in
                 self.handler._remote_recvmap[self.u_potato])
 
-        self.replication.send_edu.reset_mock()
+        put_json.expect_call_and_return(
+            call("remote",
+                path="/matrix/federation/v1/send/1000001/",
+                data=_expect_edu("remote", "m.presence",
+                    content={
+                        "unpoll": [ "@potato:remote" ],
+                    },
+                ),
+            ),
+            defer.succeed((200, "OK"))
+        )
 
         # clementine goes offline
         yield self.handler.set_state(
                 target_user=self.u_clementine, auth_user=self.u_clementine,
                 state={"state": OFFLINE})
 
-        self.replication.send_edu.assert_called_with(
-                destination="remote",
-                edu_type="m.presence",
-                content={
-                    "unpoll": [ "@potato:remote" ],
-                },
-        )
+        put_json.await_calls()
 
         self.assertFalse(self.u_potato in self.handler._remote_recvmap)
 
     @defer.inlineCallbacks
     def test_remote_poll_receive(self):
-        yield self.replication.received_edu(
-                "remote", "m.presence", {
+        put_json = self.mock_http_client.put_json
+        put_json.expect_call_and_return(
+            call("remote",
+                path="/matrix/federation/v1/send/1000000/",
+                data=_expect_edu("remote", "m.presence",
+                    content={
+                        "push": [
+                            {"user_id": "@banana:test",
+                             "state": "offline",
+                             "status_msg": None},
+                        ],
+                    },
+                ),
+            ),
+            defer.succeed((200, "OK"))
+        )
+
+        yield self.mock_federation_resource.trigger("PUT",
+            "/matrix/federation/v1/send/1000000/",
+            _make_edu_json("remote", "m.presence",
+                content={
                     "poll": [ "@banana:test" ],
-                }
+                },
+            )
         )
 
+        yield put_json.await_calls()
+
         # Gut-wrenching tests
         self.assertTrue(self.u_banana in self.handler._remote_sendmap)
 
-        self.replication.send_edu.assert_called_with(
-                destination="remote",
-                edu_type="m.presence",
+        yield self.mock_federation_resource.trigger("PUT",
+            "/matrix/federation/v1/send/1000001/",
+            _make_edu_json("remote", "m.presence",
                 content={
-                    "push": [
-                        {"user_id": "@banana:test",
-                         "state": "offline",
-                         "status_msg": None},
-                    ],
-                },
-        )
-
-        yield self.replication.received_edu(
-                "remote", "m.presence", {
                     "unpoll": [ "@banana:test" ],
                 }
+            )
         )
 
         # Gut-wrenching tests