def test_get_peers_Received_sendsValidResponseWithPeers(self): # Create the protocol and populate its # routing table with nodes kresponder = self._patched_responder() peers = [("127.0.0.%d" % peer_num, peer_num) for peer_num in range(10)] incoming_query = Query() incoming_query.rpctype = "get_peers" incoming_query._from = 555 incoming_query._transaction_id = 15 # We have this target id in our routing table incoming_query.target_id = 77 expected_response = Response() expected_response._from = kresponder.node_id expected_response._transaction_id = 15 expected_response.peers = peers expected_response.rpctype = "get_peers" for peer in peers: kresponder._datastore.put(incoming_query.target_id, peer) kresponder.datagramReceived(krpc_coder.encode(incoming_query), test_address) actual_response = kresponder.sendResponse.response # Grab the autogenerated token and sort the peers to # match our expected order expected_response.token = actual_response.token actual_response.peers.sort(key = lambda (ip, port) : port) self.assertEquals(expected_response, actual_response)
def test_find_node_Received_sendsValidResponseMultipleNodes(self): # Create the protocol and populate its # routing table with nodes kresponder = self._patched_responder() node_list = [] node_gen = lambda num: contact.Node(num, ("127.0.0.%d" % num, num)) for i in range(100): n = node_gen(i) if kresponder.routing_table.offer_node(n): node_list.append(n) querying_node = contact.Node(123, test_address) incoming_query = Query() incoming_query.rpctype = "find_node" incoming_query._from = querying_node.node_id incoming_query._transaction_id = 15 incoming_query.target_id = 777777 expected_response = Response() expected_response._from = kresponder.node_id expected_response._transaction_id = 15 expected_response.rpctype = "find_node" node_list.sort(key = lambda node: node.distance(incoming_query.target_id)) node_list = node_list[:constants.k] expected_response.nodes = node_list kresponder.datagramReceived(krpc_coder.encode(incoming_query), test_address) actual_response = kresponder.sendResponse.response self.assertEquals(expected_response, actual_response)
def announce_peer(self, address, target_id, token, port, timeout=None): timeout = timeout or constants.rpctimeout query = Query() query.rpctype = "announce_peer" query.target_id = target_id query.token = token query.port = port return self.sendQuery(query, address, timeout)
def _gen_equal_announce_peers(self): q1 = Query() q2 = Query() q1._transaction_id = q2._transaction_id = 99 q1._from = q2._from = 55 q1.rpctype = q2.rpctype = "announce_peer" q1.token = q2.token = 13 q1.port = q2.port = 123 q1.target_id = q2.target_id = 66 self.assertEquals(q1, q2) return (q1, q2)
def setUp(self): self.clock = Clock() monkey_patcher.addPatch(krpc_responder, "time", self.clock) monkey_patcher.patch() self.address = ("127.0.0.1", 5555) # Attach a standard test query query = Query() query._from = 15125 query.rpctype = "get_peers" query.target_id = 90809 self.query = query # The token generator that will be tested self.tgen = _TokenGenerator()
class QueryTestCase(unittest.TestCase): def setUp(self): self.q = Query() self.q._transaction_id = 500 self.q._from = 27 self.q.rpctype = "ping" def test_build_response(self): nodes = [] token = 8192 peers = [" "] r = self.q.build_response(nodes, token, peers) self.assertEquals(self.q._transaction_id, r._transaction_id) self.assertEquals(self.q.rpctype, r.rpctype) self.assertEquals(nodes, r.nodes) self.assertEquals(token, r.token) self.assertEquals(peers, r.peers) def test_build_error(self): code = 203 message = "Oops, error" e = self.q.build_error(code, message) self.assertEquals(self.q._transaction_id, e._transaction_id) self.assertEquals(code, e.code) self.assertEquals(message, e.message) def test_repr(self): expected_repr = "<Query: _transaction_id=500 rpctype=ping _from=27>" self.assertEquals(expected_repr, repr(self.q)) def test__eq__(self): q1, q2 = self._gen_equal_announce_peers() self.assertEquals(q1, q2) def test__ne___(self): q1, q2 = self._gen_equal_announce_peers() q1._transaction_id = 88 q2._transaction_id = 66 self.assertNotEquals(q1, q2) def _gen_equal_announce_peers(self): q1 = Query() q2 = Query() q1._transaction_id = q2._transaction_id = 99 q1._from = q2._from = 55 q1.rpctype = q2.rpctype = "announce_peer" q1.token = q2.token = 13 q1.port = q2.port = 123 q1.target_id = q2.target_id = 66 self.assertEquals(q1, q2) return (q1, q2)
def test_get_peers_Received_sendsValidResponseWithNodes(self): # Create the protocol and populate its # routing table with nodes # We need a node_id close to 'target_id' so that our kbuckets split # in a way that we will have the target id target_id = 76 our_id = target_id - 1 kresponder = self._patched_responder(our_id) node_list = [] node_gen = lambda num: contact.Node(num, ("127.0.0.%d" % num, num)) for i in range(100): if i != our_id: n = node_gen(i) if kresponder.routing_table.offer_node(n): node_list.append(n) # simulate that a get_peers query has been # received by making a fake get_peers query # and feeding it into "datagramReceived()" querying_node = contact.Node(123, test_address) incoming_query = Query() incoming_query.rpctype = "get_peers" incoming_query._from = querying_node.node_id incoming_query._transaction_id = 15 # We have this target id in our routing table incoming_query.target_id = target_id # Create a response object and ensure # and the response (that the node sends) # matches what we made expected_response = Response() expected_response._from = kresponder.node_id expected_response._transaction_id = incoming_query._transaction_id expected_response.rpctype = "get_peers" # the specification calls for the resulting # nodes to be sorted by distance node_list.sort(key = lambda node: node.distance(incoming_query.target_id)) node_list = node_list[:constants.k] expected_response.nodes = node_list # simulating the incoming query and capture # the outgoing response kresponder.datagramReceived(krpc_coder.encode(incoming_query), test_address) actual_response = kresponder.sendResponse.response # Grab the autogenerated token expected_response.token = actual_response.token self.assertEquals(expected_response, actual_response)
def test_ping_Received_sendsValidResponse(self): kresponder = self._patched_responder() incoming_query = Query() incoming_query.rpctype = "ping" incoming_query._from = 123 incoming_query._transaction_id = 15 expected_response = Response() expected_response._from = kresponder.node_id expected_response._transaction_id = 15 expected_response.rpctype = "ping" kresponder.datagramReceived(krpc_coder.encode(incoming_query), test_address) actual_response = kresponder.sendResponse.response self.assertEquals(expected_response, actual_response)
def _query_decoder(rpc_dict): """ Decode the given KRPC dictionary into a valid Query @see decode @return krpc_types.Query """ q = Query() q._from = basic_coder.decode_network_id(rpc_dict['a']['id']) q.rpctype = rpctype = rpc_dict['q'] if rpctype == 'ping': pass elif rpctype == 'find_node': q.target_id = basic_coder.decode_network_id(rpc_dict['a']['target']) elif rpctype == 'get_peers': q.target_id = basic_coder.decode_network_id(rpc_dict['a']['info_hash']) elif rpctype == 'announce_peer': q.target_id = basic_coder.decode_network_id(rpc_dict['a']['info_hash']) # Try encoding the port (to ensure it is within range) basic_coder.encode_port(rpc_dict['a']['port']) q.port = rpc_dict['a']['port'] q.token = basic_coder.btol(rpc_dict['a']['token']) else: raise _ProtocolFormatError() return q
def test_find_node_Received_sendsValidResponseWithTargetNode(self): # Create the protocol and populate its # routing table with nodes # We need a node_id close to 'target_id' so that our kbuckets split # in a way that we will have the target id target_id = 76 our_id = target_id - 1 kresponder = self._patched_responder(our_id) node_list = [] node_gen = lambda num: contact.Node(num, ("127.0.0.%d" % num, num)) for i in range(100): if i != our_id: n = node_gen(i) node_was_accepted = kresponder.routing_table.offer_node(n) if node_was_accepted: node_list.append(n) querying_node = contact.Node(123, test_address) incoming_query = Query() incoming_query.rpctype = "find_node" incoming_query._from = querying_node.node_id incoming_query._transaction_id = 15 # We have this target id in our routing table incoming_query.target_id = target_id expected_response = Response() expected_response._from = kresponder.node_id expected_response._transaction_id = 15 expected_response.rpctype = "find_node" # The response node_list should contain only the target node node_list = filter(lambda node: node.node_id == target_id, node_list) expected_response.nodes = node_list if len(node_list) != 1: self.fail("Too many or too few nodes!") kresponder.datagramReceived(krpc_coder.encode(incoming_query), test_address) actual_response = kresponder.sendResponse.response self.assertEquals(expected_response, actual_response)
def test_get_peers_Received_sendsValidResponseWithPeers(self): # Create the protocol and populate its # routing table with nodes kresponder = self._patched_responder() peers = [("127.0.0.%d" % peer_num, peer_num) for peer_num in range(10)] incoming_query = Query() incoming_query.rpctype = "get_peers" incoming_query._from = 555 incoming_query._transaction_id = 15 # We have this target id in our routing table incoming_query.target_id = 77 expected_response = Response() expected_response._from = kresponder.node_id expected_response._transaction_id = 15 expected_response.peers = peers expected_response.rpctype = "get_peers" for peer in peers: kresponder._datastore.put(incoming_query.target_id, peer) kresponder.datagramReceived(krpc_coder.encode(incoming_query), test_address) actual_response = kresponder.sendResponse.response # Grab the autogenerated token and sort the peers to # match our expected order expected_response.token = actual_response.token actual_response.peers.sort(key=lambda (ip, port): port) self.assertEquals(expected_response, actual_response)
def test_find_node_Received_sendsValidResponseMultipleNodes(self): # Create the protocol and populate its # routing table with nodes kresponder = self._patched_responder() node_list = [] node_gen = lambda num: contact.Node(num, ("127.0.0.%d" % num, num)) for i in range(100): n = node_gen(i) if kresponder.routing_table.offer_node(n): node_list.append(n) querying_node = contact.Node(123, test_address) incoming_query = Query() incoming_query.rpctype = "find_node" incoming_query._from = querying_node.node_id incoming_query._transaction_id = 15 incoming_query.target_id = 777777 expected_response = Response() expected_response._from = kresponder.node_id expected_response._transaction_id = 15 expected_response.rpctype = "find_node" node_list.sort( key=lambda node: node.distance(incoming_query.target_id)) node_list = node_list[:constants.k] expected_response.nodes = node_list kresponder.datagramReceived(krpc_coder.encode(incoming_query), test_address) actual_response = kresponder.sendResponse.response self.assertEquals(expected_response, actual_response)
def test_get_peers_Received_sendsValidResponseWithNodes(self): # Create the protocol and populate its # routing table with nodes # We need a node_id close to 'target_id' so that our kbuckets split # in a way that we will have the target id target_id = 76 our_id = target_id - 1 kresponder = self._patched_responder(our_id) node_list = [] node_gen = lambda num: contact.Node(num, ("127.0.0.%d" % num, num)) for i in range(100): if i != our_id: n = node_gen(i) if kresponder.routing_table.offer_node(n): node_list.append(n) # simulate that a get_peers query has been # received by making a fake get_peers query # and feeding it into "datagramReceived()" querying_node = contact.Node(123, test_address) incoming_query = Query() incoming_query.rpctype = "get_peers" incoming_query._from = querying_node.node_id incoming_query._transaction_id = 15 # We have this target id in our routing table incoming_query.target_id = target_id # Create a response object and ensure # and the response (that the node sends) # matches what we made expected_response = Response() expected_response._from = kresponder.node_id expected_response._transaction_id = incoming_query._transaction_id expected_response.rpctype = "get_peers" # the specification calls for the resulting # nodes to be sorted by distance node_list.sort( key=lambda node: node.distance(incoming_query.target_id)) node_list = node_list[:constants.k] expected_response.nodes = node_list # simulating the incoming query and capture # the outgoing response kresponder.datagramReceived(krpc_coder.encode(incoming_query), test_address) actual_response = kresponder.sendResponse.response # Grab the autogenerated token expected_response.token = actual_response.token self.assertEquals(expected_response, actual_response)
def setUp(self): TestingBase.setUp(self) # Set up a query and address for testing self.address = ("127.0.0.1", 55) self.query = Query() self.query.rpctype = "ping" self.query._from = 15 self.query._transaction_id = 99 self.packet = krpc_coder.encode(self.query) # Patch in hardcoded value for the bandwidth # limits so that changing the constants will # not effect the usefulness of this test case # (The global bandwidth is set to 3 standard ping queries) # (The per user bandwidth is set to 1 standard ping query) self.monkey_patcher.addPatch(rate_limiter.constants, "global_bandwidth_rate", 3 * len(self.packet)) self.monkey_patcher.addPatch(rate_limiter.constants, "host_bandwidth_rate", 1 * len(self.packet)) self.monkey_patcher.patch()
def test_announce_peer_Received_sendsValidResponse(self): kresponder = self._patched_responder() # announce_peer queries need a token (the token value # comes in response to a get_peers query) # So first, we need to "receive" a get_peers query # get_peers creation and "receiving" query = Query() query.rpctype = "get_peers" query._from = 123 query._transaction_id = 150 query.target_id = 800 kresponder.datagramReceived(krpc_coder.encode(query), test_address) response = kresponder.sendResponse.response # announce_peer creation and "receiving" incoming_query = Query() incoming_query._transaction_id = 999 incoming_query._from = query._from incoming_query.rpctype = "announce_peer" incoming_query.token = response.token incoming_query.port = 55 incoming_query.target_id = query.target_id # Test the announce_peer response expected_response = Response() expected_response._from = kresponder.node_id expected_response._transaction_id = incoming_query._transaction_id expected_response.rpctype = "announce_peer" # Reset the response grabber kresponder.sendResponse.response = None kresponder.datagramReceived(krpc_coder.encode(incoming_query), test_address) actual_response = kresponder.sendResponse.response self.assertEquals(expected_response, actual_response)
def setUp(self): q = self.q = Query() q._transaction_id = 15 q._from = 2**120
def get_peers(self, address, target_id, timeout=None): timeout = timeout or constants.rpctimeout query = Query() query.rpctype = "get_peers" query.target_id = target_id return self.sendQuery(query, address, timeout)
def find_node(self, address, node_id, timeout=None): timeout = timeout or constants.rpctimeout query = Query() query.rpctype = "find_node" query.target_id = node_id return self.sendQuery(query, address, timeout)
def ping(self, address, timeout=None): timeout = timeout or constants.rpctimeout query = Query() query.rpctype = "ping" return self.sendQuery(query, address, timeout)
def test_announce_peer_Received_invalidTokenDoesntAddPeer(self): kresponder = self._patched_responder() # announce_peer queries need a token (the token value # comes in response to a get_peers query) # So first, we need to "receive" a get_peers query # get_peers creation and "receiving" query = Query() query.rpctype = "get_peers" query._from = 123 query._transaction_id = 150 query.target_id = 800 kresponder.datagramReceived(krpc_coder.encode(query), test_address) response = kresponder.sendResponse.response # announce_peer creation and "receiving" incoming_query = Query() incoming_query._transaction_id = 999 incoming_query._from = query._from incoming_query.rpctype = "announce_peer" incoming_query.token = 5858585858 # this is an invalid token incoming_query.port = 55 incoming_query.target_id = query.target_id # Test the announce_peer response expected_response = Response() expected_response._from = kresponder.node_id expected_response._transaction_id = incoming_query._transaction_id # Reset the response grabber kresponder.sendResponse.response = None kresponder.datagramReceived(krpc_coder.encode(incoming_query), test_address) actual_response = kresponder.sendResponse.response # Make sure we didnt send a response self.assertEquals(None, actual_response) # Check to see if another get_peers query will return us # as a peer query = Query() query.rpctype = "get_peers" query._from = 123 query._transaction_id = 9809831 query.target_id = 800 kresponder.datagramReceived(krpc_coder.encode(query), test_address) response = kresponder.sendResponse.response # Make sure no peers were returned self.assertEquals(None, response.peers)
def setUp(self): self.q = Query() self.q._transaction_id = 500 self.q._from = 27 self.q.rpctype = "ping"