def test_distance(self):
def dist(node_id1, node_id2):
return self.rt.distance(self._lpad_node_id_len(node_id1),
self._lpad_node_id_len(node_id2))
self.assertEqual(0, dist("a", "a"))
self.assertNotEqual(0, dist("abcd", "dcba"))
self.assertEqual(1, dist("2", "3"))
self.assertEqual(10, dist("2", "8"))
self.assertEqual(4008636142L, dist("1" * 8, "f" * 8))
d_ab = dist("a", "b")
self.assertEqual(d_ab, dist("b", "a"))
self.assertEqual(d_ab, dist(u"a", "b"))
self.assertEqual(d_ab, dist("a", u"b"))
self.assertEqual(
d_ab,
self.rt.distance(guid.GUIDMixin(self._lpad_node_id_len("a")),
self._lpad_node_id_len("b")))
self.assertEqual(
d_ab,
self.rt.distance(self._lpad_node_id_len("a"),
guid.GUIDMixin(self._lpad_node_id_len("b"))))
self.assertRaises(ValueError, self.rt.distance, "a" * 4,
"a" * constants.HEX_NODE_ID_LEN)
self.assertRaises(ValueError, self.rt.distance,
"a" * constants.HEX_NODE_ID_LEN, "a" * 4)
def test_hash(self):
a = guid.GUIDMixin(self.guid)
self.assertEqual(hash(a), hash(self.guid))
self.assertEqual(hash(a), hash(self.uguid))
b = guid.GUIDMixin(self.uguid)
self.assertEqual(hash(b), hash(self.guid))
self.assertEqual(hash(b), hash(self.uguid))
def test_hash(self):
guid_mixin_1 = guid.GUIDMixin(self.guid)
self.assertEqual(hash(guid_mixin_1), hash(self.guid))
self.assertEqual(hash(guid_mixin_1), hash(self.uguid))
guid_mixin_2 = guid.GUIDMixin(self.uguid)
self.assertEqual(hash(guid_mixin_2), hash(self.guid))
self.assertEqual(hash(guid_mixin_2), hash(self.uguid))
def _test_eq_true_scenario(self, guid1, guid2):
a = guid.GUIDMixin(guid1)
b = guid.GUIDMixin(guid1)
c = guid.GUIDMixin(guid2)
self.assertIsNot(a, b, "Separate instantiations produce same objects.")
self.assertEqual(a, b, "GUIDMixin unequal to same GUIDMixin.")
self.assertEqual(a, guid1, "GUIDMixin unequal to own GUID.")
self.assertEqual(a, c,
"GUIDMixin unequal to string-equivalent GUIDMixin.")
def _test_eq_true_scenario(self, guid1, guid2):
guid_mixin_1 = guid.GUIDMixin(guid1)
guid_mixin_2 = guid.GUIDMixin(guid1)
guid_mixin_3 = guid.GUIDMixin(guid2)
self.assertIsNot(guid_mixin_1, guid_mixin_2, "Separate instantiations produce same objects.")
self.assertEqual(guid_mixin_1, guid_mixin_2, "GUIDMixin unequal to same GUIDMixin.")
self.assertEqual(guid_mixin_1, guid1, "GUIDMixin unequal to own GUID.")
self.assertEqual(
guid_mixin_1, guid_mixin_3, "GUIDMixin unequal to string-equivalent GUIDMixin."
)
def test_removeContact(self):
self._test_removeContact_scenario(self.id1)
self._test_removeContact_scenario(unicode(self.id1))
self._test_removeContact_scenario(guid.GUIDMixin(self.id1))
# Removing an absent contact shouldn't raise a ValueError
self._test_removeContact_scenario(self.id2)
def add_contact(self, contact):
"""
Add a contact to the contact list.
The new contact is always appended to the contact list after removing
any prior occurences of the same contact.
@param contact: The ID of the contact to add.
@type contact: guid.GUIDMixin or str or unicode
@raise node.kbucket.BucketFull: The bucket is full and the contact
to add is not already in it.
"""
if isinstance(contact, basestring):
contact = guid.GUIDMixin(contact)
try:
# Assume contact exists. Attempt to remove the old one...
self.contacts.remove(contact)
# ... and add the new one at the end of the list.
self.contacts.append(contact)
# The code above works as follows:
# Assume C1 is the existing contact and C2 is the new contact.
# Iff C1 is equal to C2, it will be removed from the list.
# Since Contact.__eq__ compares only GUIDs, contact C1 will
# be replaced even if it's not exactly the same as C2.
# This is the intended behaviour; the fresh contact may have
# updated add-on data (e.g. optimization-specific stuff).
except ValueError:
# The contact wasn't there after all, so add it.
if len(self.contacts) < constants.K:
self.contacts.append(contact)
else:
raise BucketFull('No space in bucket to insert contact')
def setUpClass(cls):
cls.id1 = "a" * 20
cls.id2 = "b" * 20
cls.uid1 = unicode(cls.id1)
cls.uid2 = unicode(cls.id2)
cls.parent_node_id = cls.id1
cls.market_id = 42
cls.guid = guid.GUIDMixin(cls.id1)
def test_key_in_range(self):
self.assertTrue(self.bucket.key_in_range(self.range_min))
self.assertTrue(self.bucket.key_in_range(self.range_max - 1))
mid_key = self.range_min + (self.range_max - self.range_min) // 2
mid_key_hex = hex(mid_key)
mid_key_guid = guid.GUIDMixin(mid_key_hex)
self.assertTrue(self.bucket.key_in_range(mid_key))
self.assertTrue(self.bucket.key_in_range(mid_key_hex))
self.assertTrue(self.bucket.key_in_range(mid_key_guid))
self.assertFalse(self.bucket.key_in_range(self.range_min - 1))
self.assertFalse(self.bucket.key_in_range(self.range_max))
def _test_eq_false_scenario(self, guid1, guid2):
a = guid.GUIDMixin(guid1)
b = guid.GUIDMixin(guid2)
self.assertNotEqual(a, b, "GUIDMixin equal to different GUIDMixin.")
self.assertNotEqual(a, guid2, "GUIDMixin equal to different GUID.")
def _test_eq_false_scenario(self, guid1, guid2):
guid_mixin_1 = guid.GUIDMixin(guid1)
guid_mixin_2 = guid.GUIDMixin(guid2)
self.assertNotEqual(guid_mixin_1, guid_mixin_2, "GUIDMixin equal to different GUIDMixin.")
self.assertNotEqual(guid_mixin_1, guid2, "GUIDMixin equal to different GUID.")
def test_kbucketIndex_default(self):
hex_key = self.rt.numToId(self._init_N_buckets(2))
self.assertEqual(1, self.rt.kbucketIndex(hex_key))
self.assertEqual(1, self.rt.kbucketIndex(unicode(hex_key)))
self.assertEqual(1, self.rt.kbucketIndex(guid.GUIDMixin(hex_key)))
def test_repr(self):
guid_mixin_1 = guid.GUIDMixin(self.guid)
self.assertEqual(guid_mixin_1.__repr__(), str(guid_mixin_1))
guid_mixin_2 = guid.GUIDMixin(self.uguid)
self.assertEqual(guid_mixin_2.__repr__(), str(guid_mixin_2))
def _mk_contact_by_num(i):
return guid.GUIDMixin(str(i))
def test_repr(self):
g = guid.GUIDMixin(self.guid)
self.assertEqual(g.__repr__(), str(g))
gu = guid.GUIDMixin(self.uguid)
self.assertEqual(gu.__repr__(), str(gu))
def test_kbucket_index_default(self):
hex_key = self.routingtable.num_to_id(self._init_n_buckets(2))
self.assertEqual(1, self.routingtable.kbucket_index(hex_key))
self.assertEqual(1, self.routingtable.kbucket_index(unicode(hex_key)))
self.assertEqual(
1, self.routingtable.kbucket_index(guid.GUIDMixin(hex_key)))
def test_init(self):
guid_mixin_1 = guid.GUIDMixin(self.guid)
self.assertEqual(guid_mixin_1.guid, self.guid)
guid_mixin_2 = guid.GUIDMixin(self.uguid)
self.assertEqual(guid_mixin_2.guid, self.uguid)
def test_init(self):
g = guid.GUIDMixin(self.guid)
self.assertEqual(g.guid, self.guid)
gu = guid.GUIDMixin(self.uguid)
self.assertEqual(gu.guid, self.uguid)
