Пример #1
0
 def setUp(self):
     """
     Create a C{MessageHandler} for the tests.
     """
     self.handler = MessageHandler("spam@egg", "test_cookie")
Пример #2
0
class MessageHandlerTestCase(TestCase):
    """
    Test for the message handler class.
    """

    def setUp(self):
        """
        Create a C{MessageHandler} for the tests.
        """
        self.handler = MessageHandler("spam@egg", "test_cookie")


    def test_link(self):
        """
        Test handling of a LINK token.
        """
        srcPid = Pid(Atom("foo@bar"), 0, 0, 0)
        destPid = Pid(Atom("spam@egg"), 0, 0, 0)
        ctrlMessage = (self.handler.CTRLMSGOP_LINK, srcPid, destPid)
        self.handler.passThroughMessage(None, ctrlMessage, None)
        self.assertEqual(destPid._links, set([(None, srcPid)]))


    def test_unlinkNotExisting(self):
        """
        Test handling of an UNLINK token while the link doesn't exit locally.
        """
        srcPid = Pid(Atom("foo@bar"), 0, 0, 0)
        destPid = Pid(Atom("spam@egg"), 0, 0, 0)
        ctrlMessage = (self.handler.CTRLMSGOP_UNLINK, srcPid, destPid)
        self.handler.passThroughMessage(None, ctrlMessage, None)
        self.assertEqual(destPid._links, set([]))


    def test_unlink(self):
        """
        Test handling of an UNLINK token.
        """
        srcPid = Pid(Atom("foo@bar"), 0, 0, 0)
        destPid = Pid(Atom("spam@egg"), 0, 0, 0)
        destPid.link(None, srcPid)
        # Sanity check
        self.assertNotEqual(destPid._links, set([]))

        ctrlMessage = (self.handler.CTRLMSGOP_UNLINK, srcPid, destPid)
        self.handler.passThroughMessage(None, ctrlMessage, None)
        self.assertEqual(destPid._links, set([]))


    def test_nodeLink(self):
        """
        Test handling of a NODE_LINK token.
        """
        self.assertRaises(
            NotImplementedError, self.handler.passThroughMessage, None,
            (self.handler.CTRLMSGOP_NODE_LINK,), None)


    def test_groupLeader(self):
        """
        Test handling of a GROUP_LEADER token.
        """
        self.assertRaises(
            NotImplementedError, self.handler.passThroughMessage, None,
            (self.handler.CTRLMSGOP_GROUP_LEADER,), None)


    def test_exit(self):
        """
        Test handling EXIT token.
        """
        srcPid = Pid(Atom("foo@bar"), 0, 0, 0)
        destPid = Pid(Atom("spam@egg"), 0, 0, 0)
        destPid.link(None, srcPid)
        called = []
        destPid._handlers[srcPid] = [lambda *args: called.append(args)]

        ctrlMessage = (self.handler.CTRLMSGOP_EXIT, srcPid, destPid, "reason")
        self.handler.passThroughMessage(None, ctrlMessage, None)
        self.assertEqual(called, [("reason",)])
        self.assertEqual(destPid._links, set([]))


    def test_exit2(self):
        """
        Test handling of an EXIT2 token.
        """
        srcPid = Pid(Atom("foo@bar"), 0, 0, 0)
        destPid = Pid(Atom("spam@egg"), 0, 0, 0)
        destPid.link(None, srcPid)
        called = []
        destPid._handlers[srcPid] = [lambda *args: called.append(args)]

        ctrlMessage = (self.handler.CTRLMSGOP_EXIT2, srcPid, destPid, "reason")
        self.handler.passThroughMessage(None, ctrlMessage, None)
        self.assertEqual(called, [("reason",)])
        self.assertEqual(destPid._links, set([]))


    def test_exitTT(self):
        """
        Test handling of an EXIT_TT token.
        """
        srcPid = Pid(Atom("foo@bar"), 0, 0, 0)
        destPid = Pid(Atom("spam@egg"), 0, 0, 0)
        destPid.link(None, srcPid)
        called = []
        destPid._handlers[srcPid] = [lambda *args: called.append(args)]

        ctrlMessage = (self.handler.CTRLMSGOP_EXIT_TT, srcPid, destPid,
                       "reason", "TOKEN")
        self.handler.passThroughMessage(None, ctrlMessage, None)
        self.assertEqual(called, [("reason",)])
        self.assertEqual(destPid._links, set([]))


    def test_exit2TT(self):
        """
        Test handling of an EXIT2_TT token.
        """
        srcPid = Pid(Atom("foo@bar"), 0, 0, 0)
        destPid = Pid(Atom("spam@egg"), 0, 0, 0)
        destPid.link(None, srcPid)
        called = []
        destPid._handlers[srcPid] = [lambda *args: called.append(args)]

        ctrlMessage = (self.handler.CTRLMSGOP_EXIT2_TT, srcPid, destPid,
                       "reason", "TOKEN")
        self.handler.passThroughMessage(None, ctrlMessage, None)
        self.assertEqual(called, [("reason",)])
        self.assertEqual(destPid._links, set([]))


    def test_monitorP(self):
        """
        Test handling of a MONITOR_P token.
        """
        srcPid = Pid(Atom("foo@bar"), 0, 0, 0)
        destPid = Pid(Atom("spam@egg"), 0, 0, 0)
        ref = Reference(Atom("spam@egg"), 0, 0)
        ctrlMessage = (self.handler.CTRLMSGOP_MONITOR_P, srcPid, destPid, ref)
        self.handler.passThroughMessage(None, ctrlMessage, None)
        self.assertEqual(destPid._remoteMonitors, set([(None, srcPid, ref)]))


    def test_demonitorPNotExisting(self):
        """
        Test handling of a DEMONITOR_P token while the link doesn't exist
        locally.
        """
        srcPid = Pid(Atom("foo@bar"), 0, 0, 0)
        destPid = Pid(Atom("spam@egg"), 0, 0, 0)
        ref = Reference(Atom("spam@egg"), 0, 0)
        ctrlMessage = (self.handler.CTRLMSGOP_DEMONITOR_P, srcPid, destPid,
                       ref)
        self.handler.passThroughMessage(None, ctrlMessage, None)
        self.assertEqual(destPid._remoteMonitors, set([]))


    def test_demonitorP(self):
        """
        Test handling of a DEMONITOR_P token.
        """
        srcPid = Pid(Atom("foo@bar"), 0, 0, 0)
        destPid = Pid(Atom("spam@egg"), 0, 0, 0)
        ref = Reference(Atom("spam@egg"), 0, 0)
        destPid._remoteMonitor(None, srcPid, ref)
        # Sanity check
        self.assertNotEqual(destPid._remoteMonitors, set([]))

        ctrlMessage = (self.handler.CTRLMSGOP_DEMONITOR_P, srcPid, destPid,
                       ref)
        self.handler.passThroughMessage(None, ctrlMessage, None)
        self.assertEqual(destPid._remoteMonitors, set([]))


    def test_monitorPExit(self):
        """
        Test handling of a MONITOR_P_EXIT token.
        """
        srcPid = Pid(Atom("foo@bar"), 0, 0, 0)
        destPid = Pid(Atom("spam@egg"), 0, 0, 0)
        ref = Reference(Atom("spam@egg"), 0, 0)

        ctrlMessage = (self.handler.CTRLMSGOP_MONITOR_P_EXIT, srcPid, destPid,
                       ref, "reason")
        self.handler.passThroughMessage(None, ctrlMessage, None)


    def test_monitorPExitWithHandler(self):
        """
        Test handling of a MONITOR_P_EXIT token with a registered handler to
        it.
        """
        srcPid = Pid(Atom("foo@bar"), 0, 0, 0)
        destPid = Pid(Atom("spam@egg"), 0, 0, 0)
        ref = Reference(Atom("spam@egg"), 0, 0)

        called = []
        destPid._monitorHandlers[ref] = [lambda *args: called.append(args)]
        ctrlMessage = (self.handler.CTRLMSGOP_MONITOR_P_EXIT, srcPid, destPid,
                       ref, "reason")
        self.handler.passThroughMessage(None, ctrlMessage, None)
        self.assertEqual(called, [("reason",)])


    def test_operationRegSendUnhandled(self):
        """
        Test handling of a REG_SEND token, for an unknown method.
        """
        pid = Pid(Atom("foo@bar"), 0, 0, 0)
        ctrlMessage = (self.handler.CTRLMSGOP_REG_SEND, pid, "cookie",
                       Atom("foo"))
        self.handler.passThroughMessage(None, ctrlMessage, None)


    def test_createPid(self):
        """
        Test L{MessageHandler.createPid}.
        """
        pid = self.handler.createPid()
        self.assertEqual(pid.nodeId, 0)
        self.assertEqual(pid.serial, 0)
        pid = self.handler.createPid()
        self.assertEqual(pid.nodeId, 1)
        self.assertEqual(pid.serial, 0)


    def test_createPidSerialIncrement(self):
        """
        Check that L{MessageHandler.createPid} increments the serial number
        used for pid when the nodeId reaches the 0x7fff value.
        """
        self.handler.pidCount = 0x7fff
        pid = self.handler.createPid()
        self.assertEqual(pid.nodeId, 32767)
        self.assertEqual(pid.serial, 0)

        pid = self.handler.createPid()
        self.assertEqual(pid.nodeId, 0)
        self.assertEqual(pid.serial, 1)


    def test_createPidSerialReset(self):
        """
        Check that L{MessageHandler.createPid} resets the serial number to 0
        when the nodeId reaches the 0x7fff value and the serial value reaches
        the 0x1fff value.
        """
        self.handler.pidCount = 0x7fff
        self.handler.serial = 0x1fff
        pid = self.handler.createPid()
        self.assertEqual(pid.nodeId, 32767)
        self.assertEqual(pid.serial, 8191)

        pid = self.handler.createPid()
        self.assertEqual(pid.nodeId, 0)
        self.assertEqual(pid.serial, 0)


    def test_createPidSerialResetNotExtented(self):
        """
        Check that L{MessageHandler.createPid} resets the serial number to 0
        when the nodeId reaches the 0x7fff value and the serial value reaches
        the 0x7 value and that the protocol distribution flags doesn't specify
        L{DISTR_FLAG_EXTENDEDPIDSPORTS}.
        """
        self.handler.distrFlags -= self.handler.DISTR_FLAG_EXTENDEDPIDSPORTS
        proto = TestableNodeProtocol()
        proto.distrFlags = 0
        self.handler.pidCount = 0x7fff
        self.handler.serial = 0x07
        pid = self.handler.createPid()
        self.assertEqual(pid.nodeId, 32767)
        self.assertEqual(pid.serial, 7)

        pid = self.handler.createPid()
        self.assertEqual(pid.nodeId, 0)
        self.assertEqual(pid.serial, 0)


    def test_createPort(self):
        """
        Test L{MessageHandler.createPort}.
        """
        port = self.handler.createPort()
        self.assertEqual(port.portId, 0)

        port = self.handler.createPort()
        self.assertEqual(port.portId, 1)


    def test_createPortReset(self):
        """
        L{MessageHandler.createPort} resets the port value to 0 when it reaches
        the 0xfffffff value.
        """
        self.handler.portCount = 0xfffffff
        port = self.handler.createPort()
        self.assertEqual(port.portId, 268435455)

        port = self.handler.createPort()
        self.assertEqual(port.portId, 0)


    def test_createPortNotExtended(self):
        """
        Check that L{MessageHandler.createPort} reset the port value to 0 when
        it reaches the 0x3ffff value and that the protocol distribution flags
        doesn't specify L{DISTR_FLAG_EXTENDEDPIDSPORTS}.
        """
        self.handler.distrFlags -= self.handler.DISTR_FLAG_EXTENDEDPIDSPORTS
        proto = TestableNodeProtocol()
        proto.distrFlags = 0
        self.handler.portCount = 0x3ffff
        port = self.handler.createPort()
        self.assertEqual(port.portId, 262143)

        port = self.handler.createPort()
        self.assertEqual(port.portId, 0)