def test_client_status_is_approved_when_authentication_method_is_custom_and_approve_is_called(
):
# Given
expected_status = Handshake.CONNECTION_STATUS_APPROVED
allowed_authentication_methods_client = ["custom"]
allowed_authentication_methods_server = ["custom"]
authentication_information_client = {}
client = Handshake(
role=Handshake.CLIENT,
authentication_information=authentication_information_client,
allowed_authentication_methods=allowed_authentication_methods_client)
server = Handshake(
role=Handshake.SERVER,
allowed_authentication_methods=allowed_authentication_methods_server)
server.add_message(client.next_message())
client.add_message(server.next_message())
server.add_message(client.next_message())
client.add_message(server.next_message())
server.add_message(client.next_message())
# When
server.approve()
client.add_message(server.next_message())
status_server = server.get_status()
status_client = client.get_status()
# Then
assert status_server == expected_status
assert status_client == expected_status
def test_client_status_is_waiting_approval_when_authentication_method_is_custom(
):
# Given
expected_status = Handshake.CONNECTION_STATUS_WAIT_APPROVAL
allowed_authentication_methods_client = ["custom"]
allowed_authentication_methods_server = ["custom"]
authentication_information_client = {}
client = Handshake(
role=Handshake.CLIENT,
authentication_information=authentication_information_client,
allowed_authentication_methods=allowed_authentication_methods_client)
server = Handshake(
role=Handshake.SERVER,
allowed_authentication_methods=allowed_authentication_methods_server)
server.add_message(client.next_message())
client.add_message(server.next_message())
server.add_message(client.next_message())
client.add_message(server.next_message())
server.add_message(client.next_message())
# When
status = server.get_status()
# Then
assert status == expected_status
def test_get_status_return_complete_when_and_handshake_was_successful_without_authentication(
):
# Given
server = Handshake(role=Handshake.SERVER)
client = Handshake(role=Handshake.CLIENT)
server.add_message(client.next_message())
client.add_message(server.next_message())
server.add_message(client.next_message())
client.add_message(server.next_message())
# When
result_client = client.get_status()
result_server = server.get_status()
# Then
assert result_client == Handshake.CONNECTION_STATUS_APPROVED
assert result_server == Handshake.CONNECTION_STATUS_APPROVED
def test_connection_fail_if_abort_is_called_on_client_after_a_connection_request(
):
# Given
server = Handshake(role=Handshake.SERVER)
client = Handshake(role=Handshake.CLIENT)
server.add_message(client.next_message())
client.add_message(server.next_message())
# When
client.abort()
connection_failed_message = client.next_message()
server.add_message(connection_failed_message)
# Then
assert server.get_status() == Handshake.CONNECTION_STATUS_FAILED
assert client.get_status() == Handshake.CONNECTION_STATUS_FAILED
assert int.from_bytes(connection_failed_message.topic,
'little') == Handshake.CONNECTION_FAILED_TOPIC
def test_get_status_return_incomplete_when_role_is_client_and_handshake_process_not_started(
):
# Given
role = Handshake.CLIENT
client = Handshake(role=role)
# When
result = client.get_status()
# Then
assert result == Handshake.CONNECTION_STATUS_INCOMPLETE
def test_get_status_return_approved_when_authentication_is_correct():
# Given
allowed_authentication_methods = ["password"]
password_to_derive = b"test"
password_salt = os.urandom(16)
password_client = "test"
derived_password = derive_password_scrypt(
password_salt=password_salt, password_to_derive=password_to_derive)
authentication_information_server = {
"password": {
Handshake.PASSWORD_AUTH_METHOD_DERIVED_PASSWORD_KEY:
derived_password,
Handshake.PASSWORD_AUTH_METHOD_SALT_KEY: password_salt
}
}
server = Handshake(
role=Handshake.SERVER,
authentication_information=authentication_information_server,
allowed_authentication_methods=allowed_authentication_methods)
authentication_information_client = {
Handshake.PASSWORD_AUTH_METHOD_PASSWORD_KEY: password_client
}
client = Handshake(
role=Handshake.CLIENT,
authentication_information=authentication_information_client,
allowed_authentication_methods=allowed_authentication_methods)
server.add_message(client.next_message())
client.add_message(server.next_message())
server.add_message(client.next_message())
client.add_message(server.next_message())
server.add_message(client.next_message())
client.add_message(server.next_message())
# When
result_client = client.get_status()
result_server = server.get_status()
# Then
assert result_client == Handshake.CONNECTION_STATUS_APPROVED
assert result_server == Handshake.CONNECTION_STATUS_APPROVED
def test_connection_fail_if_server_and_client_have_not_a_common_protocol_version(
):
# Given
allowed_protocol_versions_client = ['alpha']
allowed_protocol_versions_server = ['1.0']
server = Handshake(
role=Handshake.SERVER,
allowed_protocol_versions=allowed_protocol_versions_server)
client = Handshake(
role=Handshake.CLIENT,
allowed_protocol_versions=allowed_protocol_versions_client)
server.add_message(client.next_message())
# When
connection_failed_message = server.next_message()
client.add_message(connection_failed_message)
# Then
assert server.get_status() == Handshake.CONNECTION_STATUS_FAILED
assert client.get_status() == Handshake.CONNECTION_STATUS_FAILED
assert int.from_bytes(connection_failed_message.topic,
'little') == Handshake.CONNECTION_FAILED_TOPIC
