mirror of
https://github.com/aljazceru/python-teos.git
synced 2025-12-17 14:14:22 +01:00
135 lines
4.8 KiB
Python
135 lines
4.8 KiB
Python
import json
|
|
import struct
|
|
import binascii
|
|
from pytest import fixture
|
|
|
|
from common.appointment import Appointment
|
|
from common.encrypted_blob import EncryptedBlob
|
|
|
|
from test.common.unit.conftest import get_random_value_hex
|
|
|
|
from common.constants import LOCATOR_LEN_BYTES
|
|
|
|
|
|
# Not much to test here, adding it for completeness
|
|
@fixture
|
|
def appointment_data():
|
|
locator = get_random_value_hex(LOCATOR_LEN_BYTES)
|
|
start_time = 100
|
|
end_time = 120
|
|
to_self_delay = 20
|
|
encrypted_blob_data = get_random_value_hex(100)
|
|
|
|
return {
|
|
"locator": locator,
|
|
"start_time": start_time,
|
|
"end_time": end_time,
|
|
"to_self_delay": to_self_delay,
|
|
"encrypted_blob": encrypted_blob_data,
|
|
}
|
|
|
|
|
|
def test_init_appointment(appointment_data):
|
|
# The appointment has no checks whatsoever, since the inspector is the one taking care or that, and the only one
|
|
# creating appointments.
|
|
# DISCUSS: whether this makes sense by design or checks should be ported from the inspector to the appointment
|
|
# 35-appointment-checks
|
|
appointment = Appointment(
|
|
appointment_data["locator"],
|
|
appointment_data["start_time"],
|
|
appointment_data["end_time"],
|
|
appointment_data["to_self_delay"],
|
|
appointment_data["encrypted_blob"],
|
|
)
|
|
|
|
assert (
|
|
appointment_data["locator"] == appointment.locator
|
|
and appointment_data["start_time"] == appointment.start_time
|
|
and appointment_data["end_time"] == appointment.end_time
|
|
and appointment_data["to_self_delay"] == appointment.to_self_delay
|
|
and EncryptedBlob(appointment_data["encrypted_blob"]) == appointment.encrypted_blob
|
|
)
|
|
|
|
|
|
def test_to_dict(appointment_data):
|
|
appointment = Appointment(
|
|
appointment_data["locator"],
|
|
appointment_data["start_time"],
|
|
appointment_data["end_time"],
|
|
appointment_data["to_self_delay"],
|
|
appointment_data["encrypted_blob"],
|
|
)
|
|
|
|
dict_appointment = appointment.to_dict()
|
|
|
|
assert (
|
|
appointment_data["locator"] == dict_appointment["locator"]
|
|
and appointment_data["start_time"] == dict_appointment["start_time"]
|
|
and appointment_data["end_time"] == dict_appointment["end_time"]
|
|
and appointment_data["to_self_delay"] == dict_appointment["to_self_delay"]
|
|
and EncryptedBlob(appointment_data["encrypted_blob"]) == EncryptedBlob(dict_appointment["encrypted_blob"])
|
|
)
|
|
|
|
|
|
def test_to_json(appointment_data):
|
|
appointment = Appointment(
|
|
appointment_data["locator"],
|
|
appointment_data["start_time"],
|
|
appointment_data["end_time"],
|
|
appointment_data["to_self_delay"],
|
|
appointment_data["encrypted_blob"],
|
|
)
|
|
|
|
dict_appointment = json.loads(appointment.to_json())
|
|
|
|
assert (
|
|
appointment_data["locator"] == dict_appointment["locator"]
|
|
and appointment_data["start_time"] == dict_appointment["start_time"]
|
|
and appointment_data["end_time"] == dict_appointment["end_time"]
|
|
and appointment_data["to_self_delay"] == dict_appointment["to_self_delay"]
|
|
and EncryptedBlob(appointment_data["encrypted_blob"]) == EncryptedBlob(dict_appointment["encrypted_blob"])
|
|
)
|
|
|
|
|
|
def test_from_dict(appointment_data):
|
|
# The appointment should be build if we don't miss any field
|
|
appointment = Appointment.from_dict(appointment_data)
|
|
assert isinstance(appointment, Appointment)
|
|
|
|
# Otherwise it should fail
|
|
for key in appointment_data.keys():
|
|
prev_val = appointment_data[key]
|
|
appointment_data[key] = None
|
|
|
|
try:
|
|
Appointment.from_dict(appointment_data)
|
|
assert False
|
|
|
|
except ValueError:
|
|
appointment_data[key] = prev_val
|
|
assert True
|
|
|
|
|
|
def test_serialize(appointment_data):
|
|
# From the tower end, appointments are only created if they pass the inspector tests, so not covering weird formats.
|
|
# Serialize may fail if, from the user end, the user tries to do it with an weird appointment. Not critical.
|
|
|
|
appointment = Appointment.from_dict(appointment_data)
|
|
serialized_appointment = appointment.serialize()
|
|
|
|
# Size must be 16 + 4 + 4 + 4 + len(encrypted_blob)
|
|
assert len(serialized_appointment) >= 28
|
|
assert isinstance(serialized_appointment, bytes)
|
|
|
|
locator = serialized_appointment[:16]
|
|
start_time = serialized_appointment[16:20]
|
|
end_time = serialized_appointment[20:24]
|
|
to_self_delay = serialized_appointment[24:28]
|
|
encrypted_blob = serialized_appointment[28:]
|
|
|
|
assert binascii.hexlify(locator).decode() == appointment.locator
|
|
assert struct.unpack(">I", start_time)[0] == appointment.start_time
|
|
assert struct.unpack(">I", end_time)[0] == appointment.end_time
|
|
assert struct.unpack(">I", to_self_delay)[0] == appointment.to_self_delay
|
|
assert binascii.hexlify(encrypted_blob).decode() == appointment.encrypted_blob.data
|