def test_retrieve(self):
input = "login#ac1&pass1"
self.input_handler.handle_input(input)
token_number = 123
response = ServerMessageFactory.successful_login_ack(token_number)
response = json.dumps(response).encode()
self.response_handler.handle_response(response)
input_2 = "retrieve#2"
self.input_handler.handle_input(input_2)
from_username = "******"
retrieve_message = "hello_test"
response_2 = ServerMessageFactory.retrieve_ack(from_username,
retrieve_message)
response_2 = json.dumps(response_2).encode()
self.response_handler.handle_response(response_2)
self.assertFalse(
self.state_transition_manager.curr_state.state_completed)
response_3 = ServerMessageFactory.end_of_retrieve_ack()
response_3 = json.dumps(response_3).encode()
self.response_handler.handle_response(response_3)
self.assertTrue(
self.state_transition_manager.curr_state.state_completed)
def handle_request(self, data, addr):
# The input comes in as a json string encoded as bytes, so we decode it and deserialize the json from a string
# If invalid non-json, just drop it
try:
decoded_payload = json.loads(data.decode())
except Exception as err:
print("Received invalid JSON in packet; dropping!")
return
self.curr_response = []
self.curr_addr = addr
print("")
print("Received payload: {}".format(decoded_payload))
try:
self._multiplex_request(decoded_payload)
except MalformedRequestIdentityException as err:
self.curr_response.append(
(ServerMessageFactory.invalid_header_identity(str(err)),
self.curr_addr))
send_packet(self.curr_response)
except InvalidTokenException as err:
# Send must-login-first-error
self.curr_response.append(
(ServerMessageFactory.must_login_first_error(str(err)),
self.curr_addr))
send_packet(self.curr_response)
def test_subscribe(self):
input = "login#ac1&pass1"
self.input_handler.handle_input(input)
token_number = 123
response = ServerMessageFactory.successful_login_ack(token_number)
response = json.dumps(response).encode()
self.response_handler.handle_response(response)
input_2 = "subscribe#ac2"
self.input_handler.handle_input(input_2)
response_2 = ServerMessageFactory.successful_subscribe_ack()
response_2 = json.dumps(response_2).encode()
self.response_handler.handle_response(response_2)
self.assertTrue(
self.state_transition_manager.curr_state.state_completed)
def test_invalid_login(self):
input = "login#ac1&wrong_pass"
self.input_handler.handle_input(input)
response = ServerMessageFactory.failed_login_ack(
"Incorrect Login Information")
response = json.dumps(response).encode()
with self.assertRaises(MalformedRequestException) as err:
self.response_handler.handle_response(response)
self.assertTrue("Login Failed from Server" in str(err.exception))
def test_server_err_subscribe(self):
input = "login#ac1&pass1"
self.input_handler.handle_input(input)
token_number = 123
response = ServerMessageFactory.successful_login_ack(token_number)
response = json.dumps(response).encode()
self.response_handler.handle_response(response)
input_2 = "subscribe#ac2"
self.input_handler.handle_input(input_2)
response_2 = ServerMessageFactory.failed_subscribe_ack(
"Invalid subscribe")
response_2 = json.dumps(response_2).encode()
with self.assertRaises(MalformedRequestException) as err:
self.response_handler.handle_response(response_2)
self.assertTrue("Subscribe Failed from Server" in str(err.exception))
self.assertFalse(
self.state_transition_manager.curr_state.state_completed)
def test_valid_login(self):
input = "login#ac1&pass1"
self.input_handler.handle_input(input)
token_number = 324
response = ServerMessageFactory.successful_login_ack(token_number)
response = json.dumps(response).encode()
self.response_handler.handle_response(response)
self.assertTrue(
self.state_transition_manager.curr_state.state_completed)
self.assertEqual(messaging_system.client.token_holder.token,
token_number)
def _multiplex_request(self, payload):
if (not header_keys['MAGIC_NUM_1'] in payload
or not header_keys['MAGIC_NUM_2'] in payload
or payload[header_keys['MAGIC_NUM_1']] != MAGIC_NUMBER_1
or payload[header_keys['MAGIC_NUM_2']] != MAGIC_NUMBER_2):
raise MalformedRequestIdentityException(
"Invalid Magic Numbers in Request")
if (not header_keys['OPCODE'] in payload):
raise MalformedRequestIdentityException(
"Missing Opcode in request")
if (payload[header_keys['OPCODE']] == opcodes['LOGIN']):
try:
user_token = self._handle_login(payload, self.curr_addr)
self.curr_response.append(
(ServerMessageFactory.successful_login_ack(user_token),
self.curr_addr))
except MalformedRequestHeaderException as err:
self.curr_response.append(
(ServerMessageFactory.failed_login_ack(str(err)),
self.curr_addr))
elif (payload[header_keys['OPCODE']] == opcodes['SUBSCRIBE']):
try:
self._handle_subscribe(payload)
self.curr_response.append(
(ServerMessageFactory.successful_subscribe_ack(),
self.curr_addr))
except MalformedRequestHeaderException as err:
self.curr_response.append(
(ServerMessageFactory.failed_subscribe_ack(str(err)),
self.curr_addr))
elif (payload[header_keys['OPCODE']] == opcodes['UNSUBSCRIBE']):
try:
self._handle_unsubscribe(payload)
self.curr_response.append(
(ServerMessageFactory.successful_unsubscribe_ack(),
self.curr_addr))
except MalformedRequestHeaderException as err:
self.curr_response.append(
(ServerMessageFactory.failed_unsubscribe_ack(str(err)),
self.curr_addr))
elif (payload[header_keys['OPCODE']] == opcodes['POST']):
try:
message_details = self._handle_post(payload)
self.curr_response.append(
(ServerMessageFactory.successful_post_ack(),
self.curr_addr))
for subscriber_token in message_details['SUBSCRIBER_TOKENS']:
self.curr_response.append(
(ServerMessageFactory.forward(
message_details['FROM_USERNAME'],
message_details['FORWARD_MESSAGE']),
(subscriber_token['client_addr']['ip_addr'],
subscriber_token['client_addr']['port'])))
except MalformedRequestHeaderException as err:
self.curr_response.append(
(ServerMessageFactory.failed_post_ack(str(err)),
self.curr_addr))
elif (payload[header_keys['OPCODE']] == opcodes['FORWARD_ACK']):
try:
self._handle_forward_ack(payload)
except MalformedRequestHeaderException as err:
self.curr_response.append(
(ServerMessageFactory.session_reset(), self.curr_addr))
elif (payload[header_keys['OPCODE']] == opcodes['RETRIEVE']):
try:
messages_to_send = self._handle_retrieve(payload)
for message_to_send in messages_to_send:
message = message_to_send.message
from_username = message_to_send.from_account_username
self.curr_response.append(
(ServerMessageFactory.retrieve_ack(
from_username, message), self.curr_addr))
# Send by end of retrieve ACK after sending all messages
self.curr_response.append(
(ServerMessageFactory.end_of_retrieve_ack(),
self.curr_addr))
except MalformedRequestHeaderException as err:
self.curr_response.append(
(ServerMessageFactory.session_reset(), self.curr_addr))
elif (payload[header_keys['OPCODE']] == opcodes['LOGOUT']):
try:
self._handle_logout(payload)
self.curr_response.append(
(ServerMessageFactory.logout_ack(), self.curr_addr))
except MalformedRequestHeaderException as err:
self.curr_response.append(
(ServerMessageFactory.session_reset(), self.curr_addr))
elif (payload[header_keys['OPCODE']] == opcodes['SESSION_RESET']):
try:
self._handle_session_reset(payload)
except MalformedRequestHeaderException as err:
self.curr_response.append(
(ServerMessageFactory.session_reset(), self.curr_addr))
else:
raise MalformedRequestIdentityException("Opcode is invalid")
send_packet(self.curr_response)