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)