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_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_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_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_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_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_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'))