def test_sees_peer(self):
     self.sent = []
     self.neighbors = {}
     self.engine = HelloProtocol(self, self)
     self.engine.handle_hello(MessageHELLO(None, 'R2', []), 2.0, 0, 1)
     self.engine.tick(5.0)
     self.assertEqual(len(self.sent), 1)
     dest, msg = self.sent.pop(0)
     self.assertEqual(msg.seen_peers, ['R2'])
 def test_establish_peer(self):
     self.sent = []
     self.neighbors = {}
     self.engine = HelloProtocol(self, self)
     self.engine.handle_hello(MessageHELLO(None, 'R2', ['R1']), 0.5, 0, 1)
     self.engine.tick(1.0)
     self.engine.tick(2.0)
     self.engine.tick(3.0)
     self.assertEqual(len(self.neighbors), 1)
     self.assertEqual(self.neighbors.keys(), ['R2'])
 def test_hello_sent(self):
     self.sent = []
     self.local_link_state = None
     self.engine = HelloProtocol(self, self)
     self.engine.tick(1.0)
     self.assertEqual(len(self.sent), 1)
     dest, msg = self.sent.pop(0)
     self.assertEqual(dest, "amqp:/_local/qdhello")
     self.assertEqual(msg.get_opcode(), "HELLO")
     self.assertEqual(msg.id, self.id)
     self.assertEqual(msg.seen_peers, [])
     self.assertEqual(self.local_link_state, None)
Example #4
0
 def test_establish_multiple_peers(self):
     self.sent = []
     self.neighbors = {}
     self.engine = HelloProtocol(self, self)
     self.engine.handle_hello(MessageHELLO(None, 'R2', ['R1']), 0.5, 0)
     self.engine.tick(1.0)
     self.engine.handle_hello(MessageHELLO(None, 'R3', ['R1', 'R2']), 1.5, 0)
     self.engine.tick(2.0)
     self.engine.handle_hello(MessageHELLO(None, 'R4', ['R1']), 2.5, 0)
     self.engine.handle_hello(MessageHELLO(None, 'R5', ['R2']), 2.5, 0)
     self.engine.handle_hello(MessageHELLO(None, 'R6', ['R1']), 2.5, 0)
     self.engine.tick(3.0)
     keys = self.neighbors.keys()
     keys.sort()
     self.assertEqual(keys, ['R2', 'R3', 'R4', 'R6'])
 def test_sees_peer(self):
     self.sent = []
     self.neighbors = {}
     self.engine = HelloProtocol(self, self)
     self.engine.handle_hello(MessageHELLO(None, 'R2', []), 2.0, 0, 1)
     self.engine.tick(5.0)
     self.assertEqual(len(self.sent), 1)
     dest, msg = self.sent.pop(0)
     self.assertEqual(msg.seen_peers, ['R2'])
 def test_establish_peer(self):
     self.sent = []
     self.neighbors = {}
     self.engine = HelloProtocol(self, self)
     self.engine.handle_hello(MessageHELLO(None, 'R2', ['R1']), 0.5, 0, 1)
     self.engine.tick(1.0)
     self.engine.tick(2.0)
     self.engine.tick(3.0)
     self.assertEqual(len(self.neighbors), 1)
     self.assertEqual(list(self.neighbors.keys()), ['R2'])
 def test_hello_sent(self):
     self.sent = []
     self.local_link_state = None
     self.engine = HelloProtocol(self, self)
     self.engine.tick(1.0)
     self.assertEqual(len(self.sent), 1)
     dest, msg = self.sent.pop(0)
     self.assertEqual(dest, "amqp:/_local/qdhello")
     self.assertEqual(msg.get_opcode(), "HELLO")
     self.assertEqual(msg.id, self.id)
     self.assertEqual(msg.seen_peers, [])
     self.assertEqual(self.local_link_state, None)
 def test_establish_multiple_peers(self):
     self.sent = []
     self.neighbors = {}
     self.engine = HelloProtocol(self, self)
     self.engine.handle_hello(MessageHELLO(None, 'R2', ['R1']), 0.5, 0, 1)
     self.engine.tick(1.0)
     self.engine.handle_hello(MessageHELLO(None, 'R3', ['R1', 'R2']), 1.5, 0, 1)
     self.engine.tick(2.0)
     self.engine.handle_hello(MessageHELLO(None, 'R4', ['R1']), 2.5, 0, 1)
     self.engine.handle_hello(MessageHELLO(None, 'R5', ['R2']), 2.5, 0, 1)
     self.engine.handle_hello(MessageHELLO(None, 'R6', ['R1']), 2.5, 0, 1)
     self.engine.tick(3.0)
     keys = [k for k in self.neighbors.keys()]
     keys.sort()
     self.assertEqual(keys, ['R2', 'R3', 'R4', 'R6'])
