def test_key_in_range_no_too_high(self):
"""
Ensures a key just above the k-bucket's range is identified as out of
range.
"""
bucket = Bucket(1, 5)
self.assertFalse(bucket.key_in_range('7'))
def test_key_in_range_no_too_low(self):
"""
Ensures a key just below the k-bucket's range is identified as out of
range.
"""
bucket = Bucket(5, 9)
self.assertFalse(bucket.key_in_range('2'))
def test_key_in_range_no_too_low(self):
"""
Ensures a key just below the k-bucket's range is identified as out of
range.
"""
bucket = Bucket(5, 9)
self.assertFalse(bucket.key_in_range('2'))
def test_key_in_range_no_too_high(self):
"""
Ensures a key just above the k-bucket's range is identified as out of
range.
"""
bucket = Bucket(1, 5)
self.assertFalse(bucket.key_in_range('7'))
def test_get_contacts_empty(self):
"""
If the k-bucket is empty, the result of getContacts is an empty list.
"""
range_min = 12345
range_max = 98765
bucket = Bucket(range_min, range_max)
result = bucket.get_contacts()
self.assertEqual(0, len(result))
def test_get_contacts_empty(self):
"""
If the k-bucket is empty, the result of getContacts is an empty list.
"""
range_min = 12345
range_max = 98765
bucket = Bucket(range_min, range_max)
result = bucket.get_contacts()
self.assertEqual(0, len(result))
def test_len(self):
"""
Ensures the number of nodes in the k-bucket is returned by __len__.
"""
range_min = 12345
range_max = 98765
bucket = Bucket(range_min, range_max)
contact = PeerNode("12345", "192.168.0.2", 8888, 123)
bucket.add_contact(contact)
self.assertEqual(1, len(bucket))
def test_len(self):
"""
Ensures the number of nodes in the k-bucket is returned by __len__.
"""
range_min = 12345
range_max = 98765
bucket = Bucket(range_min, range_max)
contact = PeerNode("12345", "192.168.0.2", 8888, 123)
bucket.add_contact(contact)
self.assertEqual(1, len(bucket))
def test_get_contacts_all(self):
"""
Ensures get_contacts works as expected.
"""
range_min = 12345
range_max = 98765
bucket = Bucket(range_min, range_max)
for i in range(K):
contact = PeerNode("%d" % i, "192.168.0.%d" % i, 9999, 123)
bucket.add_contact(contact)
result = bucket.get_contacts()
self.assertEqual(20, len(result))
def test_get_contacts_all(self):
"""
Ensures get_contacts works as expected.
"""
range_min = 12345
range_max = 98765
bucket = Bucket(range_min, range_max)
for i in range(K):
contact = PeerNode("%d" % i, "192.168.0.%d" % i, 9999, 123)
bucket.add_contact(contact)
result = bucket.get_contacts()
self.assertEqual(20, len(result))
def test_remove_contact_with_bad_id(self):
"""
Ensures a ValueError exception is raised if one attempts to remove a
non-existent contact from a k-bucket.
"""
range_min = 12345
range_max = 98765
bucket = Bucket(range_min, range_max)
contact = PeerNode("12345", "192.168.0.2", 8888, 123)
bucket.add_contact(contact)
with self.assertRaises(ValueError):
bucket.remove_contact("54321")
def test_split_bucket_cache_update(self):
"""
Ensures that if there are cached contacts for the split bucket then
the two new buckets are topped up, the old cache is removed and two
new caches created (one for each of the new buckets).
"""
parent_node_id = 'deadbeef'
r = RoutingTable(parent_node_id)
bucket = Bucket(0, 100)
contact1 = PeerNode(PUBLIC_KEY, '192.168.0.1', 9999, 0)
contact1.network_id = hex(20)
bucket.add_contact(contact1)
contact2 = PeerNode(PUBLIC_KEY, '192.168.0.2', 8888, 0)
contact2.network_id = hex(40)
bucket.add_contact(contact2)
contact3 = PeerNode(PUBLIC_KEY, '192.168.0.3', 8888, 0)
contact3.network_id = hex(60)
bucket.add_contact(contact3)
contact4 = PeerNode(PUBLIC_KEY, '192.168.0.4', 8888, 0)
contact4.network_id = hex(80)
bucket.add_contact(contact4)
r._buckets[0] = bucket
# Add two items to the cache.
cache = []
cache_contact1 = PeerNode(PUBLIC_KEY, '192.168.0.5', 8888, 0)
cache_contact1.network_id = hex(10)
cache.append(cache_contact1)
cache_contact2 = PeerNode(PUBLIC_KEY, '192.168.0.6', 8888, 0)
cache_contact2.network_id = hex(70)
cache.append(cache_contact2)
r._replacement_cache = {
(0, 100): cache
}
# Two buckets!
r._split_bucket(0)
self.assertEqual(2, len(r._buckets))
bucket1 = r._buckets[0]
bucket2 = r._buckets[1]
# Ensure the right number of contacts are in each bucket in the correct
# order (most recently added at the head of the list).
self.assertEqual(3, len(bucket1._contacts))
self.assertEqual(3, len(bucket2._contacts))
self.assertEqual(contact1, bucket1._contacts[0])
self.assertEqual(contact2, bucket1._contacts[1])
self.assertEqual(cache_contact1, bucket1._contacts[2])
self.assertEqual(contact3, bucket2._contacts[0])
self.assertEqual(contact4, bucket2._contacts[1])
self.assertEqual(cache_contact2, bucket2._contacts[2])
# Ensure the _replacement_cache is in the expected state.
self.assertEqual(2, len(r._replacement_cache))
self.assertNotIn((0, 100), r._replacement_cache)
self.assertIn((0, 50), r._replacement_cache)
self.assertIn((50, 100), r._replacement_cache)
def test_get_contact_with_bad_id(self):
"""
Ensures a ValueError exception is raised if one attempts to get a
contact from the k-bucket with an id that doesn't exist in the
k-bucket.
"""
range_min = 12345
range_max = 98765
bucket = Bucket(range_min, range_max)
contact = PeerNode("12345", "192.168.0.2", 8888, 123)
bucket.add_contact(contact)
with self.assertRaises(ValueError):
bucket.get_contact("54321")
def test_get_contacts_count_too_big(self):
"""
If the "count" argument is bigger than the number of contacts in the
bucket then all the contacts are returned.
"""
range_min = 12345
range_max = 98765
bucket = Bucket(range_min, range_max)
for i in range(10):
contact = PeerNode("%d" % i, "192.168.0.%d" % i, 9999, 123)
bucket.add_contact(contact)
result = bucket.get_contacts(count=20)
self.assertEqual(10, len(result))
def test_get_contacts_count_too_big(self):
"""
If the "count" argument is bigger than the number of contacts in the
bucket then all the contacts are returned.
"""
range_min = 12345
range_max = 98765
bucket = Bucket(range_min, range_max)
for i in range(10):
contact = PeerNode("%d" % i, "192.168.0.%d" % i, 9999, 123)
bucket.add_contact(contact)
result = bucket.get_contacts(count=20)
self.assertEqual(10, len(result))
def test_add_contact_to_full_bucket(self):
"""
Ensures that if one attempts to add a contact to a bucket whose size is
greater than the constant K, then the BucketFull exception is raised.
"""
range_min = 12345
range_max = 98765
bucket = Bucket(range_min, range_max)
for i in range(K):
contact = PeerNode("%d" % i, "192.168.0.%d" % i, 9999, 123)
bucket.add_contact(contact)
with self.assertRaises(BucketFull):
contact_too_many = PeerNode("12345", "192.168.0.2", 8888, 123)
bucket.add_contact(contact_too_many)
def test_get_contacts_with_exclusion(self):
"""
If a contact is passed as the excludeContact argument then it won't be
in the result list.
"""
range_min = 12345
range_max = 98765
bucket = Bucket(range_min, range_max)
for i in range(K):
contact = PeerNode("%d" % i, "192.168.0.%d" % i, 9999, 123)
bucket.add_contact(contact)
result = bucket.get_contacts(count=20, exclude_contact=contact)
self.assertEqual(19, len(result))
self.assertFalse(contact in result)
def test_get_contacts_with_exclusion(self):
"""
If a contact is passed as the excludeContact argument then it won't be
in the result list.
"""
range_min = 12345
range_max = 98765
bucket = Bucket(range_min, range_max)
for i in range(K):
contact = PeerNode("%d" % i, "192.168.0.%d" % i, 9999, 123)
bucket.add_contact(contact)
result = bucket.get_contacts(count=20, exclude_contact=contact)
self.assertEqual(19, len(result))
self.assertFalse(contact in result)
def test_get_contact(self):
"""
Ensures it is possible to get a contact from the k-bucket with a valid
id.
"""
range_min = 12345
range_max = 98765
bucket = Bucket(range_min, range_max)
for i in range(K):
contact = PeerNode(PUBLIC_KEY, "192.168.0.%d" % i, 9999, 123)
contact.network_id = hex(i)
bucket.add_contact(contact)
for i in range(K):
self.assertTrue(bucket.get_contact(hex(i)),
"Could not get contact with id %d" % i)
def test_get_contact(self):
"""
Ensures it is possible to get a contact from the k-bucket with a valid
id.
"""
range_min = 12345
range_max = 98765
bucket = Bucket(range_min, range_max)
for i in range(K):
contact = PeerNode(PUBLIC_KEY, "192.168.0.%d" % i, 9999, 123)
contact.network_id = hex(i)
bucket.add_contact(contact)
for i in range(K):
self.assertTrue(bucket.get_contact(hex(i)),
"Could not get contact with id %d" % i)
def test_remove_contact(self):
"""
Ensures it is possible to remove a contact with a certain ID from the
k-bucket.
"""
range_min = 12345
range_max = 98765
bucket = Bucket(range_min, range_max)
for i in range(K):
contact = PeerNode(PUBLIC_KEY, "192.168.0.%d" % i, 9999, 123)
contact.network_id = hex(i)
bucket.add_contact(contact)
for i in range(K):
bucket.remove_contact(hex(i))
self.assertFalse(hex(i) in bucket._contacts,
"Could not remove contact with id %s" % hex(i))
def test_random_key_in_bucket_range(self):
"""
Ensures the returned key is within the expected bucket range.
"""
parent_node_id = 'deadbeef'
r = RoutingTable(parent_node_id)
bucket = Bucket(1, 2)
r._buckets[0] = bucket
expected = 1
actual = int(r._random_key_in_bucket_range(0), 0)
self.assertEqual(expected, actual)
def test_add_existing_contact(self):
"""
Ensures that if an existing contact is re-added to the kbucket it is
simply moved to the end of the _contacts list (as specified in the
original Kademlia paper) signifying that it is the most recently seen
contact within this bucket.
"""
range_min = 12345
range_max = 98765
bucket = Bucket(range_min, range_max)
contact1 = PeerNode("1", "192.168.0.1", 9999, 123)
bucket.add_contact(contact1)
contact2 = PeerNode("2", "192.168.0.2", 8888, 123)
bucket.add_contact(contact2)
bucket.add_contact(contact1)
# There should still only be two contacts in the bucket.
self.assertEqual(2, len(bucket._contacts),
"Too many contacts in the k-bucket.")
# The end contact should be the most recently added contact.
self.assertEqual(contact1, bucket._contacts[-1:][0],
"The expected most recent contact is wrong.")
def test_add_new_contact(self):
"""
Ensures that a new contact, when added to the kbucket is appended to
the end of the _contacts list (as specified in the original Kademlia
paper) signifying that it is the most recently seen contact within
this bucket.
"""
range_min = 12345
range_max = 98765
bucket = Bucket(range_min, range_max)
contact1 = PeerNode(PUBLIC_KEY, "192.168.0.1", 9999, 123)
contact1.network_id = hex(1)
bucket.add_contact(contact1)
self.assertEqual(1, len(bucket._contacts),
"Single contact not added to k-bucket.")
contact2 = PeerNode(PUBLIC_KEY, "192.168.0.2", 8888, 123)
contact2.network_id = hex(2)
bucket.add_contact(contact2)
self.assertEqual(2, len(bucket._contacts),
"K-bucket's contact list not the expected length.")
self.assertEqual(contact2, bucket._contacts[-1:][0],
"K-bucket's most recent (last) contact wrong.")
def test_init(self):
"""
Ensures an object is created as expected.
"""
range_min = 12345
range_max = 98765
bucket = Bucket(range_min, range_max)
# Min/Max are set correctly
self.assertEqual(range_min, bucket.range_min,
"Bucket rangeMin not set correctly.")
self.assertEqual(range_max, bucket.range_max,
"Bucket rangeMax not initialised correctly.")
# The contacts list exists and is empty
self.assertEqual([], bucket._contacts,
"Bucket contact list not initialised correctly.")
# Last access timestamp is correct
self.assertEqual(0, bucket.last_accessed)
def test_remove_contact_with_bad_id(self):
"""
Ensures a ValueError exception is raised if one attempts to remove a
non-existent contact from a k-bucket.
"""
range_min = 12345
range_max = 98765
bucket = Bucket(range_min, range_max)
contact = PeerNode("12345", "192.168.0.2", 8888, 123)
bucket.add_contact(contact)
with self.assertRaises(ValueError):
bucket.remove_contact("54321")
def test_get_contact_with_bad_id(self):
"""
Ensures a ValueError exception is raised if one attempts to get a
contact from the k-bucket with an id that doesn't exist in the
k-bucket.
"""
range_min = 12345
range_max = 98765
bucket = Bucket(range_min, range_max)
contact = PeerNode("12345", "192.168.0.2", 8888, 123)
bucket.add_contact(contact)
with self.assertRaises(ValueError):
bucket.get_contact("54321")
def test_add_contact_to_full_bucket(self):
"""
Ensures that if one attempts to add a contact to a bucket whose size is
greater than the constant K, then the BucketFull exception is raised.
"""
range_min = 12345
range_max = 98765
bucket = Bucket(range_min, range_max)
for i in range(K):
contact = PeerNode("%d" % i, "192.168.0.%d" % i, 9999, 123)
bucket.add_contact(contact)
with self.assertRaises(BucketFull):
contact_too_many = PeerNode("12345", "192.168.0.2", 8888, 123)
bucket.add_contact(contact_too_many)
def test_get_refresh_list(self):
"""
Ensures that only keys from stale k-buckets are returned.
"""
parent_node_id = 'deadbeef'
r = RoutingTable(parent_node_id)
bucket1 = Bucket(1, 2)
# Set the lastAccessed flag on bucket 1 to be out of date
bucket1.last_accessed = time.time() - 3700
r._buckets[0] = bucket1
bucket2 = Bucket(2, 3)
bucket2.last_accessed = time.time()
r._buckets.append(bucket2)
expected = 1
result = r.get_refresh_list(0)
self.assertEqual(1, len(result))
self.assertEqual(expected, int(result[0], 0))
def test_remove_contact(self):
"""
Ensures it is possible to remove a contact with a certain ID from the
k-bucket.
"""
range_min = 12345
range_max = 98765
bucket = Bucket(range_min, range_max)
for i in range(K):
contact = PeerNode(PUBLIC_KEY, "192.168.0.%d" % i, 9999, 123)
contact.network_id = hex(i)
bucket.add_contact(contact)
for i in range(K):
bucket.remove_contact(hex(i))
self.assertFalse(
hex(i) in bucket._contacts,
"Could not remove contact with id %s" % hex(i))
def test_get_forced_refresh_list(self):
"""
Ensures that keys from all k-buckets (no matter if they're stale or
not) are returned.
"""
parent_node_id = 'deadbeef'
r = RoutingTable(parent_node_id)
bucket1 = Bucket(1, 2)
# Set the lastAccessed flag on bucket 1 to be out of date
bucket1.last_accessed = time.time() - 3700
r._buckets[0] = bucket1
bucket2 = Bucket(2, 3)
bucket2.last_accessed = time.time()
r._buckets.append(bucket2)
result = r.get_refresh_list(0, True)
# Even though bucket 2 is not stale it still has a key for it in
# the result.
self.assertEqual(2, len(result))
self.assertEqual(1, int(result[0], 0))
self.assertEqual(2, int(result[1], 0))
def test_add_existing_contact(self):
"""
Ensures that if an existing contact is re-added to the kbucket it is
simply moved to the end of the _contacts list (as specified in the
original Kademlia paper) signifying that it is the most recently seen
contact within this bucket.
"""
range_min = 12345
range_max = 98765
bucket = Bucket(range_min, range_max)
contact1 = PeerNode("1", "192.168.0.1", 9999, 123)
bucket.add_contact(contact1)
contact2 = PeerNode("2", "192.168.0.2", 8888, 123)
bucket.add_contact(contact2)
bucket.add_contact(contact1)
# There should still only be two contacts in the bucket.
self.assertEqual(2, len(bucket._contacts),
"Too many contacts in the k-bucket.")
# The end contact should be the most recently added contact.
self.assertEqual(contact1, bucket._contacts[-1:][0],
"The expected most recent contact is wrong.")
def test_add_new_contact(self):
"""
Ensures that a new contact, when added to the kbucket is appended to
the end of the _contacts list (as specified in the original Kademlia
paper) signifying that it is the most recently seen contact within
this bucket.
"""
range_min = 12345
range_max = 98765
bucket = Bucket(range_min, range_max)
contact1 = PeerNode(PUBLIC_KEY, "192.168.0.1", 9999, 123)
contact1.network_id = hex(1)
bucket.add_contact(contact1)
self.assertEqual(1, len(bucket._contacts),
"Single contact not added to k-bucket.")
contact2 = PeerNode(PUBLIC_KEY, "192.168.0.2", 8888, 123)
contact2.network_id = hex(2)
bucket.add_contact(contact2)
self.assertEqual(2, len(bucket._contacts),
"K-bucket's contact list not the expected length.")
self.assertEqual(contact2, bucket._contacts[-1:][0],
"K-bucket's most recent (last) contact wrong.")
def test_split_bucket_cache_too_full(self):
"""
If the split occurs and there are too many contacts and cached
contacts for a new bucket, the remainder or cached contacts are added
to the cache for the new bucket.
"""
parent_node_id = 'deadbeef'
r = RoutingTable(parent_node_id)
bucket = Bucket(0, 100)
low_contacts = []
high_contacts = []
for i in range(10):
contact = PeerNode(PUBLIC_KEY, '192.168.0.1', 9999, 0)
contact.network_id = hex(i)
bucket.add_contact(contact)
low_contacts.append(contact)
for i in range(50, 60):
contact = PeerNode(PUBLIC_KEY, '192.168.0.1', 9999, 0)
contact.network_id = hex(i)
bucket.add_contact(contact)
high_contacts.append(contact)
r._buckets[0] = bucket
# Add items to the cache.
cache = []
low_cache = []
high_cache = []
for i in range(10, 30):
contact = PeerNode(PUBLIC_KEY, '192.168.0.1', 9999, 0)
contact.network_id = hex(i)
cache.append(contact)
low_cache.append(contact)
for i in range(60, 80):
contact = PeerNode(PUBLIC_KEY, '192.168.0.1', 9999, 0)
contact.network_id = hex(i)
cache.append(contact)
high_cache.append(contact)
r._replacement_cache = {
(0, 100): cache
}
# Two buckets!
r._split_bucket(0)
self.assertEqual(2, len(r._buckets))
bucket1 = r._buckets[0]
bucket2 = r._buckets[1]
# Ensure the right number of contacts are in each bucket in the correct
# order (most recently added at the head of the list).
self.assertEqual(20, len(bucket1._contacts))
self.assertEqual(20, len(bucket2._contacts))
for i in range(10):
self.assertEqual(low_contacts[i], bucket1._contacts[i])
self.assertEqual(low_cache[i], bucket1._contacts[i + 10])
for i in range(10):
self.assertEqual(high_contacts[i], bucket2._contacts[i])
self.assertEqual(high_cache[i], bucket2._contacts[i + 10])
# Ensure the _replacement_cache is in the expected state.
self.assertEqual(2, len(r._replacement_cache))
self.assertNotIn((0, 100), r._replacement_cache)
self.assertIn((0, 50), r._replacement_cache)
self.assertIn((50, 100), r._replacement_cache)
self.assertEqual(10, len(r._replacement_cache[(0, 50)]))
self.assertEqual(10, len(r._replacement_cache[(50, 100)]))
for i in range(10):
self.assertEqual(low_cache[i + 10],
r._replacement_cache[(0, 50)][i])
self.assertEqual(high_cache[i + 10],
r._replacement_cache[(50, 100)][i])
def test_split_bucket(self):
"""
Ensures that the correct bucket is split in two and that the contacts
are found in the right place.
"""
parent_node_id = 'deadbeef'
r = RoutingTable(parent_node_id)
bucket = Bucket(0, 100)
contact1 = PeerNode(PUBLIC_KEY, '192.168.0.1', 9999, 0)
contact1.network_id = hex(20)
bucket.add_contact(contact1)
contact2 = PeerNode(PUBLIC_KEY, '192.168.0.2', 8888, 0)
contact2.network_id = hex(40)
bucket.add_contact(contact2)
contact3 = PeerNode(PUBLIC_KEY, '192.168.0.3', 8888, 0)
contact3.network_id = hex(60)
bucket.add_contact(contact3)
contact4 = PeerNode(PUBLIC_KEY, '192.168.0.4', 8888, 0)
contact4.network_id = hex(80)
bucket.add_contact(contact4)
r._buckets[0] = bucket
# Sanity check
self.assertEqual(1, len(r._buckets))
r._split_bucket(0)
# Two buckets!
self.assertEqual(2, len(r._buckets))
bucket1 = r._buckets[0]
bucket2 = r._buckets[1]
# Ensure the right number of contacts are in each bucket in the correct
# order (most recently added at the head of the list).
self.assertEqual(2, len(bucket1._contacts))
self.assertEqual(2, len(bucket2._contacts))
self.assertEqual(contact1, bucket1._contacts[0])
self.assertEqual(contact2, bucket1._contacts[1])
self.assertEqual(contact3, bucket2._contacts[0])
self.assertEqual(contact4, bucket2._contacts[1])
# Split the new bucket again, ensuring that only the target bucket is
# modified.
r._split_bucket(1)
self.assertEqual(3, len(r._buckets))
bucket3 = r._buckets[2]
# bucket1 remains un-changed
self.assertEqual(2, len(bucket1._contacts))
# bucket2 only contains the lower half of its original contacts.
self.assertEqual(1, len(bucket2._contacts))
self.assertEqual(contact3, bucket2._contacts[0])
# bucket3 now contains the upper half of the original contacts.
self.assertEqual(1, len(bucket3._contacts))
self.assertEqual(contact4, bucket3._contacts[0])
# Split the bucket at position 0 and ensure the resulting buckets are
# in the correct position with the correct content.
r._split_bucket(0)
self.assertEqual(4, len(r._buckets))
bucket1, bucket2, bucket3, bucket4 = r._buckets
self.assertEqual(1, len(bucket1._contacts))
self.assertEqual(contact1, bucket1._contacts[0])
self.assertEqual(1, len(bucket2._contacts))
self.assertEqual(contact2, bucket2._contacts[0])
self.assertEqual(1, len(bucket3._contacts))
self.assertEqual(contact3, bucket3._contacts[0])
self.assertEqual(1, len(bucket4._contacts))
self.assertEqual(contact4, bucket4._contacts[0])
def test_key_in_range_yes(self):
"""
Ensures that a key within the appropriate range is identified as such.
"""
bucket = Bucket(1, 9)
self.assertTrue(bucket.key_in_range('2'))
def test_key_in_range_yes(self):
"""
Ensures that a key within the appropriate range is identified as such.
"""
bucket = Bucket(1, 9)
self.assertTrue(bucket.key_in_range('2'))
