from .dispersytestclass import DispersyTestFunc


class TestTimeline(DispersyTestFunc):

    def test_delay_by_proof(self):
        """
        When OTHER receives a message that it has no permission for, it will send a
        dispersy-missing-proof message to try to obtain the dispersy-authorize.
        """
        node, other = self.create_nodes(2)
        node.send_identity(other)

        # permit NODE
        proof_msg = self._mm.create_authorize([(node.my_member, self._community.get_meta_message(u"protected-full-sync-text"), u"permit"),
                                    (node.my_member, self._community.get_meta_message(u"protected-full-sync-text"), u"authorize")])

        # NODE creates message
        tmessage = node.create_protected_full_sync_text("Protected message", 42)
        other.give_message(tmessage, node)

        # must NOT have been stored in the database
        other.assert_not_stored(tmessage)

        # OTHER sends dispersy-missing-proof to NODE
        _, message = node.receive_message(names=[u"dispersy-missing-proof"]).next()
        self.assertEqual(message.payload.member.public_key, node.my_member.public_key)
        self.assertEqual(message.payload.global_time, 42)

        # NODE provides proof
        other.give_message(proof_msg, node)

        # must have been stored in the database
        other.assert_is_stored(tmessage)

    def test_missing_proof(self):
        """
        When OTHER receives a dispersy-missing-proof message it needs to find and send the proof.
        """
        node, other = self.create_nodes(2)
        node.send_identity(other)

        # permit NODE
        authorize = self._mm.create_authorize([(node.my_member, self._community.get_meta_message(u"protected-full-sync-text"), u"permit"),
                                               (node.my_member, self._community.get_meta_message(u"protected-full-sync-text"), u"authorize")])
        node.give_message(authorize, self._mm)

        protected_text = node.create_protected_full_sync_text("Protected message", 42)
        node.store([protected_text])

        # OTHER pretends to received the protected message and requests the proof
        node.give_message(other.create_missing_proof(node.my_member, 42), other)

        # NODE sends dispersy-authorize to OTHER
        _, authorize = other.receive_message(names=[u"dispersy-authorize"]).next()

        permission_triplet = (node.my_member.mid, u"protected-full-sync-text", u"permit")
        authorize_permission_triplets = [(triplet[0].mid, triplet[1].name, triplet[2]) for triplet in authorize.payload.permission_triplets]
        self.assertIn(permission_triplet, authorize_permission_triplets)

    def test_missing_authorize_proof(self):
        """
             MASTER
               \\        authorize(MASTER, OWNER)
                \\
                OWNER
                  \\        authorize(OWNER, NODE1)
                   \\
                   NODE1

        When NODE receives a dispersy-missing-proof message from OTHER for authorize(MM, NODE)
        the dispersy-authorize message for authorize(MASTER, MM) must be returned.
        """
        node, other = self.create_nodes(2)
        node.send_identity(other)

        # permit NODE
        authorize = self._mm.create_authorize([(node.my_member, self._community.get_meta_message(u"protected-full-sync-text"), u"permit"),
                                             (node.my_member, self._community.get_meta_message(u"protected-full-sync-text"), u"authorize")])
        node.give_message(authorize, self._mm)

        # OTHER wants the proof that OWNER is allowed to grant authorization to NODE
        node.give_message(other.create_missing_proof(authorize.authentication.member, authorize.distribution.global_time), other)

        # NODE sends dispersy-authorize containing authorize(MASTER, OWNER) to OTHER
        _, authorize = other.receive_message(names=[u"dispersy-authorize"]).next()

        permission_triplet = (self._mm.my_member.mid, u"protected-full-sync-text", u"permit")
        authorize_permission_triplets = [(triplet[0].mid, triplet[1].name, triplet[2]) for triplet in authorize.payload.permission_triplets]
        self.assertIn(permission_triplet, authorize_permission_triplets)

210d875b4fc481efece25e3c452dbe7765c67df4
<mask token>


class TestTimeline(DispersyTestFunc):

    def test_delay_by_proof(self):
        """
        When OTHER receives a message that it has no permission for, it will send a
        dispersy-missing-proof message to try to obtain the dispersy-authorize.
        """
        node, other = self.create_nodes(2)
        node.send_identity(other)
        proof_msg = self._mm.create_authorize([(node.my_member, self.
            _community.get_meta_message(u'protected-full-sync-text'),
            u'permit'), (node.my_member, self._community.get_meta_message(
            u'protected-full-sync-text'), u'authorize')])
        tmessage = node.create_protected_full_sync_text('Protected message', 42
            )
        other.give_message(tmessage, node)
        other.assert_not_stored(tmessage)
        _, message = node.receive_message(names=[u'dispersy-missing-proof']
            ).next()
        self.assertEqual(message.payload.member.public_key, node.my_member.
            public_key)
        self.assertEqual(message.payload.global_time, 42)
        other.give_message(proof_msg, node)
        other.assert_is_stored(tmessage)
    <mask token>
    <mask token>

