def test_request_serialization():
wait_time = 1000
can_frame = CANFrame(
1, bytearray([0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]))
request = Request(can_frame, wait_time)
reference_map = {'canFrame': can_frame.to_map(), 'waitTime': wait_time}
assert reference_map == request.to_map()
def test_dummy_data_conversion(data):
bytes_as_array = None
if isinstance(data, str):
bytes_as_array = bytearray(data, 'utf8')
else:
bytes_as_array = bytearray(data)
assert CANFrame.unmarshalling_data(
CANFrame.marshalling_data(bytes_as_array)) == bytes_as_array
def test_data_serialization_CANFrame(id, bytes, data):
bytes_as_array = None
if isinstance(bytes, str):
bytes_as_array = bytearray(bytes, 'utf8')
else:
bytes_as_array = bytearray(bytes)
can_frame = CANFrame(id, bytes_as_array)
can_frame_map = can_frame.to_map()
assert can_frame_map == reference_map(id, data, can_frame.timestamp)
def test_extract_CANFrame_from_obj(id, in_bytes, data):
bytes_as_array = None
if isinstance(in_bytes, str):
bytes_as_array = bytearray(in_bytes, 'utf8')
else:
bytes_as_array = bytearray(in_bytes)
actual_frame = CANFrame(id, bytes_as_array)
expected_frame = CANFrame.from_obj(
reference_obj(id, data, actual_frame.timestamp, actual_frame.response))
assert expected_frame == actual_frame
def generate_request():
# Generate random request to device
data_length = random.randint(1, 7)
data = bytearray((random.getrandbits(8) for i in range(data_length)))
frame_id = fuzz_ids[random.randint(0, len(fuzz_ids) - 1)]
can_frame = CANFrame(frame_id, data)
request = Request(can_frame, 100)
return request
def get_reference_can_frame():
can_frame_1 = CANFrame(530, bytearray('123asd', 'utf8'))
can_frame_1.set_timestamp(1494429336205)
can_frame_2 = CANFrame(533, bytearray('asdqwe', 'utf8'))
can_frame_2.set_timestamp(1494429336206)
list_of_can_frames = ListAsMappable(lambda x: x)
list_of_can_frames.populate([can_frame_1, can_frame_2])
frames = CANFrames(list_of_can_frames)
frames.set_id(2)
return frames
def get_reference_can_request():
ecu_id = 0x700
can_frame_1 = CANFrame(ecu_id, bytearray('test-test', 'utf8'))
can_frame_2 = CANFrame(ecu_id, bytearray('asdqwezxc', 'utf8'))
can_frame_1.set_timestamp(1494508949810)
can_frame_2.set_timestamp(1494508949811)
requests = [Request(can_frame_1, 100),
Request(can_frame_2, 100)]
can_request = CANRequest(1, Query(requests, CANResponseFilter.CANResponseFilter.NONE()))
can_request.set_id(2)
return can_request
def test_query_serialization():
wait_time = 1000
can_frame = CANFrame(
1, bytearray([0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]))
request = Request(can_frame, wait_time)
query = Query([request], CANResponseFilter.NONE())
query_as_map = query.to_map()
reference_map = {
'requests': [request.to_map()],
'canResponseFilter': CANResponseFilter.NONE().to_map()
}
assert reference_map == query_as_map
def test_custom_equality_fail():
can_frame = CANFrame(
1, bytearray([0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]))
assert not can_frame == {}
# get authentication token
token = api.authenticate(key, secret)
# get available devices, Device.TEST_DEVICE is always available
devices = api.get_connected_devices(token)
# find available device
device = None
for dev in devices:
if dev.is_available_now():
device = dev
print("Selected device: " + device.name)
break
# connect to it
cloud = api.connect_to_device(token, device)
# create CAN frame, with id 0x700 and data
can_frame = CANFrame(0x700, bytearray([0x1]))
# create request to send the can frame
# and collect all responses from CAN bus for 300 ms
request = Request(can_frame, 300)
try:
responses = cloud.send_can_frames([request], CANResponseFilter.NONE())
for response in responses:
frame_ids = {hex(x.frame_id) for x in response.iterator()}
print("Request ID: " + hex(response.request.frame_id))
print("Unique ids: " + str(len(frame_ids)))
print("IDs: " + str(frame_ids))
finally:
cloud.close()