def _assert_address(self, name, expected, exp_ttl = 300):
yield common.delay(None, 0.1)
for dns_medium in self.driver.iter_agents("dns_agent"):
dns_agent = dns_medium.get_agent()
result = yield dns_agent.lookup_address(name, "127.0.0.1")
for ip, ttl in result:
self.assertEqual(exp_ttl, ttl)
self.assertEqual(set(expected),
set([ip for ip, _ttl in result]))
def testJoinCreatesConnectionAgents(self):
self.assertEqual(0, self.count_agents('connection_agent'))
# join to the room, this should create connection_agent
res = yield self.room.generate_join_url()
self.assertTrue('session_id' in res)
self.assertTrue('url' in res)
self.assertEqual(1, self.count_agents('connection_agent'))
# get the list for the room
llist = yield self.room.get_list()
self.assertTrue(res['session_id'] in llist)
# check state of connection agent
connection = first(
self.driver.iter_agents('connection_agent')).get_agent()
pc = connection.get_pending_connections()
self.assertTrue(res['session_id'] in pc)
# now wait for this connection attempt to expire
yield common.delay(None, 11)
pc = connection.get_pending_connections()
self.assertFalse(res['session_id'] in pc)
# now do the same 3 times do check that another agent is spawned
for x in range(3):
res = yield self.room.generate_join_url()
self.assertTrue('session_id' in res)
self.assertTrue('url' in res)
self.assertEqual(2, self.count_agents('connection_agent'))
# get the list for the room
llist = yield self.room.get_list()
self.assertEqual(3, len(llist))
# now wait for all connections attempts to expire, get the list
# which should be empty and assert that we are down to single
# connection agent
yield common.delay(None, 11)
llist = yield self.room.get_list()
yield self.wait_for_idle(10)
self.assertEqual(0, len(llist))
self.assertEqual(1, self.count_agents('connection_agent'))
def testMultipleReconnects(self):
def wait_for_msgs():
return defer.DeferredList(map(
lambda ag: self.cb_after(None, ag, 'on_message'),
self.agents))
def send_to_neighbour(attempt):
total = len(self.connections)
deferrs = list()
for conn, i in zip(self.connections, range(total)):
target = (i + 1) % total
msg = "%s,%s" % (attempt, target, )
d = conn.post(self._agent(target), m(msg))
deferrs.append(d)
return defer.DeferredList(deferrs)
def asserts(attempt):
for agent in self.agents:
self.assertEqual(attempt, len(agent.messages))
self.assertTrue(
unwrap(agent.messages[-1]).startswith("%s," % attempt))
number_of_reconnections = 5
mock = self.setup_receiver()
yield self.process.rabbitmqctl_dump('list_bindings')
for index in range(1, number_of_reconnections + 1):
d = wait_for_msgs()
yield send_to_neighbour(index)
self.log('Reconnecting %d time out of %d.',
index, number_of_reconnections)
yield self.disconnect_client()
yield common.delay(None, 0.1)
self.assertCalled(mock, 'on_disconnect', times=index)
self.assertCalled(mock, 'on_connect', times=index-1)
yield self.process.rabbitmqctl_dump(
'list_queues name messages '
'messages_ready consumers')
yield d
yield self.process.rabbitmqctl_dump(
'list_queues name messages')
asserts(index)
def testReconnect(self):
mock = self.setup_receiver()
d1 = self.cb_after(None, self.agents[0], "on_message")
yield self.connections[1].post(self._agent(0), m("first message"))
yield d1
yield self.disconnect_client()
yield common.delay(None, 0.1)
self.assertCalled(mock, 'on_disconnect', times=1)
d2 = self.cb_after(None, self.agents[0], "on_message")
yield self.connections[1].post(self._agent(0), m("second message"))
yield d2
self.assertEqual(2, len(self.agents[0].messages))
self.assertEqual("first message", unwrap(self.agents[0].messages[0]))
self.assertEqual("second message", unwrap(self.agents[0].messages[1]))
self.assertCalled(mock, 'on_connect', times=1)
def testReceivingNotifications(self):
yield self.agent.register()
yield self.agent.do_change()
yield self.wait_for(self.agent.len_changes(1), 1, 0.02)
self.assert_last_change(deleted=False, own=True)
doc = yield self.driver.get_document('some_doc')
doc.counter = 5
doc = yield self.driver.save_document(doc)
yield self.wait_for(self.agent.len_changes(2), 1, 0.02)
self.assert_last_change(deleted=False, own=False)
yield self.agent.cancel()
yield self.driver.delete_document(doc)
yield common.delay(None, 0.1)
self.assertEqual(2, len(self.agent.get_changes()))
yield self.agent.register()
def _assert_alias(self, name, expected, exp_ttl = 300):
yield common.delay(None, 0.1)
for dns_medium in self.driver.iter_agents("dns_agent"):
dns_agent = dns_medium.get_agent()
alias, _ = yield dns_agent.lookup_alias(name)
self.assertEqual(expected, alias)