<mask token>


class TestTimeline(DispersyTestFunc):

    def test_delay_by_proof(self):
        """
        When OTHER receives a message that it has no permission for, it will send a
        dispersy-missing-proof message to try to obtain the dispersy-authorize.
        """
        node, other = self.create_nodes(2)
        node.send_identity(other)
        proof_msg = self._mm.create_authorize([(node.my_member, self.
            _community.get_meta_message(u'protected-full-sync-text'),
            u'permit'), (node.my_member, self._community.get_meta_message(
            u'protected-full-sync-text'), u'authorize')])
        tmessage = node.create_protected_full_sync_text('Protected message', 42
            )
        other.give_message(tmessage, node)
        other.assert_not_stored(tmessage)
        _, message = node.receive_message(names=[u'dispersy-missing-proof']
            ).next()
        self.assertEqual(message.payload.member.public_key, node.my_member.
            public_key)
        self.assertEqual(message.payload.global_time, 42)
        other.give_message(proof_msg, node)
        other.assert_is_stored(tmessage)
    <mask token>

    def test_missing_authorize_proof(self):
        """
             MASTER
               \\        authorize(MASTER, OWNER)
                \\
                OWNER
                  \\        authorize(OWNER, NODE1)
                   \\
                   NODE1

        When NODE receives a dispersy-missing-proof message from OTHER for authorize(MM, NODE)
        the dispersy-authorize message for authorize(MASTER, MM) must be returned.
        """
        node, other = self.create_nodes(2)
        node.send_identity(other)
        authorize = self._mm.create_authorize([(node.my_member, self.
            _community.get_meta_message(u'protected-full-sync-text'),
            u'permit'), (node.my_member, self._community.get_meta_message(
            u'protected-full-sync-text'), u'authorize')])
        node.give_message(authorize, self._mm)
        node.give_message(other.create_missing_proof(authorize.
            authentication.member, authorize.distribution.global_time), other)
        _, authorize = other.receive_message(names=[u'dispersy-authorize']
            ).next()
        permission_triplet = (self._mm.my_member.mid,
            u'protected-full-sync-text', u'permit')
        authorize_permission_triplets = [(triplet[0].mid, triplet[1].name,
            triplet[2]) for triplet in authorize.payload.permission_triplets]
        self.assertIn(permission_triplet, authorize_permission_triplets)

<mask token>


