From edb8928f5cf713abb0b74d352d27b7aa1df7095a Mon Sep 17 00:00:00 2001 From: Jack Robison Date: Tue, 24 Oct 2017 20:05:38 -0400 Subject: [PATCH] update tests --- lbrynet/tests/dht/test_node.py | 38 ++++++++++++++++--------- lbrynet/tests/dht/test_protocol.py | 12 ++++---- lbrynet/tests/dht/test_routing_table.py | 3 ++ lbrynet/tests/unit/dht/test_messages.py | 37 +++++++++--------------- 4 files changed, 47 insertions(+), 43 deletions(-) diff --git a/lbrynet/tests/dht/test_node.py b/lbrynet/tests/dht/test_node.py index c86f98fa1..9ae3eb3a9 100644 --- a/lbrynet/tests/dht/test_node.py +++ b/lbrynet/tests/dht/test_node.py @@ -62,6 +62,7 @@ class NodeDataTest(unittest.TestCase): self.cases.append((h.digest(), 5000+2*i)) self.cases.append((h.digest(), 5001+2*i)) + @defer.inlineCallbacks def testStore(self): """ Tests if the node can store (and privately retrieve) some data """ for key, value in self.cases: @@ -70,7 +71,7 @@ class NodeDataTest(unittest.TestCase): 'lbryid': self.contact.id, 'token': self.token } - self.node.store(key, request, self.contact.id, _rpcNodeContact=self.contact) + yield self.node.store(key, request, self.contact.id, _rpcNodeContact=self.contact) for key, value in self.cases: expected_result = self.contact.compact_ip() + str(struct.pack('>H', value)) + \ self.contact.id @@ -90,7 +91,7 @@ class NodeContactTest(unittest.TestCase): """ Tests if a contact can be added and retrieved correctly """ import lbrynet.dht.contact # Create the contact - h = hashlib.sha1() + h = hashlib.sha384() h.update('node1') contactID = h.digest() contact = lbrynet.dht.contact.Contact(contactID, '127.0.0.1', 91824, self.node._protocol) @@ -133,6 +134,10 @@ class FakeRPCProtocol(protocol.DatagramProtocol): def sendRPC(self, contact, method, args, rawResponse=False): """ Fake RPC protocol; allows entangled.kademlia.contact.Contact objects to "send" RPCs""" + h = hashlib.sha384() + h.update('rpcId') + rpc_id = h.digest()[:20] + if method == "findNode": # get the specific contacts closest contacts closestContacts = [] @@ -144,7 +149,8 @@ class FakeRPCProtocol(protocol.DatagramProtocol): # Pack the closest contacts into a ResponseMessage for closeContact in closestContactsList: closestContacts.append((closeContact.id, closeContact.address, closeContact.port)) - message = ResponseMessage("rpcId", contact.id, closestContacts) + + message = ResponseMessage(rpc_id, contact.id, closestContacts) df = defer.Deferred() df.callback((message, (contact.address, contact.port))) return df @@ -171,7 +177,7 @@ class FakeRPCProtocol(protocol.DatagramProtocol): response = closestContacts # Create the response message - message = ResponseMessage("rpcId", contact.id, response) + message = ResponseMessage(rpc_id, contact.id, response) df = defer.Deferred() df.callback((message, (contact.address, contact.port))) return df @@ -189,7 +195,10 @@ class NodeLookupTest(unittest.TestCase): # Note: The reactor is never started for this test. All deferred calls run sequentially, # since there is no asynchronous network communication # create the node to be tested in isolation - self.node = lbrynet.dht.node.Node('12345678901234567800', 4000, None, None, self._protocol) + h = hashlib.sha384() + h.update('node1') + node_id = str(h.digest()) + self.node = lbrynet.dht.node.Node(node_id, 4000, None, None, self._protocol) self.updPort = 81173 self.contactsAmount = 80 # Reinitialise the routing table @@ -198,16 +207,16 @@ class NodeLookupTest(unittest.TestCase): # create 160 bit node ID's for test purposes self.testNodeIDs = [] - idNum = int(self.node.node_id) + idNum = int(self.node.node_id.encode('hex'), 16) for i in range(self.contactsAmount): # create the testNodeIDs in ascending order, away from the actual node ID, # with regards to the distance metric - self.testNodeIDs.append(idNum + i + 1) + self.testNodeIDs.append(str("%X" % (idNum + i + 1)).decode('hex')) # generate contacts self.contacts = [] for i in range(self.contactsAmount): - contact = lbrynet.dht.contact.Contact(str(self.testNodeIDs[i]), "127.0.0.1", + contact = lbrynet.dht.contact.Contact(self.testNodeIDs[i], "127.0.0.1", self.updPort + i + 1, self._protocol) self.contacts.append(contact) @@ -241,23 +250,24 @@ class NodeLookupTest(unittest.TestCase): lbrynet.dht.datastore.DictDataStore())) self._protocol.createNetwork(contacts_with_datastores) + @defer.inlineCallbacks def testNodeBootStrap(self): """ Test bootstrap with the closest possible contacts """ - df = self.node._iterativeFind(self.node.node_id, self.contacts[0:8]) + activeContacts = yield self.node._iterativeFind(self.node.node_id, self.contacts[0:8]) # Set the expected result - expectedResult = [] + expectedResult = set() for item in self.contacts[0:6]: - expectedResult.append(item.id) + expectedResult.add(item.id) # Get the result from the deferred - activeContacts = df.result # Check the length of the active contacts self.failUnlessEqual(activeContacts.__len__(), expectedResult.__len__(), "More active contacts should exist, there should be %d " - "contacts" % expectedResult.__len__()) + "contacts but there are %d" % (len(expectedResult), + len(activeContacts))) # Check that the received active contacts are the same as the input contacts - self.failUnlessEqual(activeContacts, expectedResult, + self.failUnlessEqual({contact.id for contact in activeContacts}, expectedResult, "Active should only contain the closest possible contacts" " which were used as input for the boostrap") diff --git a/lbrynet/tests/dht/test_protocol.py b/lbrynet/tests/dht/test_protocol.py index 70c1e0456..d616451d9 100644 --- a/lbrynet/tests/dht/test_protocol.py +++ b/lbrynet/tests/dht/test_protocol.py @@ -16,7 +16,7 @@ class KademliaProtocolTest(unittest.TestCase): def setUp(self): del lbrynet.dht.protocol.reactor lbrynet.dht.protocol.reactor = twisted.internet.selectreactor.SelectReactor() - self.node = Node(node_id='node1', udpPort=9182, externalIP="127.0.0.1") + self.node = Node(node_id='1' * 48, udpPort=9182, externalIP="127.0.0.1") self.protocol = lbrynet.dht.protocol.KademliaProtocol(self.node) def testReactor(self): @@ -39,7 +39,7 @@ class KademliaProtocolTest(unittest.TestCase): lbrynet.dht.constants.rpcAttempts = 1 lbrynet.dht.constants.rpcTimeout = 1 self.node.ping = fake_ping - deadContact = lbrynet.dht.contact.Contact('node2', '127.0.0.1', 9182, self.protocol) + deadContact = lbrynet.dht.contact.Contact('2' * 48, '127.0.0.1', 9182, self.protocol) self.node.addContact(deadContact) # Make sure the contact was added self.failIf(deadContact not in self.node.contacts, @@ -73,7 +73,7 @@ class KademliaProtocolTest(unittest.TestCase): def testRPCRequest(self): """ Tests if a valid RPC request is executed and responded to correctly """ - remoteContact = lbrynet.dht.contact.Contact('node2', '127.0.0.1', 9182, self.protocol) + remoteContact = lbrynet.dht.contact.Contact('2' * 48, '127.0.0.1', 9182, self.protocol) self.node.addContact(remoteContact) self.error = None @@ -105,7 +105,7 @@ class KademliaProtocolTest(unittest.TestCase): Verifies that a RPC request for an existing but unpublished method is denied, and that the associated (remote) exception gets raised locally """ - remoteContact = lbrynet.dht.contact.Contact('node2', '127.0.0.1', 9182, self.protocol) + remoteContact = lbrynet.dht.contact.Contact('2' * 48, '127.0.0.1', 9182, self.protocol) self.node.addContact(remoteContact) self.error = None @@ -126,7 +126,7 @@ class KademliaProtocolTest(unittest.TestCase): # Publish the "local" node on the network lbrynet.dht.protocol.reactor.listenUDP(9182, self.protocol) # Simulate the RPC - df = remoteContact.pingNoRPC() + df = remoteContact.not_a_rpc_function() df.addCallback(handleResult) df.addErrback(handleError) df.addBoth(lambda _: lbrynet.dht.protocol.reactor.stop()) @@ -139,7 +139,7 @@ class KademliaProtocolTest(unittest.TestCase): def testRPCRequestArgs(self): """ Tests if an RPC requiring arguments is executed correctly """ - remoteContact = lbrynet.dht.contact.Contact('node2', '127.0.0.1', 9182, self.protocol) + remoteContact = lbrynet.dht.contact.Contact('2' * 48, '127.0.0.1', 9182, self.protocol) self.node.addContact(remoteContact) self.error = None diff --git a/lbrynet/tests/dht/test_routing_table.py b/lbrynet/tests/dht/test_routing_table.py index 436b531ec..fa0b0fd6e 100644 --- a/lbrynet/tests/dht/test_routing_table.py +++ b/lbrynet/tests/dht/test_routing_table.py @@ -27,6 +27,9 @@ class FakeDeferred(object): def addErrback(self, *args, **kwargs): return + def addCallbacks(self, *args, **kwargs): + return + class TreeRoutingTableTest(unittest.TestCase): """ Test case for the RoutingTable class """ diff --git a/lbrynet/tests/unit/dht/test_messages.py b/lbrynet/tests/unit/dht/test_messages.py index dfa948059..36c2295b9 100644 --- a/lbrynet/tests/unit/dht/test_messages.py +++ b/lbrynet/tests/unit/dht/test_messages.py @@ -9,40 +9,41 @@ import unittest from lbrynet.dht.msgtypes import RequestMessage, ResponseMessage, ErrorMessage from lbrynet.dht.msgformat import MessageTranslator, DefaultFormat + class DefaultFormatTranslatorTest(unittest.TestCase): """ Test case for the default message translator """ def setUp(self): - self.cases = ((RequestMessage('node1', 'rpcMethod', - {'arg1': 'a string', 'arg2': 123}, 'rpc1'), + self.cases = ((RequestMessage('1' * 48, 'rpcMethod', + {'arg1': 'a string', 'arg2': 123}, '1' * 20), {DefaultFormat.headerType: DefaultFormat.typeRequest, - DefaultFormat.headerNodeID: 'node1', - DefaultFormat.headerMsgID: 'rpc1', + DefaultFormat.headerNodeID: '1' * 48, + DefaultFormat.headerMsgID: '1' * 20, DefaultFormat.headerPayload: 'rpcMethod', DefaultFormat.headerArgs: {'arg1': 'a string', 'arg2': 123}}), - (ResponseMessage('rpc2', 'node2', 'response'), + (ResponseMessage('2' * 20, '2' * 48, 'response'), {DefaultFormat.headerType: DefaultFormat.typeResponse, - DefaultFormat.headerNodeID: 'node2', - DefaultFormat.headerMsgID: 'rpc2', + DefaultFormat.headerNodeID: '2' * 48, + DefaultFormat.headerMsgID: '2' * 20, DefaultFormat.headerPayload: 'response'}), - (ErrorMessage('rpc3', 'node3', + (ErrorMessage('3' * 20, '3' * 48, "", 'this is a test exception'), {DefaultFormat.headerType: DefaultFormat.typeError, - DefaultFormat.headerNodeID: 'node3', - DefaultFormat.headerMsgID: 'rpc3', + DefaultFormat.headerNodeID: '3' * 48, + DefaultFormat.headerMsgID: '3' * 20, DefaultFormat.headerPayload: "", DefaultFormat.headerArgs: 'this is a test exception'}), (ResponseMessage( - 'rpc4', 'node4', + '4' * 20, '4' * 48, [('H\x89\xb0\xf4\xc9\xe6\xc5`H>\xd5\xc2\xc5\xe8Od\xf1\xca\xfa\x82', '127.0.0.1', 1919), ('\xae\x9ey\x93\xdd\xeb\xf1^\xff\xc5\x0f\xf8\xac!\x0e\x03\x9fY@{', '127.0.0.1', 1921)]), {DefaultFormat.headerType: DefaultFormat.typeResponse, - DefaultFormat.headerNodeID: 'node4', - DefaultFormat.headerMsgID: 'rpc4', + DefaultFormat.headerNodeID: '4' * 48, + DefaultFormat.headerMsgID: '4' * 20, DefaultFormat.headerPayload: [('H\x89\xb0\xf4\xc9\xe6\xc5`H>\xd5\xc2\xc5\xe8Od\xf1\xca\xfa\x82', '127.0.0.1', 1919), @@ -81,13 +82,3 @@ class DefaultFormatTranslatorTest(unittest.TestCase): 'Message instance variable "%s" not translated correctly; ' 'expected "%s", got "%s"' % (key, msg.__dict__[key], translatedObj.__dict__[key])) - - -def suite(): - suite = unittest.TestSuite() - suite.addTest(unittest.makeSuite(DefaultFormatTranslatorTest)) - return suite - -if __name__ == '__main__': - # If this module is executed from the commandline, run all its tests - unittest.TextTestRunner().run(suite())