Example #9
0
 def test_establish_multiple_peers(self):
     self.sent = []
     self.neighbors = {}
     self.engine = HelloProtocol(self, self)
     self.engine.handle_hello(MessageHELLO(None, "R2", ["R1"]), 0.5, 0, 1)
     self.engine.tick(1.0)
     self.engine.handle_hello(MessageHELLO(None, "R3", ["R1", "R2"]), 1.5, 0, 1)
     self.engine.tick(2.0)
     self.engine.handle_hello(MessageHELLO(None, "R4", ["R1"]), 2.5, 0, 1)
     self.engine.handle_hello(MessageHELLO(None, "R5", ["R2"]), 2.5, 0, 1)
     self.engine.handle_hello(MessageHELLO(None, "R6", ["R1"]), 2.5, 0, 1)
     self.engine.tick(3.0)
     keys = self.neighbors.keys()
     keys.sort()
     self.assertEqual(keys, ["R2", "R3", "R4", "R6"])
class NeighborTest(unittest.TestCase):
    def log(self, level, text):
        pass

    def log_hello(self, level, text):
        pass

    def send(self, dest, msg):
        self.sent.append((dest, msg))

    def neighbor_refresh(self, node_id, ProtocolVersion, instance, link_id, cost, now):
        self.neighbors[node_id] = (instance, link_id, cost, now)

    def setUp(self):
        self.sent = []
        self.neighbors = {}
        self.id = "R1"
        self.instance = 0
        # Fake configuration
        self.config = EntityBase({
            'helloIntervalSeconds'    :  1.0,
            'helloMaxAgeSeconds'      :  3.0,
            'raIntervalSeconds'       : 30.0,
            'remoteLsMaxAgeSeconds'   : 60.0 })
        self.neighbors = {}

    def test_hello_sent(self):
        self.sent = []
        self.local_link_state = None
        self.engine = HelloProtocol(self, self)
        self.engine.tick(1.0)
        self.assertEqual(len(self.sent), 1)
        dest, msg = self.sent.pop(0)
        self.assertEqual(dest, "amqp:/_local/qdhello")
        self.assertEqual(msg.get_opcode(), "HELLO")
        self.assertEqual(msg.id, self.id)
        self.assertEqual(msg.seen_peers, [])
        self.assertEqual(self.local_link_state, None)

    def test_sees_peer(self):
        self.sent = []
        self.neighbors = {}
        self.engine = HelloProtocol(self, self)
        self.engine.handle_hello(MessageHELLO(None, 'R2', []), 2.0, 0, 1)
        self.engine.tick(5.0)
        self.assertEqual(len(self.sent), 1)
        dest, msg = self.sent.pop(0)
        self.assertEqual(msg.seen_peers, ['R2'])

    def test_establish_peer(self):
        self.sent = []
        self.neighbors = {}
        self.engine = HelloProtocol(self, self)
        self.engine.handle_hello(MessageHELLO(None, 'R2', ['R1']), 0.5, 0, 1)
        self.engine.tick(1.0)
        self.engine.tick(2.0)
        self.engine.tick(3.0)
        self.assertEqual(len(self.neighbors), 1)
        self.assertEqual(list(self.neighbors.keys()), ['R2'])

    def test_establish_multiple_peers(self):
        self.sent = []
        self.neighbors = {}
        self.engine = HelloProtocol(self, self)
        self.engine.handle_hello(MessageHELLO(None, 'R2', ['R1']), 0.5, 0, 1)
        self.engine.tick(1.0)
        self.engine.handle_hello(MessageHELLO(None, 'R3', ['R1', 'R2']), 1.5, 0, 1)
        self.engine.tick(2.0)
        self.engine.handle_hello(MessageHELLO(None, 'R4', ['R1']), 2.5, 0, 1)
        self.engine.handle_hello(MessageHELLO(None, 'R5', ['R2']), 2.5, 0, 1)
        self.engine.handle_hello(MessageHELLO(None, 'R6', ['R1']), 2.5, 0, 1)
        self.engine.tick(3.0)
        keys = [k for k in self.neighbors.keys()]
        keys.sort()
        self.assertEqual(keys, ['R2', 'R3', 'R4', 'R6'])
