def test_call_malformed(self):
get = hdr.SOMEIPHeader(
service_id=self.prot.service_id,
method_id=1,
client_id=0xCCCC,
session_id=0xDDDD,
protocol_version=1,
interface_version=self.prot.version_major,
message_type=hdr.SOMEIPMessageType.REQUEST,
return_code=hdr.SOMEIPReturnCode.E_OK,
payload=b"\xff\xff",
)
self.prot.message_received(get, self.fake_addr, False)
self.mock.sendto.assert_called_once_with(
replace(
get,
payload=b"",
message_type=hdr.SOMEIPMessageType.ERROR,
return_code=hdr.SOMEIPReturnCode.E_MALFORMED_MESSAGE,
).build(),
self.fake_addr,
)
self.mock.reset_mock()
async def _notify_single(self, endpoint: header.EndpointOption[typing.Any],
events: typing.Iterable[int]) -> None:
addr = await endpoint.addrinfo()
msgbuf = bytearray()
for event_id in events:
payload = self.values[event_id]
self.log.info("notifying 0x%04x to %r: %r", event_id, addr,
payload)
_, session_id = self.service.session_storage.assign_outgoing(addr)
hdr = header.SOMEIPHeader(
service_id=self.service.service_id,
method_id=0x8000 | event_id,
client_id=0,
session_id=session_id,
message_type=header.SOMEIPMessageType.NOTIFICATION,
interface_version=self.service.version_major,
payload=payload,
)
msgbuf += hdr.build()
if msgbuf:
self.service.send(msgbuf, addr)
async def test_someip_stream_async(self):
bytes_reader = asyncio.StreamReader()
someip_reader = hdr.SOMEIPReader(bytes_reader)
async def consume(reader):
return await reader.read()
bytes_reader.feed_data(b"\xde\xad\xbe\xef")
bytes_reader.feed_data(b"\x00\x00")
bytes_reader.feed_data(b"\x00\x08\xcc\xcc")
bytes_reader.feed_data(b"\xdd\xdd\x01\x02\x40\x04")
bytes_reader.feed_data(
b"\xde\xad\xbe\xef\x00\x00\x00\x0a" b"\xcc\xcc\xdd\xdd\x01\x02\x40\x04"
)
parsed = await someip_reader.read()
message = hdr.SOMEIPHeader(
service_id=0xDEAD,
method_id=0xBEEF,
client_id=0xCCCC,
session_id=0xDDDD,
protocol_version=1,
interface_version=2,
message_type=hdr.SOMEIPMessageType.REQUEST_ACK,
return_code=hdr.SOMEIPReturnCode.E_NOT_READY,
)
self.assertEqual(parsed, message)
bytes_reader.feed_data(b"\xaa\x55")
bytes_reader.feed_eof()
parsed = await someip_reader.read()
message = hdr.SOMEIPHeader(
service_id=0xDEAD,
method_id=0xBEEF,
client_id=0xCCCC,
session_id=0xDDDD,
protocol_version=1,
interface_version=2,
message_type=hdr.SOMEIPMessageType.REQUEST_ACK,
return_code=hdr.SOMEIPReturnCode.E_NOT_READY,
payload=b"\xaa\x55",
)
self.assertEqual(parsed, message)
self.assertTrue(someip_reader.at_eof())
def test_call_good(self):
get = hdr.SOMEIPHeader(
service_id=self.prot.service_id,
method_id=1,
client_id=0xCCCC,
session_id=0xDDDD,
protocol_version=1,
interface_version=self.prot.version_major,
message_type=hdr.SOMEIPMessageType.REQUEST,
return_code=hdr.SOMEIPReturnCode.E_OK,
)
inc = replace(get,
method_id=2,
message_type=hdr.SOMEIPMessageType.REQUEST_NO_RETURN)
self.prot.message_received(get, self.fake_addr, False)
self.mock.sendto.assert_called_once_with(
replace(get,
message_type=hdr.SOMEIPMessageType.RESPONSE,
payload=b"\0\0").build(),
self.fake_addr,
)
self.mock.reset_mock()
# stays the same
self.prot.message_received(get, self.fake_addr, False)
self.mock.sendto.assert_called_once_with(
replace(get,
message_type=hdr.SOMEIPMessageType.RESPONSE,
payload=b"\0\0").build(),
self.fake_addr,
)
self.mock.reset_mock()
# increment twice
self.prot.message_received(inc, self.fake_addr, False)
self.prot.message_received(inc, self.fake_addr, False)
self.mock.sendto.assert_not_called()
self.mock.reset_mock()
# counter changed
self.prot.message_received(get, self.fake_addr, False)
self.mock.sendto.assert_called_once_with(
replace(get,
message_type=hdr.SOMEIPMessageType.RESPONSE,
payload=b"\0\2").build(),
self.fake_addr,
)
self.mock.reset_mock()
def test_call_multicast(self):
get = hdr.SOMEIPHeader(
service_id=self.prot.service_id,
method_id=1,
client_id=0xCCCC,
session_id=0xDDDD,
protocol_version=1,
interface_version=self.prot.version_major,
message_type=hdr.SOMEIPMessageType.REQUEST,
return_code=hdr.SOMEIPReturnCode.E_OK,
)
with self.assertWarnsRegex(UserWarning, r"(?i)multicast"):
self.prot.message_received(get, self.fake_addr, True)
def test_someip_no_payload(self):
payload = b"\xde\xad\xbe\xef\x00\x00\x00\x08\xcc\xcc\xdd\xdd\x01\x02\x40\x04"
message = hdr.SOMEIPHeader(
service_id=0xDEAD,
method_id=0xBEEF,
client_id=0xCCCC,
session_id=0xDDDD,
protocol_version=1,
interface_version=2,
message_type=hdr.SOMEIPMessageType.REQUEST_ACK,
return_code=hdr.SOMEIPReturnCode.E_NOT_READY,
)
self._check(payload, message, hdr.SOMEIPHeader.parse)
async def _notify_single(
self, endpoint: header.EndpointOption[typing.Any]) -> None:
addr = await endpoint.addrinfo()
payload = self.value
self.log.info("notifying to %r: %r", addr, payload)
_, session_id = self.service.session_storage.assign_outgoing(addr)
hdr = header.SOMEIPHeader(
service_id=self.service.service_id,
method_id=0x8000 | self.id,
client_id=0,
session_id=session_id,
message_type=header.SOMEIPMessageType.NOTIFICATION,
interface_version=self.service.version_major,
payload=payload,
)
self.service.send(hdr.build(), addr)
def test_someip_with_payload_rest(self):
payload = (
b"\xde\xad\xbe\xef\x00\x00\x00\x0a\xcc\xcc\xdd\xdd\x01\x02\x40\x04\xaa\x55"
)
message = hdr.SOMEIPHeader(
service_id=0xDEAD,
method_id=0xBEEF,
client_id=0xCCCC,
session_id=0xDDDD,
protocol_version=1,
interface_version=2,
message_type=hdr.SOMEIPMessageType.REQUEST_ACK,
return_code=hdr.SOMEIPReturnCode.E_NOT_READY,
payload=b"\xaa\x55",
)
self._check(payload, message, hdr.SOMEIPHeader.parse, extra=b"\1\2\3\4")
def test_call_bad_code(self):
get = hdr.SOMEIPHeader(
service_id=self.prot.service_id,
method_id=1,
client_id=0xCCCC,
session_id=0xDDDD,
protocol_version=1,
interface_version=self.prot.version_major,
message_type=hdr.SOMEIPMessageType.REQUEST,
return_code=hdr.SOMEIPReturnCode.E_NOT_READY,
)
with self.assertLogs(self.prot.log, "WARNING"):
self.prot.message_received(get, self.fake_addr, False)
self.mock.sendto.assert_called_once_with(
replace(
get,
message_type=hdr.SOMEIPMessageType.ERROR,
return_code=hdr.SOMEIPReturnCode.E_WRONG_MESSAGE_TYPE,
).build(),
self.fake_addr,
)
self.mock.reset_mock()
def test_call_unknown_method(self):
get = hdr.SOMEIPHeader(
service_id=self.prot.service_id,
method_id=0x7777,
client_id=0xCCCC,
session_id=0xDDDD,
protocol_version=1,
interface_version=self.prot.version_major,
message_type=hdr.SOMEIPMessageType.REQUEST_NO_RETURN,
return_code=hdr.SOMEIPReturnCode.E_OK,
)
with self.assertLogs(self.prot.log, "WARNING"):
self.prot.message_received(get, self.fake_addr, False)
self.mock.sendto.assert_called_once_with(
replace(
get,
message_type=hdr.SOMEIPMessageType.ERROR,
return_code=hdr.SOMEIPReturnCode.E_UNKNOWN_METHOD,
).build(),
self.fake_addr,
)
self.mock.reset_mock()
def test_call_bad_version(self):
get = hdr.SOMEIPHeader(
service_id=self.prot.service_id,
method_id=1,
client_id=0xCCCC,
session_id=0xDDDD,
protocol_version=1,
interface_version=13,
message_type=hdr.SOMEIPMessageType.REQUEST_NO_RETURN,
return_code=hdr.SOMEIPReturnCode.E_OK,
)
with self.assertLogs(self.prot.log, "WARNING"):
self.prot.message_received(get, self.fake_addr, False)
self.mock.sendto.assert_called_once_with(
replace(
get,
message_type=hdr.SOMEIPMessageType.ERROR,
return_code=hdr.SOMEIPReturnCode.E_WRONG_INTERFACE_VERSION,
).build(),
self.fake_addr,
)
self.mock.reset_mock()
async def test_subscribe_eventgroup_two_clients(self):
sub1 = sd.EventgroupSubscription(
service_id=self.prot.service_id,
instance_id=self.prot.instance_id,
major_version=self.prot.version_major,
id=1,
counter=0,
ttl=ticks(3),
endpoints=frozenset({self.endpoint}),
)
self.prot.client_subscribed(sub1, self.fake_addr)
fake_addr2 = ("192.0.2.42", 30501)
endpoint2 = hdr.IPv4EndpointOption(
ipaddress.IPv4Address(fake_addr2[0]),
port=fake_addr2[1],
l4proto=hdr.L4Protocols.UDP,
)
sub2 = sd.EventgroupSubscription(
service_id=self.prot.service_id,
instance_id=self.prot.instance_id,
major_version=self.prot.version_major,
id=1,
counter=0,
ttl=ticks(3),
endpoints=frozenset({endpoint2}),
)
self.prot.client_subscribed(sub2, fake_addr2)
notification = hdr.SOMEIPHeader(
service_id=self.prot.service_id,
method_id=0x8001,
client_id=0,
session_id=0,
interface_version=self.prot.version_major,
message_type=hdr.SOMEIPMessageType.NOTIFICATION,
)
# ignore notification after subscribe
await asyncio.sleep(ticks(0.1))
self.mock.reset_mock()
# cyclic notification
await asyncio.sleep(ticks(1.1))
self.assertCountEqual(
self.mock.sendto.call_args_list,
(
unittest.mock.call(
replace(
notification,
session_id=2,
payload=b"\0\0",
).build(),
self.fake_addr,
),
unittest.mock.call(
replace(
notification,
session_id=2,
payload=b"\0\0",
).build(),
fake_addr2,
),
),
)
self.mock.reset_mock()
self.prot.client_unsubscribed(sub2, fake_addr2)
# one client removed -> one remaining cyclic notification
await asyncio.sleep(ticks(1.1))
self.assertCountEqual(
self.mock.sendto.call_args_list,
(unittest.mock.call(
replace(
notification,
session_id=3,
payload=b"\0\0",
).build(),
self.fake_addr,
), ),
)
self.mock.reset_mock()
self.prot.client_unsubscribed(sub1, self.fake_addr)
# cyclic notification
await asyncio.sleep(ticks(1.1))
self.mock.sendto.assert_not_called()
async def test_subscribe_eventgroup(self):
sub = sd.EventgroupSubscription(
service_id=self.prot.service_id,
instance_id=self.prot.instance_id,
major_version=self.prot.version_major,
id=1,
counter=0,
ttl=ticks(3),
endpoints=frozenset({self.endpoint}),
)
self.prot.client_subscribed(sub, self.fake_addr)
notification = hdr.SOMEIPHeader(
service_id=self.prot.service_id,
method_id=0x8001,
client_id=0,
session_id=0,
interface_version=self.prot.version_major,
message_type=hdr.SOMEIPMessageType.NOTIFICATION,
)
# notification after subscribe
await asyncio.sleep(ticks(0.1))
self.mock.sendto.assert_called_once_with(
replace(
notification,
session_id=1,
payload=b"\0\0",
).build(),
self.fake_addr,
)
self.mock.reset_mock()
# cyclic notification
await asyncio.sleep(ticks(1.1))
self.mock.sendto.assert_called_once_with(
replace(
notification,
session_id=2,
payload=b"\0\0",
).build(),
self.fake_addr,
)
self.mock.reset_mock()
inc = hdr.SOMEIPHeader(
service_id=self.prot.service_id,
method_id=2,
client_id=0xCCCC,
session_id=0xDDDD,
protocol_version=1,
interface_version=self.prot.version_major,
message_type=hdr.SOMEIPMessageType.REQUEST_NO_RETURN,
)
self.prot.message_received(inc, self.fake_addr, False)
# cyclic notification
await asyncio.sleep(ticks(1.1))
self.mock.sendto.assert_called_once_with(
replace(
notification,
session_id=3,
payload=b"\0\1",
).build(),
self.fake_addr,
)
self.mock.reset_mock()
