def test_unknown_error(self): error_code = (999, "some weird error string") b_err = m.OutgoingErrorMsg(error_code).encode(tc.TID) logger.info( "TEST LOGGING ** IGNORE EXPECTED INFO ** Unknown error: %r", error_code) _ = m.IncomingMsg(b_err, tc.CLIENT_ADDR)
def _test_fire_callback_on_error(self): # the server creates the response error_msg = message.OutgoingErrorMsg(message.GENERIC_E) error_data = error_msg.encode(tc.TID) # IncomingMsg decodes the response received error_msg = message.IncomingMsg(error_data, tc.SERVER_ADDR) # querier notifies of the message (callback) self.query.on_error_received(error_msg) assert not self.got_response and self.got_error
def test_querier_responder(self): # client # setup self.c.add_msg_callback(message.RESPONSE, self.on_response_received) self.c.add_msg_callback(message.RESPONSE, self.on_routing_response_received) self.c.add_msg_callback(message.ERROR, self.on_error_received) self.c.add_timeout_callback(self.on_routing_timeout) # server # setup self.s.add_msg_callback(message.QUERY, self.on_query_received) # client creates and sends query t_task = self.c.get_timeout_task(tc.SERVER_ADDR, tc.TIMEOUT_DELAY, self.on_timeout) msg = message.OutgoingPingQuery(tc.CLIENT_ID) msg_data = msg.encode(tc.TID) self.c.send_msg_to(msg_data, tc.SERVER_ADDR) # client sets up timeout # server receives query, creates response and sends it back self.s._on_datagram_received(msg_data, tc.CLIENT_ADDR) # rpc_manager would send the message back automatically ok_(self.got_query) self.got_query = False msg = message.OutgoingPingResponse(tc.SERVER_ID) msg_data = msg.encode(tc.TID) self.s.send_msg_to(msg_data, tc.CLIENT_ADDR) # client gets response self.c._on_datagram_received(msg_data, tc.SERVER_ADDR) ok_(self.got_response) self.got_response = False ok_(self.got_routing_response) self.got_routing_response = False # client gets error msg_data = message.OutgoingErrorMsg(message.GENERIC_E).encode(tc.TID) self.c._on_datagram_received(msg_data, tc.SERVER_ADDR) ok_(self.got_error) self.got_error = False # client gets timeout t_task.fire_callbacks() ok_(self.got_timeout) self.got_timeout = False ok_(self.got_routing_timeout) self.got_routing_timeout = False # server gets invalid message self.s._on_datagram_received('zzz', tc.CLIENT_ADDR) ok_(not self.got_query) ok_(not self.got_response) ok_(not self.got_routing_response)
def test_error(self): # Client creates a query ping_msg = message.OutgoingPingQuery(tc.CLIENT_ID) q = Query(ping_msg, tc.SERVER_NODE) timeout_task = minitwisted.Task(TIMEOUT_DELAY, None) # Client registers query bencoded_msg = self.querier.register_query(q, timeout_task) # Client sends bencoded_msg time.sleep(1) # Server gets bencoded_msg and creates response ping_r_msg_out = message.OutgoingErrorMsg(message.GENERIC_E) bencoded_r = ping_r_msg_out.encode(tc.TID) # The client receives the bencoded message ping_r_in = message.IncomingMsg(bencoded_r, tc.SERVER_ADDR) stored_q = self.querier.on_error_received(ping_r_in, tc.SERVER_ADDR) assert stored_q is None
def send_query_and_get_error(self, querier): ping_msg = message.OutgoingPingQuery() query = querier.send_query(ping_msg, tc.EXTERNAL_NODE, self.on_response, self.on_timeout, self.on_error, timeout_delay=tc.TIMEOUT_DELAY) if querier is self.querier_mock: # the server creates the response error_msg = message.OutgoingErrorMsg(ping_msg.tid, message.GENERIC_E) error_data = error_msg.encode() # rpc_m decodes the response received _, _, error_msg_dict = message.decode(error_data) # rpc_m notifies of the message (callback) querier.on_error_received(error_msg_dict, tc.EXTERNAL_NODE) time.sleep(tc.TIMEOUT_DELAY + .1)
def test_find_node_with_error(self): # Client creates a query fn_msg = message.OutgoingFindNodeQuery(tc.CLIENT_ID, tc.TARGET_ID) # the destination's ID is unknown q = Query(fn_msg, node.Node(tc.SERVER_ADDR)) # Querier.register_query sets a TID and timeout_task q.tid = tc.TID q.timeout_task = minitwisted.Task(TIMEOUT_DELAY, None) q.query_ts = time.time() # The query is sent # The server creates a response fn_r_out = message.OutgoingErrorMsg(message.GENERIC_E) bencoded_fn_r = fn_r_out.encode(tc.TID) time.sleep(1) # The client receives the bencoded message fn_r_in = message.IncomingMsg(bencoded_fn_r, tc.SERVER_ADDR) q.on_error_received(fn_r_in) assert 1 < q.rtt < 1.1 assert q.lookup_obj is None
def test(self): msg_out = m.OutgoingErrorMsg(1).encode(tc.TID) assert_raises(m.MsgError, m.IncomingMsg, msg_out, tc.CLIENT_ADDR) # Unknown error doesn't raise m.MsgError msg_out = m.OutgoingErrorMsg((1, 1)).encode(tc.TID) _ = m.IncomingMsg(msg_out, tc.SERVER_ADDR)
def test_error(self): msg = message.OutgoingErrorMsg(message.GENERIC_E) self.querier.on_error_received(msg, tc.SERVER_ADDR)