class NeighborTest(unittest.TestCase):
    def log(self, level, text):
        pass

    def log_hello(self, level, text):
        pass

    def send(self, dest, msg):
        self.sent.append((dest, msg))

    def neighbor_refresh(self, node_id, ProtocolVersion, instance, link_id,
                         cost, now):
        self.neighbors[node_id] = (instance, link_id, cost, now)

    def setUp(self):
        self.sent = []
        self.neighbors = {}
        self.id = "R1"
        self.instance = 0
        # Fake configuration
        self.config = EntityBase({
            'helloInterval': 1.0,
            'helloMaxAge': 3.0,
            'raInterval': 30.0,
            'remoteLsMaxAge': 60.0
        })
        self.neighbors = {}

    def test_hello_sent(self):
        self.sent = []
        self.local_link_state = None
        self.engine = HelloProtocol(self, self)
        self.engine.tick(1.0)
        self.assertEqual(len(self.sent), 1)
        dest, msg = self.sent.pop(0)
        self.assertEqual(dest, "amqp:/_local/qdhello")
        self.assertEqual(msg.get_opcode(), "HELLO")
        self.assertEqual(msg.id, self.id)
        self.assertEqual(msg.seen_peers, [])
        self.assertEqual(self.local_link_state, None)

    def test_sees_peer(self):
        self.sent = []
        self.neighbors = {}
        self.engine = HelloProtocol(self, self)
        self.engine.handle_hello(MessageHELLO(None, 'R2', []), 2.0, 0, 1)
        self.engine.tick(5.0)
        self.assertEqual(len(self.sent), 1)
        dest, msg = self.sent.pop(0)
        self.assertEqual(msg.seen_peers, ['R2'])

    def test_establish_peer(self):
        self.sent = []
        self.neighbors = {}
        self.engine = HelloProtocol(self, self)
        self.engine.handle_hello(MessageHELLO(None, 'R2', ['R1']), 0.5, 0, 1)
        self.engine.tick(1.0)
        self.engine.tick(2.0)
        self.engine.tick(3.0)
        self.assertEqual(len(self.neighbors), 1)
        self.assertEqual(self.neighbors.keys(), ['R2'])

    def test_establish_multiple_peers(self):
        self.sent = []
        self.neighbors = {}
        self.engine = HelloProtocol(self, self)
        self.engine.handle_hello(MessageHELLO(None, 'R2', ['R1']), 0.5, 0, 1)
        self.engine.tick(1.0)
        self.engine.handle_hello(MessageHELLO(None, 'R3', ['R1', 'R2']), 1.5,
                                 0, 1)
        self.engine.tick(2.0)
        self.engine.handle_hello(MessageHELLO(None, 'R4', ['R1']), 2.5, 0, 1)
        self.engine.handle_hello(MessageHELLO(None, 'R5', ['R2']), 2.5, 0, 1)
        self.engine.handle_hello(MessageHELLO(None, 'R6', ['R1']), 2.5, 0, 1)
        self.engine.tick(3.0)
        keys = self.neighbors.keys()
        keys.sort()
        self.assertEqual(keys, ['R2', 'R3', 'R4', 'R6'])
Example #12
0
class NeighborTest(unittest.TestCase):
    def log(self, level, text):
        pass

    def log_hello(self, level, text):
        pass

    def send(self, dest, msg):
        self.sent.append((dest, msg))

    def neighbor_refresh(self, node_id, instance, link_id, cost, now):
        self.neighbors[node_id] = (instance, link_id, cost, now)

    def setUp(self):
        self.sent = []
        self.neighbors = {}
        self.id = "R1"
        self.instance = 0
        # Fake configuration
        self.config = EntityBase(
            {
                "helloInterval": 1.0,
                "helloMaxAge": 3.0,
                "raInterval": 30.0,
                "remoteLsMaxAge": 60.0,
                "mobileAddrMaxAge": 60.0,
            }
        )
        self.neighbors = {}

    def test_hello_sent(self):
        self.sent = []
        self.local_link_state = None
        self.engine = HelloProtocol(self, self)
        self.engine.tick(0.5)
        self.assertEqual(self.sent, [])
        self.engine.tick(1.5)
        self.assertEqual(len(self.sent), 1)
        dest, msg = self.sent.pop(0)
        self.assertEqual(dest, "amqp:/_local/qdhello")
        self.assertEqual(msg.get_opcode(), "HELLO")
        self.assertEqual(msg.id, self.id)
        self.assertEqual(msg.seen_peers, [])
        self.assertEqual(self.local_link_state, None)

    def test_sees_peer(self):
        self.sent = []
        self.neighbors = {}
        self.engine = HelloProtocol(self, self)
        self.engine.handle_hello(MessageHELLO(None, "R2", []), 2.0, 0, 1)
        self.engine.tick(5.0)
        self.assertEqual(len(self.sent), 1)
        dest, msg = self.sent.pop(0)
        self.assertEqual(msg.seen_peers, ["R2"])

    def test_establish_peer(self):
        self.sent = []
        self.neighbors = {}
        self.engine = HelloProtocol(self, self)
        self.engine.handle_hello(MessageHELLO(None, "R2", ["R1"]), 0.5, 0, 1)
        self.engine.tick(1.0)
        self.engine.tick(2.0)
        self.engine.tick(3.0)
        self.assertEqual(len(self.neighbors), 1)
        self.assertEqual(self.neighbors.keys(), ["R2"])

    def test_establish_multiple_peers(self):
        self.sent = []
        self.neighbors = {}
        self.engine = HelloProtocol(self, self)
        self.engine.handle_hello(MessageHELLO(None, "R2", ["R1"]), 0.5, 0, 1)
        self.engine.tick(1.0)
        self.engine.handle_hello(MessageHELLO(None, "R3", ["R1", "R2"]), 1.5, 0, 1)
        self.engine.tick(2.0)
        self.engine.handle_hello(MessageHELLO(None, "R4", ["R1"]), 2.5, 0, 1)
        self.engine.handle_hello(MessageHELLO(None, "R5", ["R2"]), 2.5, 0, 1)
        self.engine.handle_hello(MessageHELLO(None, "R6", ["R1"]), 2.5, 0, 1)
        self.engine.tick(3.0)
        keys = self.neighbors.keys()
        keys.sort()
        self.assertEqual(keys, ["R2", "R3", "R4", "R6"])