class TestTimeline(DispersyTestFunc):

    def test_delay_by_proof(self):
        """
        When OTHER receives a message that it has no permission for, it will send a
        dispersy-missing-proof message to try to obtain the dispersy-authorize.
        """
        node, other = self.create_nodes(2)
        node.send_identity(other)
        proof_msg = self._mm.create_authorize([(node.my_member, self.
            _community.get_meta_message(u'protected-full-sync-text'),
            u'permit'), (node.my_member, self._community.get_meta_message(
            u'protected-full-sync-text'), u'authorize')])
        tmessage = node.create_protected_full_sync_text('Protected message', 42
            )
        other.give_message(tmessage, node)
        other.assert_not_stored(tmessage)
        _, message = node.receive_message(names=[u'dispersy-missing-proof']
            ).next()
        self.assertEqual(message.payload.member.public_key, node.my_member.
            public_key)
        self.assertEqual(message.payload.global_time, 42)
        other.give_message(proof_msg, node)
        other.assert_is_stored(tmessage)

    def test_missing_proof(self):
        """
        When OTHER receives a dispersy-missing-proof message it needs to find and send the proof.
        """
        node, other = self.create_nodes(2)
        node.send_identity(other)
        authorize = self._mm.create_authorize([(node.my_member, self.
            _community.get_meta_message(u'protected-full-sync-text'),
            u'permit'), (node.my_member, self._community.get_meta_message(
            u'protected-full-sync-text'), u'authorize')])
        node.give_message(authorize, self._mm)
        protected_text = node.create_protected_full_sync_text(
            'Protected message', 42)
        node.store([protected_text])
        node.give_message(other.create_missing_proof(node.my_member, 42), other
            )
        _, authorize = other.receive_message(names=[u'dispersy-authorize']
            ).next()
        permission_triplet = (node.my_member.mid,
            u'protected-full-sync-text', u'permit')
        authorize_permission_triplets = [(triplet[0].mid, triplet[1].name,
            triplet[2]) for triplet in authorize.payload.permission_triplets]
        self.assertIn(permission_triplet, authorize_permission_triplets)

    def test_missing_authorize_proof(self):
        """
             MASTER
               \\        authorize(MASTER, OWNER)
                \\
                OWNER
                  \\        authorize(OWNER, NODE1)
                   \\
                   NODE1

        When NODE receives a dispersy-missing-proof message from OTHER for authorize(MM, NODE)
        the dispersy-authorize message for authorize(MASTER, MM) must be returned.
        """
        node, other = self.create_nodes(2)
        node.send_identity(other)
        authorize = self._mm.create_authorize([(node.my_member, self.
            _community.get_meta_message(u'protected-full-sync-text'),
            u'permit'), (node.my_member, self._community.get_meta_message(
            u'protected-full-sync-text'), u'authorize')])
        node.give_message(authorize, self._mm)
        node.give_message(other.create_missing_proof(authorize.
            authentication.member, authorize.distribution.global_time), other)
        _, authorize = other.receive_message(names=[u'dispersy-authorize']
            ).next()
        permission_triplet = (self._mm.my_member.mid,
            u'protected-full-sync-text', u'permit')
        authorize_permission_triplets = [(triplet[0].mid, triplet[1].name,
            triplet[2]) for triplet in authorize.payload.permission_triplets]
        self.assertIn(permission_triplet, authorize_permission_triplets)

from .dispersytestclass import DispersyTestFunc


class TestTimeline(DispersyTestFunc):

    def test_delay_by_proof(self):
        """
        When OTHER receives a message that it has no permission for, it will send a
        dispersy-missing-proof message to try to obtain the dispersy-authorize.
        """
        node, other = self.create_nodes(2)
        node.send_identity(other)
        proof_msg = self._mm.create_authorize([(node.my_member, self.
            _community.get_meta_message(u'protected-full-sync-text'),
            u'permit'), (node.my_member, self._community.get_meta_message(
            u'protected-full-sync-text'), u'authorize')])
        tmessage = node.create_protected_full_sync_text('Protected message', 42
            )
        other.give_message(tmessage, node)
        other.assert_not_stored(tmessage)
        _, message = node.receive_message(names=[u'dispersy-missing-proof']
            ).next()
        self.assertEqual(message.payload.member.public_key, node.my_member.
            public_key)
        self.assertEqual(message.payload.global_time, 42)
        other.give_message(proof_msg, node)
        other.assert_is_stored(tmessage)

    def test_missing_proof(self):
        """
        When OTHER receives a dispersy-missing-proof message it needs to find and send the proof.
        """
        node, other = self.create_nodes(2)
        node.send_identity(other)
        authorize = self._mm.create_authorize([(node.my_member, self.
            _community.get_meta_message(u'protected-full-sync-text'),
            u'permit'), (node.my_member, self._community.get_meta_message(
            u'protected-full-sync-text'), u'authorize')])
        node.give_message(authorize, self._mm)
        protected_text = node.create_protected_full_sync_text(
            'Protected message', 42)
        node.store([protected_text])
        node.give_message(other.create_missing_proof(node.my_member, 42), other
            )
        _, authorize = other.receive_message(names=[u'dispersy-authorize']
            ).next()
        permission_triplet = (node.my_member.mid,
            u'protected-full-sync-text', u'permit')
        authorize_permission_triplets = [(triplet[0].mid, triplet[1].name,
            triplet[2]) for triplet in authorize.payload.permission_triplets]
        self.assertIn(permission_triplet, authorize_permission_triplets)

    def test_missing_authorize_proof(self):
        """
             MASTER
               \\        authorize(MASTER, OWNER)
                \\
                OWNER
                  \\        authorize(OWNER, NODE1)
                   \\
                   NODE1

        When NODE receives a dispersy-missing-proof message from OTHER for authorize(MM, NODE)
        the dispersy-authorize message for authorize(MASTER, MM) must be returned.
        """
        node, other = self.create_nodes(2)
        node.send_identity(other)
        authorize = self._mm.create_authorize([(node.my_member, self.
            _community.get_meta_message(u'protected-full-sync-text'),
            u'permit'), (node.my_member, self._community.get_meta_message(
            u'protected-full-sync-text'), u'authorize')])
        node.give_message(authorize, self._mm)
        node.give_message(other.create_missing_proof(authorize.
            authentication.member, authorize.distribution.global_time), other)
        _, authorize = other.receive_message(names=[u'dispersy-authorize']
            ).next()
        permission_triplet = (self._mm.my_member.mid,
            u'protected-full-sync-text', u'permit')
        authorize_permission_triplets = [(triplet[0].mid, triplet[1].name,
            triplet[2]) for triplet in authorize.payload.permission_triplets]
        self.assertIn(permission_triplet, authorize_permission_triplets)

