def test_handle_set_should_succeed(sender, device_state):
with get_actuator_agent(vip_rpc_call_res=MockedAsyncResult({"foo": "bar"}), device_state=device_state) as actuator_agent:
actuator_agent.handle_set(PEER, sender, BUS, SET_TOPIC, HEADERS, MESSAGE)
actuator_agent.vip.rpc.call.assert_called_once()
actuator_agent.vip.pubsub.publish.assert_called()
def test_handle_get_should_succeed():
with get_actuator_agent() as actuator_agent:
actuator_agent.handle_get(PEER, SENDER, BUS, GET_TOPIC, HEADERS,
MESSAGE)
actuator_agent.vip.rpc.call.assert_called_once()
actuator_agent.vip.pubsub.publish.assert_called_once()
def test_request_new_schedule_should_succeed():
with get_actuator_agent() as actuator_agent:
result = actuator_agent.request_new_schedule(REQUESTER_ID, TASK_ID,
PRIORITY_LOW,
TIME_SLOT_REQUESTS)
assert result["result"] == SUCCESS
def test_get_point_should_succeed(topic, point):
with get_actuator_agent(
vip_rpc_call_res=MockedAsyncResult(10.0)) as actuator_agent:
result = actuator_agent.get_point(topic, point=point)
actuator_agent.vip.rpc.call.assert_called_once()
assert result is not None
def test_set_multiple_points_should_raise_lock_error_on_empty_devices():
with pytest.raises(LockError):
requester_id = "requester-id-1"
topic_values = [("foo/bar", "roma_value")]
with get_actuator_agent(
vip_message_peer=requester_id) as actuator_agent:
actuator_agent.set_multiple_points("request-id-1", topic_values)
def test_set_multiple_points_should_raise_value_error(invalid_topic_values):
with pytest.raises(ValueError):
requester_id = "requester-id-1"
with get_actuator_agent(
vip_message_peer=requester_id) as actuator_agent:
actuator_agent.set_multiple_points("request-id-1",
invalid_topic_values)
def test_get_multiple_points_should_return_errors(invalid_topics):
with get_actuator_agent() as actuator_agent:
results, errors = actuator_agent.get_multiple_points(invalid_topics)
assert isinstance(results, dict)
assert isinstance(errors, dict)
assert len(errors) == 1
def test_scrape_all_should_succeed():
with get_actuator_agent(
vip_rpc_call_res=MockedAsyncResult({})) as actuator_agent:
topic = "whan/that/aprille"
result = actuator_agent.scrape_all(topic)
assert isinstance(result, dict)
def test_revert_device_should_raise_lock_error_on_empty_devices():
with pytest.raises(LockError):
requester_id = "request-id-1"
topic = "foo/bar"
with get_actuator_agent(
vip_message_peer="requester-id-1") as actuator_agent:
actuator_agent.revert_device(requester_id, topic)
def test_request_cancel_schedule_should_succeed_happy_path():
true_request_result = RequestResult(True, {}, "")
with get_actuator_agent(
cancel_schedule_result=true_request_result) as actuator_agent:
result = actuator_agent.request_cancel_schedule(REQUESTER_ID, TASK_ID)
assert result["result"] == SUCCESS
def test_set_point_should_raise_type_error(rpc_peer):
with pytest.raises(TypeError, match="Agent id must be a nonempty string"):
requester_id = "requester-id-1"
topic = "foo/bar"
value = "some value"
point = None
with get_actuator_agent(vip_message_peer=rpc_peer) as actuator_agent:
actuator_agent.set_point(requester_id, topic, value, point=point)
def test_set_point_should_raise_lock_error_on_non_matching_device():
with pytest.raises(LockError):
requester_id = "requester-id-1"
topic = "foo/bar"
value = "some value"
with get_actuator_agent(
vip_message_peer="some rpc_peer") as actuator_agent:
actuator_agent.set_point(requester_id, topic, value)
def test_get_multiple_points_should_succeed(topics):
mocked_rpc_call_res = MockedAsyncResult(({"result": "value"}, {}))
with get_actuator_agent(
vip_rpc_call_res=mocked_rpc_call_res) as actuator_agent:
results, errors = actuator_agent.get_multiple_points(topics)
assert isinstance(results, dict)
assert isinstance(errors, dict)
assert len(errors) == 0
def test_handle_schedule_request_should_succeed_on_cancel_schedule_request_type(success):
headers = {"type": "CANCEL_SCHEDULE", "requesterID": "id-123", "taskID": "12345"}
with get_actuator_agent(slot_requests_res=RequestResult(success, {}, "")) as actuator_agent:
actuator_agent.handle_schedule_request(
PEER, SENDER, BUS, REQUEST_TOPIC, headers, create_message()
)
actuator_agent.vip.pubsub.publish.assert_called()
def test_handle_set_should_handle_type_error_on_invalid_sender(caplog):
with get_actuator_agent(vip_identity=None) as actuator_agent:
actuator_agent.handle_set(PEER, None, BUS, SET_TOPIC, HEADERS, MESSAGE)
actuator_agent.vip.rpc.call.assert_not_called()
actuator_agent.vip.pubsub.publish.assert_called_once()
assert (caplog.records[-1].message ==
"Actuator Agent Error: {'type': 'TypeError', "
"'value': 'Agent id must be a nonempty string'}")
def test_handle_set_should_handle_lock_error(caplog):
with get_actuator_agent(vip_identity=None) as actuator_agent:
actuator_agent.handle_set(PEER, SENDER, BUS, SET_TOPIC, HEADERS, MESSAGE)
actuator_agent.vip.rpc.call.assert_not_called()
actuator_agent.vip.pubsub.publish.assert_called_once()
assert (
caplog.records[-1].message == "Actuator Agent Error: {'type': 'LockError', "
"'value': 'caller (sender-1) does not have this lock'}"
)
def test_request_cancel_schedule_should_fail_on_invalid_task_id():
false_request_result = RequestResult(False, {}, "TASK_ID_DOES_NOT_EXIST")
invalid_task_id = "invalid-task-id"
with get_actuator_agent(
cancel_schedule_result=false_request_result) as actuator_agent:
result = actuator_agent.request_cancel_schedule(
REQUESTER_ID, invalid_task_id)
assert result["result"] == FAILURE
assert result["info"] == "TASK_ID_DOES_NOT_EXIST"
def test_set_multiple_points_should_succeed(topic_values, device_state):
requester_id = "requester-id-1"
mocked_rpc_call_res = MockedAsyncResult(({}))
with get_actuator_agent(
vip_message_peer=requester_id,
device_state=device_state,
vip_rpc_call_res=mocked_rpc_call_res) as actuator_agent:
result = actuator_agent.set_multiple_points("request-id-1",
topic_values)
assert result == {}
def test_revert_device_should_raise_lock_error_on_non_matching_requester():
with pytest.raises(LockError):
device_state = {
"foo/bar": DeviceState("requester-id-1", "task-id-1", "anytime")
}
requester_id = "request-id-1"
topic = "foo/bar"
with get_actuator_agent(vip_message_peer="wrong-requester", device_state=device_state) \
as actuator_agent:
actuator_agent.revert_device(requester_id, topic)
def test_handle_get_should_handle_standard_error(caplog):
with get_actuator_agent(vip_identity=None) as actuator_agent:
actuator_agent.handle_get(PEER, SENDER, BUS, GET_TOPIC, HEADERS, MESSAGE)
actuator_agent.vip.rpc.call.assert_not_called()
actuator_agent.vip.pubsub.publish.assert_called_once()
assert (
caplog.records[-1].message
== "Actuator Agent Error: {'type': 'AttributeError', "
"'value': \"'ActuatorAgent' object has no attribute 'driver_vip_identity'\"}"
)
def test_handle_set_should_return_none_on_none_message(caplog):
with get_actuator_agent(vip_identity=None) as actuator_agent:
result = actuator_agent.handle_set(PEER, SENDER, BUS, SET_TOPIC, HEADERS, None)
assert result is None
actuator_agent.vip.pubsub.publish.assert_called_once()
actuator_agent.vip.rpc.call.assert_not_called()
assert (
caplog.records[-1].message
== "ValueError: {'type': 'ValueError', 'value': 'missing argument'}"
)
def test_request_new_schedule_should_fail_on_invalid_priority(
invalid_priority, expected_info):
false_request_result = RequestResult(False, {}, expected_info)
with get_actuator_agent(
slot_requests_res=false_request_result) as actuator_agent:
result = actuator_agent.request_new_schedule(REQUESTER_ID, TASK_ID,
invalid_priority,
TIME_SLOT_REQUESTS)
assert result["result"] == FAILURE
assert result["info"] == expected_info
def test_set_multiple_points_should_raise_lock_error_on_non_matching_requester(
):
with pytest.raises(LockError):
requester_id = "wrong-requester"
topic_values = [("foo/bar", "roma_value")]
device_state = {
"foo": DeviceState("requester-id-1", "task-id-1", "anytime")
}
with get_actuator_agent(vip_message_peer=requester_id, device_state=device_state) \
as actuator_agent:
actuator_agent.set_multiple_points("request-id-1", topic_values)
def test_request_new_schedule_should_fail_on_invalid_taskid(
task_id, expected_info):
false_request_result = RequestResult(False, {}, expected_info)
with get_actuator_agent(
slot_requests_res=false_request_result) as actuator_agent:
result = actuator_agent.request_new_schedule(REQUESTER_ID, task_id,
PRIORITY_LOW,
TIME_SLOT_REQUESTS)
assert result["result"] == FAILURE
assert result["info"] == expected_info
def test_request_new_schedule_should_fail_invalid_time_slot_requests(
time_slot_request, expected_info):
false_request_result = RequestResult(False, {}, expected_info)
with get_actuator_agent(
slot_requests_res=false_request_result) as actuator_agent:
result = actuator_agent.request_new_schedule(REQUESTER_ID, TASK_ID,
PRIORITY_LOW,
time_slot_request)
assert result["result"] == FAILURE
assert result["info"] == expected_info
def test_handle_revert_device_should_succeed():
device_state = {
"somedevicepath": DeviceState("sender-1", "task-id-1", "anytime")
}
with get_actuator_agent(device_state=device_state,
vip_rpc_call_res=MockedAsyncResult({"foo": "bar"})) as actuator_agent:
actuator_agent.handle_revert_device(
PEER, SENDER, BUS, REVERT_DEVICE_TOPIC, HEADERS, MESSAGE
)
actuator_agent.vip.rpc.call.assert_called_once()
actuator_agent.vip.pubsub.publish.assert_called_once()
def test_request_new_schedule_should_succeed_when_stop_start_times_overlap():
start = str(datetime.now())
end = str(datetime.now() + timedelta(seconds=1))
end2 = str(datetime.now() + timedelta(seconds=2))
time_slot_requests = [["fakedriver0", start, end],
["fakedriver0", end, end2]]
with get_actuator_agent() as actuator_agent:
result = actuator_agent.request_new_schedule(REQUESTER_ID, TASK_ID,
PRIORITY_LOW,
time_slot_requests)
assert result["result"] == SUCCESS
def test_set_point_should_succeed(point, device_state):
requester_id = "requester-id-1"
topic = "foo/bar"
value = "some value"
with get_actuator_agent(vip_message_peer=requester_id, device_state=device_state) as \
actuator_agent:
result = actuator_agent.set_point(requester_id,
topic,
value,
point=point)
assert result is not None
def test_handle_schedule_request_should_log_invalid_request_type(
invalid_request_type, caplog
):
headers = {
"type": invalid_request_type,
"requesterID": "id-123",
"taskID": "12345",
"priority": "HIGH",
}
with get_actuator_agent(vip_identity=None) as actuator_agent:
actuator_agent.handle_schedule_request(
PEER, SENDER, BUS, REQUEST_TOPIC, headers, create_message()
)
actuator_agent.vip.pubsub.publish.assert_called()
assert caplog.records[-1].message == "handle-schedule_request, invalid request type"
