async def test_send(self):
# Arrange
sut = PayloadSender()
sender = MockTransportSender()
sut.connect(sender)
header_id: UUID = uuid4()
header = Header(type="A", id=header_id, end=True)
header.payload_length = 3
payload = [1, 2, 3]
async def mock_sent_callback(callback_header: Header):
print(
f"{callback_header.type}.{callback_header.payload_length}.{callback_header.id}.{callback_header.end}"
)
# Act
sut.send_payload(header,
payload,
is_length_known=True,
sent_callback=mock_sent_callback)
# Assert
await sender.send_called.acquire()
await sut.disconnect()
async def disassemble(self):
header = Header(type=self._type, id=self._identifier, end=True)
header.payload_length = 0
self._sender.send_payload(header, None, True, None)
return
def test_get_payload_stream_exists_ok(self):
manager = StreamManager(None)
identifier: UUID = uuid4()
stream1 = manager.get_payload_stream(Header(id=identifier))
stream2 = manager.get_payload_stream(Header(id=identifier))
self.assertEqual(stream1, stream2)
def test_on_receive_sets_end(self):
identifier: UUID = uuid4()
stream_manager = StreamManager()
assembler = PayloadStreamAssembler(stream_manager, identifier)
header = Header()
header.end = True
assembler.get_payload_as_stream()
assembler.on_receive(header, [], 100)
self.assertTrue(assembler.end)
def test_get_payload_stream_not_exists_ok(self):
manager = StreamManager(None)
identifier: UUID = uuid4()
stream = manager.get_payload_stream(Header(id=identifier))
self.assertIsNotNone(stream)
def test_get_payload_stream_streams_match(self):
manager = StreamManager(None)
identifier: UUID = uuid4()
assembler = manager.get_payload_assembler(identifier)
stream = manager.get_payload_stream(Header(id=identifier))
self.assertEqual(assembler.get_payload_as_stream(), stream)
def test_on_receive_exists(self):
manager = StreamManager(None)
identifier: UUID = uuid4()
assembler = manager.get_payload_assembler(identifier)
assembler.get_payload_as_stream()
manager.on_receive(Header(id=identifier, end=True), [], 100)
self.assertTrue(assembler.end)
async def _send(self):
# determine if we know the length we can send and whether we can tell if this is the end
is_length_known = self._is_end
header = Header(type=self.type, id=self.identifier, end=self._is_end)
header.payload_length = 0
if self._stream_length is not None:
# determine how many bytes we can send and if we are at the end
header.payload_length = min(
self._stream_length - self._send_offset,
TransportConstants.MAX_PAYLOAD_LENGTH,
)
header.end = (self._send_offset + header.payload_length >=
self._stream_length)
is_length_known = True
self.sender.send_payload(header, self._stream, is_length_known,
self._on_send)
async def test_process_request(self):
# Arrange
header_id: UUID = uuid4()
header = Header(type="A", id=header_id, end=True)
header.payload_length = 3
stream_manager = MockStreamManager()
on_completed_called = False
async def mock_on_completed(identifier: UUID, request: ReceiveRequest):
nonlocal on_completed_called
assert identifier == header_id
assert request.verb == "POST"
assert request.path == "/api/messages"
assert len(request.streams) == 1
on_completed_called = True
sut = ReceiveRequestAssembler(header,
stream_manager,
on_completed=mock_on_completed)
# Act
stream_id: UUID = uuid4()
streams: List[StreamDescription] = [
StreamDescription(id=str(stream_id),
content_type="json",
length=100)
]
payload = RequestPayload(verb="POST",
path="/api/messages",
streams=streams).to_json()
payload_stream: List[int] = list(bytes(payload, "utf-8"))
await sut.process_request(payload_stream)
# Assert
assert on_completed_called
def test_close_stream_end_no_op(self):
closed = False
def mock_cancel_stream(_: PayloadStreamAssembler):
nonlocal closed
closed = True
manager = StreamManager(on_cancel_stream=mock_cancel_stream)
identifier: UUID = uuid4()
assembler = manager.get_payload_assembler(identifier)
assembler.get_payload_as_stream()
assembler.on_receive(Header(end=True), [], 1) # Set it as ended
manager.close_stream(identifier)
self.assertFalse(closed)
def test_serializes_to_ascii(self):
header = Header()
header.type = PayloadTypes.REQUEST
header.payload_length = 168
header.id = uuid4()
header.end = True
buffer: List[int] = [None] * TransportConstants.MAX_PAYLOAD_LENGTH
offset: int = 0
length = HeaderSerializer.serialize(header, buffer, offset)
decoded = bytes(buffer[offset:length]).decode("ascii")
self.assertEqual(f"A.000168.{str(header.id)}.1\n", decoded)
def test_can_round_trip(self):
header = Header()
header.type = PayloadTypes.REQUEST
header.payload_length = 168
header.id = uuid4()
header.end = True
buffer: List[int] = [None] * TransportConstants.MAX_PAYLOAD_LENGTH
offset: int = 0
length = HeaderSerializer.serialize(header, buffer, offset)
result = HeaderSerializer.deserialize(buffer, 0, length)
self.assertEqual(header.type, result.type)
self.assertEqual(header.payload_length, result.payload_length)
self.assertEqual(header.id, result.id)
self.assertEqual(header.end, result.end)
def test_on_receive_not_exists_no_op(self):
manager = StreamManager(None)
identifier: UUID = uuid4()
manager.on_receive(Header(id=identifier), [], 100)