def test_guid_in_range(self):
range_min, range_max = 2, 16
bucket = self.kbucket_class(range_min, range_max)
low_out, low_in, mid, high_in, high_out = (
range_min - 1, range_min, range_min + (range_max - range_min) // 2,
range_max - 1, range_max)
for num in (low_in, mid, high_in):
self.assertTrue(bucket.guid_in_range(util.num_to_guid(num)))
for num in (low_out, high_out):
self.assertFalse(bucket.guid_in_range(util.num_to_guid(num)))
def test_guid_in_range(self):
range_min, range_max = 2, 16
bucket = self.kbucket_class(range_min, range_max)
low_out, low_in, mid, high_in, high_out = (
range_min - 1,
range_min,
range_min + (range_max - range_min) // 2,
range_max - 1,
range_max
)
for num in (low_in, mid, high_in):
self.assertTrue(bucket.guid_in_range(util.num_to_guid(num)))
for num in (low_out, high_out):
self.assertFalse(bucket.guid_in_range(util.num_to_guid(num)))
def test_remove_absent_guid(self):
absent_guid = util.num_to_guid(self.range_max - 1)
# Removing an absent guid shouldn't raise an error.
try:
self.rt.remove_guid(absent_guid)
except Exception:
self.fail('RoutingTable crashed on removing absent contact.')
def setUpClass(cls):
cls.range_min = 0
cls.range_max = 2**constants.BIT_NODE_ID_LEN
cls.own_num_guid = 1
cls.own_guid = util.num_to_guid(cls.own_num_guid)
cls.bad_guid = 'f' * (constants.HEX_NODE_ID_LEN + 1)
cls.bad_contact = contact.Contact('123.45.67.89', 12345, cls.bad_guid)
def test_num_to_guid(self):
test_tuples = ((0, '0000000000000000000000000000000000000000'),
(42, '000000000000000000000000000000000000002a'),
(2**constants.BIT_NODE_ID_LEN - 1,
'ffffffffffffffffffffffffffffffffffffffff'))
for num, guid in test_tuples:
self.assertEqual(util.num_to_guid(num), guid)
def test_get_contacts_excluding_absent(self):
bucket = self._make_kbucket(constants.K)
absent_guid = util.num_to_guid(self.range_max - 1)
try:
rest_contacts = bucket.get_contacts(excluded_guid=absent_guid)
except Exception:
self.fail('Crashed while excluding contact absent from bucket.')
else:
self.assertEqual(len(rest_contacts), len(bucket))
def test_get_contacts_excluding_absent(self):
bucket = self._make_kbucket(constants.K)
absent_guid = util.num_to_guid(self.range_max - 1)
try:
rest_contacts = bucket.get_contacts(excluded_guid=absent_guid)
except Exception:
self.fail('Crashed while excluding contact absent from bucket.')
else:
self.assertEqual(len(rest_contacts), len(bucket))
def test_num_to_guid(self):
test_tuples = (
(0, '0000000000000000000000000000000000000000'),
(42, '000000000000000000000000000000000000002a'),
(
2**constants.BIT_NODE_ID_LEN - 1,
'ffffffffffffffffffffffffffffffffffffffff'
)
)
for num, guid in test_tuples:
self.assertEqual(util.num_to_guid(num), guid)
def test_find_close_nodes_except_sender_guid(self):
rt = self._make_rt_with_n_buckets(3)
sender_num_guid = rt[0].range_min
sender_contact = self._make_contact_from_num(sender_num_guid)
rt.add_contact(sender_contact)
self.assertIn(sender_contact, rt[0])
r_guid = util.num_to_guid(sender_num_guid + 1)
node_list = rt.find_close_nodes(
r_guid,
sender_guid=sender_contact.guid
)
self.assertEqual(len(node_list), constants.K)
self.assertNotIn(sender_contact, node_list)
def test_add_new_contact_and_cache(self):
# Add K + 1 contacts to initial KBucket, to force a split.
base = util.guid_to_num(self.own_guid) + 1
for i in range(constants.K):
self.rt.add_contact(
self._make_contact_from_num(base + i)
)
self.rt.add_contact(self._make_contact_from_num(self.range_max - 1))
# Create a guid that is at maximal distance from own_guid,
# thus must be at a different bucket.
self.assertEqual(len(self.rt), 2)
max_base = (2**constants.BIT_NODE_ID_LEN - 1) ^ self.own_num_guid
self.assertTrue(self.rt[0].guid_in_range(self.own_guid))
self.assertTrue(self.rt[1].guid_in_range(util.num_to_guid(max_base)))
# Add contacts to the other KBucket, until it is full.
for i in range(constants.K):
if len(self.rt[1]) == constants.K:
break
self.rt.add_contact(
self._make_contact_from_num(max_base - i)
)
# Create and add a contact that is in the range of the other
# KBucket.
new_contact = self._make_contact_from_num(max_base - constants.K)
self.rt.add_contact(new_contact)
self.assertEqual(
len(self.rt),
2,
'A KBucket not containing own_guid was split.'
)
# Assert the new contact was cached properly.
self.assertNotIn(new_contact, self.rt[0])
self.assertNotIn(new_contact, self.rt[1])
self.assertEqual([], self.rt[0].get_cached_contacts())
self.assertEqual([new_contact], self.rt[1].get_cached_contacts())
def test_get_contact_updates_timestamp(self):
self.bucket.last_accessed = 1
self.bucket.get_contact(util.num_to_guid(self.range_min))
self.assertFalse(self.bucket.is_stale())
def _make_contact_from_num(i):
return contact.Contact('123.45.67.89', 12345, util.num_to_guid(i))
def test_remove_guid_updates_timestamp(self):
self.bucket.last_accessed = 1
self.bucket.remove_guid(util.num_to_guid(self.range_min))
self.assertFalse(self.bucket.is_stale())
def test_get_absent_contact(self):
new_guid = util.num_to_guid(self.range_max - 1)
self.assertIsNone(self.rt.get_contact(new_guid))
def test_get_contact_updates_timestamp(self):
self.bucket.last_accessed = 1
self.bucket.get_contact(util.num_to_guid(self.range_min))
self.assertFalse(self.bucket.is_stale())
def test_get_absent_contact(self):
absent_guid = util.num_to_guid(self.range_max - 2)
self.assertIsNone(self.bucket.get_contact(absent_guid),
'Nonexistent contact found.')
def test_get_absent_contact(self):
absent_guid = util.num_to_guid(self.range_max - 2)
self.assertIsNone(
self.bucket.get_contact(absent_guid),
'Nonexistent contact found.'
)
def test_remove_guid_updates_timestamp(self):
self.bucket.last_accessed = 1
self.bucket.remove_guid(util.num_to_guid(self.range_min))
self.assertFalse(self.bucket.is_stale())