from .dispersytestclass import DispersyTestFunc


class TestTimeline(DispersyTestFunc):

    def test_delay_by_proof(self):
        """
        When OTHER receives a message that it has no permission for, it will send a
        dispersy-missing-proof message to try to obtain the dispersy-authorize.
        """
        node, other = self.create_nodes(2)
        node.send_identity(other)

        # permit NODE
        proof_msg = self._mm.create_authorize([(node.my_member, self._community.get_meta_message(u"protected-full-sync-text"), u"permit"),
                                    (node.my_member, self._community.get_meta_message(u"protected-full-sync-text"), u"authorize")])

        # NODE creates message
        tmessage = node.create_protected_full_sync_text("Protected message", 42)
        other.give_message(tmessage, node)

        # must NOT have been stored in the database
        other.assert_not_stored(tmessage)

        # OTHER sends dispersy-missing-proof to NODE
        _, message = node.receive_message(names=[u"dispersy-missing-proof"]).next()
        self.assertEqual(message.payload.member.public_key, node.my_member.public_key)
        self.assertEqual(message.payload.global_time, 42)

        # NODE provides proof
        other.give_message(proof_msg, node)

        # must have been stored in the database
        other.assert_is_stored(tmessage)

    def test_missing_proof(self):
        """
        When OTHER receives a dispersy-missing-proof message it needs to find and send the proof.
        """
        node, other = self.create_nodes(2)
        node.send_identity(other)

        # permit NODE
        authorize = self._mm.create_authorize([(node.my_member, self._community.get_meta_message(u"protected-full-sync-text"), u"permit"),
                                               (node.my_member, self._community.get_meta_message(u"protected-full-sync-text"), u"authorize")])
        node.give_message(authorize, self._mm)

        protected_text = node.create_protected_full_sync_text("Protected message", 42)
        node.store([protected_text])

        # OTHER pretends to received the protected message and requests the proof
        node.give_message(other.create_missing_proof(node.my_member, 42), other)

        # NODE sends dispersy-authorize to OTHER
        _, authorize = other.receive_message(names=[u"dispersy-authorize"]).next()

        permission_triplet = (node.my_member.mid, u"protected-full-sync-text", u"permit")
        authorize_permission_triplets = [(triplet[0].mid, triplet[1].name, triplet[2]) for triplet in authorize.payload.permission_triplets]
        self.assertIn(permission_triplet, authorize_permission_triplets)

    def test_missing_authorize_proof(self):
        """
             MASTER
               \\        authorize(MASTER, OWNER)
                \\
                OWNER
                  \\        authorize(OWNER, NODE1)
                   \\
                   NODE1

        When NODE receives a dispersy-missing-proof message from OTHER for authorize(MM, NODE)
        the dispersy-authorize message for authorize(MASTER, MM) must be returned.
        """
        node, other = self.create_nodes(2)
        node.send_identity(other)

        # permit NODE
        authorize = self._mm.create_authorize([(node.my_member, self._community.get_meta_message(u"protected-full-sync-text"), u"permit"),
                                             (node.my_member, self._community.get_meta_message(u"protected-full-sync-text"), u"authorize")])
        node.give_message(authorize, self._mm)

        # OTHER wants the proof that OWNER is allowed to grant authorization to NODE
        node.give_message(other.create_missing_proof(authorize.authentication.member, authorize.distribution.global_time), other)

        # NODE sends dispersy-authorize containing authorize(MASTER, OWNER) to OTHER
        _, authorize = other.receive_message(names=[u"dispersy-authorize"]).next()

        permission_triplet = (self._mm.my_member.mid, u"protected-full-sync-text", u"permit")
        authorize_permission_triplets = [(triplet[0].mid, triplet[1].name, triplet[2]) for triplet in authorize.payload.permission_triplets]
        self.assertIn(permission_triplet, authorize_permission_triplets)
