def test_http_server_queue_item_add_handler_4(re_manager,
fastapi_server): # noqa: F811
"""
Add instruction ('queue_stop') to the queue.
"""
plan1 = {"name": "count", "args": [["det1"]], "item_type": "plan"}
plan2 = {"name": "count", "args": [["det1", "det2"]], "item_type": "plan"}
instruction = {"name": "queue_stop", "item_type": "instruction"}
# Create the queue with 2 entries
resp1 = request_to_json("post", "/queue/item/add", json={"item": plan1})
assert resp1["success"] is True, f"resp={resp1}"
resp2 = request_to_json("post",
"/queue/item/add",
json={"item": instruction})
assert resp2["success"] is True, f"resp={resp2}"
resp3 = request_to_json("post", "/queue/item/add", json={"item": plan2})
assert resp3["success"] is True, f"resp={resp3}"
resp4 = request_to_json("get", "/queue/get")
assert len(resp4["items"]) == 3
assert resp4["items"][0]["item_type"] == "plan"
assert resp4["items"][1]["item_type"] == "instruction"
assert resp4["items"][2]["item_type"] == "plan"
def test_http_server_queue_item_update_2_fail(re_manager, fastapi_server,
replace): # noqa F811
"""
Failing cases for `queue_item_update`: submitted item UID does not match any UID in the queue.
"""
resp1 = request_to_json("post", "/queue/item/add", json={"item": _plan1})
assert resp1["success"] is True
assert resp1["qsize"] == 1
assert resp1["item"]["name"] == _plan1["name"]
assert resp1["item"]["args"] == _plan1["args"]
assert "item_uid" in resp1["item"]
plan = resp1["item"]
plan_changed = plan.copy()
plan_changed["args"] = [["det1"]]
plan_changed["item_uid"] = "incorrect_uid"
params = {"item": plan_changed}
if replace is not None:
params["replace"] = replace
resp2 = request_to_json("post", "/queue/item/update", json=params)
assert resp2["success"] is False
assert resp2["msg"] == "Failed to add an item: Failed to replace item: " \
"Item with UID 'incorrect_uid' is not in the queue"
resp3 = request_to_json("get", "/queue/get")
assert resp3["items"] != []
assert len(resp3["items"]) == 1
assert resp3["items"][0] == plan
assert resp3["running_item"] == {}
def test_http_server_reload_permissions(re_manager_pc_copy, fastapi_server,
tmp_path): # noqa F811
"""
Tests for ``/permissions/reload`` API.
"""
pc_path = copy_default_profile_collection(tmp_path)
append_code_to_last_startup_file(pc_path,
additional_code=_sample_trivial_plan1)
# Generate the new list of allowed plans and devices and reload them
gen_list_of_plans_and_devices(startup_dir=pc_path,
file_dir=pc_path,
overwrite=True)
plan = {
"item": {
"name": "trivial_plan_for_unit_test",
"item_type": "plan"
}
}
# Attempt to add the plan to the queue. The request is supposed to fail, because
# the initially loaded profile collection does not contain the plan.
resp1 = request_to_json("post", "/queue/item/add", json=plan)
assert resp1["success"] is False, str(resp1)
# Reload profile collection
resp2 = request_to_json("post", "/permissions/reload")
assert resp2["success"] is True, str(resp2)
# Attempt to add the plan to the queue. It should be successful now.
resp3 = request_to_json("post", "/queue/item/add", json=plan)
assert resp3["success"] is True, str(resp3)
assert resp3["qsize"] == 1, str(resp3)
def test_http_server_plans_allowed_and_devices(re_manager,
fastapi_server): # noqa F811
resp1 = request_to_json("get", "/plans/allowed")
assert isinstance(resp1["plans_allowed"], dict)
assert len(resp1["plans_allowed"]) > 0
resp2 = request_to_json("get", "/devices/allowed")
assert isinstance(resp2["devices_allowed"], dict)
assert len(resp2["devices_allowed"]) > 0
def test_http_server_move_plan_1(re_manager, fastapi_server, params, src,
order, success, msg): # noqa F811
"""
The tests are derived from the ZMQ API tests. The number of tests are reduced to save time.
"""
plans = [
{
"name": "count",
"args": [["det1"]],
"item_type": "plan"
},
{
"name": "count",
"args": [["det2"]],
"item_type": "plan"
},
{
"name": "count",
"args": [["det1", "det2"]],
"item_type": "plan"
},
]
for plan in plans:
request_to_json("post", "/queue/item/add", json={"item": plan})
resp1 = request_to_json("get", "/queue/get")
queue = resp1["items"]
assert len(queue) == 3
item_uids = [_["item_uid"] for _ in queue]
# Add one more 'nonexistent' uid (that is not in the queue)
item_uids.append("nonexistent")
# Replace indices with actual UIDs that will be sent to the function
if "uid" in params:
params["uid"] = item_uids[params["uid"]]
if "before_uid" in params:
params["before_uid"] = item_uids[params["before_uid"]]
if "after_uid" in params:
params["after_uid"] = item_uids[params["after_uid"]]
resp2 = request_to_json("post", "/queue/item/move", json=params)
if success:
assert resp2["success"] is True
assert resp2["item"] == queue[src]
assert resp2["qsize"] == len(plans)
assert resp2["msg"] == ""
# Compare the order of UIDs in the queue with the expected order
item_uids_reordered = [item_uids[_] for _ in order]
resp3 = request_to_json("get", "/queue/get")
item_uids_from_queue = [_["item_uid"] for _ in resp3["items"]]
assert item_uids_from_queue == item_uids_reordered
else:
assert resp2["success"] is False
assert msg in resp2["msg"]
def test_http_server_queue_item_get_remove_handler_2(
re_manager,
fastapi_server,
pos,
pos_result,
success # noqa F811
):
plans = [
{
"name": "count",
"args": [["det1"]],
"item_type": "plan"
},
{
"name": "count",
"args": [["det2"]],
"item_type": "plan"
},
{
"name": "count",
"args": [["det1", "det2"]],
"item_type": "plan"
},
]
for plan in plans:
request_to_json("post", "/queue/item/add", json={"item": plan})
# Remove entry at the specified position
params = {} if pos is None else {"pos": pos}
# Testing '/queue/item/get'
resp1 = request_to_json("post", "/queue/item/get", json=params)
assert resp1["success"] is success
if success:
assert resp1["item"]["args"] == plans[pos_result]["args"]
assert "item_uid" in resp1["item"]
assert resp1["msg"] == ""
else:
assert resp1["item"] == {}
assert "Failed to get an item" in resp1["msg"]
# Testing '/queue/item/remove'
resp2 = request_to_json("post", "/queue/item/remove", json=params)
assert resp2["success"] is success
assert resp2["qsize"] == (2 if success else None)
if success:
assert resp2["item"]["args"] == plans[pos_result]["args"]
assert "item_uid" in resp2["item"]
assert resp2["msg"] == ""
else:
assert resp2["item"] == {}
assert "Failed to remove an item" in resp2["msg"]
resp3 = request_to_json("get", "/queue/get")
assert len(resp3["items"]) == (2 if success else 3)
assert resp3["running_item"] == {}
def test_http_server_manager_stop_handler_1(re_manager, fastapi_server,
option): # noqa F811
request_to_json("post", "/environment/open")
assert wait_for_environment_to_be_created(10), "Timeout"
kwargs = {"json": {"option": option} if option else {}}
resp1 = request_to_json("post", "/manager/stop", **kwargs)
assert resp1["success"] is True
assert re_manager.check_if_stopped() is True
def test_http_server_secure_1(monkeypatch, re_manager_cmd, fastapi_server_fs,
test_mode): # noqa: F811
"""
Test operation of HTTP server with enabled encryption. Security of HTTP server can be enabled
only by setting the environment variable to the value of the public key.
"""
public_key, private_key = generate_new_zmq_key_pair()
if test_mode == "none":
# No encryption
pass
elif test_mode == "ev":
# Set server private key using environment variable
monkeypatch.setenv("QSERVER_ZMQ_PRIVATE_KEY",
private_key) # RE Manager
monkeypatch.setenv("QSERVER_ZMQ_PUBLIC_KEY", public_key) # HTTP server
set_qserver_zmq_public_key(
monkeypatch, server_public_key=public_key) # For test functions
else:
raise RuntimeError(f"Unrecognized test mode '{test_mode}'")
fastapi_server_fs()
re_manager_cmd([])
resp1 = request_to_json("post", "/queue/item/add", json={"item": _plan1})
assert resp1["success"] is True, str(resp1)
resp2 = request_to_json("post", "/queue/item/add", json={"item": _plan2})
assert resp2["success"] is True, str(resp2)
resp3 = request_to_json("get", "/plans/allowed")
assert isinstance(resp3["plans_allowed"], dict)
assert len(resp3["plans_allowed"]) > 0
resp4 = request_to_json("get", "/devices/allowed")
assert isinstance(resp4["devices_allowed"], dict)
assert len(resp4["devices_allowed"]) > 0
resp5 = request_to_json("post", "/environment/open")
assert resp5["success"] is True
assert wait_for_environment_to_be_created(10)
resp6 = request_to_json("get", "/status")
assert resp6["items_in_queue"] == 2
assert resp6["items_in_history"] == 0
resp7 = request_to_json("post", "/queue/start")
assert resp7["success"] is True
wait_for_queue_execution_to_complete(20)
resp8 = request_to_json("get", "/status")
assert resp8["items_in_queue"] == 0
assert resp8["items_in_history"] == 2
# Close the environment
resp9 = request_to_json("post", "/environment/close")
assert resp9 == {"success": True, "msg": ""}
wait_for_manager_state_idle(10)
def test_http_server_queue_item_add_handler_3(re_manager,
fastapi_server): # noqa F811
# Unknown plan name
plan1 = {
"item": {
"name": "count_test",
"args": [["det1", "det2"]],
"item_type": "plan"
}
}
resp1 = request_to_json("post", "/queue/item/add", json=plan1)
assert resp1["success"] is False
assert "Plan 'count_test' is not in the list of allowed plans" in resp1[
"msg"]
# Unknown kwarg
plan2 = {
"item": {
"name": "count",
"args": [["det1", "det2"]],
"kwargs": {
"abc": 10
},
"item_type": "plan"
}
}
resp2 = request_to_json("post", "/queue/item/add", json=plan2)
assert resp2["success"] is False
assert (
"Failed to add an item: Plan validation failed: got an unexpected keyword argument 'abc'"
in resp2["msg"])
# Valid plan
plan3 = {
"item": {
"name": "count",
"args": [["det1", "det2"]],
"item_type": "plan"
}
}
resp3 = request_to_json("post", "/queue/item/add", json=plan3)
assert resp3["success"] is True
assert resp3["qsize"] == 1
assert resp3["item"]["name"] == "count"
assert resp3["item"]["args"] == [["det1", "det2"]]
assert "item_uid" in resp3["item"]
resp4 = request_to_json("get", "/queue/get")
assert resp4["items"] != []
assert len(resp4["items"]) == 1
assert resp4["items"][0] == resp3["item"]
assert resp4["running_item"] == {}
def test_http_server_open_environment_handler(re_manager,
fastapi_server): # noqa F811
resp1 = request_to_json("post", "/environment/open")
assert resp1 == {"success": True, "msg": ""}
assert wait_for_environment_to_be_created(10), "Timeout"
resp2 = request_to_json("post", "/environment/open")
assert resp2 == {
"success": False,
"msg": "RE Worker environment already exists."
}
def test_http_server_clear_queue_handler_1(re_manager,
fastapi_server): # noqa F811
add_plans_to_queue()
resp1 = request_to_json("get", "/queue/get")
assert len(resp1["items"]) == 3
resp2 = request_to_json("post", "/queue/clear")
assert resp2["success"] is True
assert resp2["msg"] == ""
resp3 = request_to_json("get", "/queue/get")
assert len(resp3["items"]) == 0
def test_http_server_queue_upload_spreasheet_5(re_manager, fastapi_server_fs,
tmp_path,
monkeypatch): # noqa F811
"""
Test for ``/queue/upload/spreadsheet``. Test the case when one of the plans is not accepted by
RE Manager. The API is expected to return ``success==False``, error message. Items in ``result``
will contain ``success`` status and error message for each plan.
"""
monkeypatch.setenv(
"BLUESKY_HTTPSERVER_CUSTOM_MODULE",
"bluesky_queueserver.server.tests.http_custom_proc_functions",
prepend=False,
)
fastapi_server_fs()
plan_params = [["count", 5, 1], ["nonexisting_plan", 4, 0.7],
["count", 6, 0.5]]
col_names = ["name", "num", "delay"]
ss_path, plans_expected = _create_test_excel_file1(tmp_path,
plan_params=plan_params,
col_names=col_names)
# Send the Excel file to the server
files = {"spreadsheet": open(ss_path, "rb")}
resp1 = request_to_json("post", "/queue/upload/spreadsheet", files=files)
assert resp1["success"] is False, str(resp1)
assert resp1[
"msg"] == "Failed to add all items: validation of 1 out of 3 submitted items failed"
items, results = resp1["items"], resp1["results"]
assert len(items) == len(plans_expected), str(items)
assert len(results) == len(plans_expected), str(items)
for n, p_exp in enumerate(plans_expected):
p, r = items[n], results[n]
if p_exp["name"] == "nonexisting_plan":
assert r["success"] is False
assert "not in the list of allowed plans" in r["msg"], r["msg"]
else:
assert r["success"] is True
assert r["msg"] == ""
for k, v in p_exp.items():
assert k in p
assert v == p[k]
# No plans are expected to be added to the queue
resp2 = request_to_json("get", "/status")
assert resp2["items_in_queue"] == 0
assert resp2["items_in_history"] == 0
def test_http_server_status_handler(re_manager, fastapi_server): # noqa F811
resp = request_to_json("get", "/status")
assert resp["msg"] == "RE Manager"
assert resp["manager_state"] == "idle"
assert resp["items_in_queue"] == 0
assert resp["running_item_uid"] is None
assert resp["worker_environment_exists"] is False
def test_http_server_queue_upload_spreasheet_2(re_manager, fastapi_server_fs,
tmp_path,
monkeypatch): # noqa F811
"""
Test for ``/queue/upload/spreadsheet`` API. Test that ``data_type`` parameter is passed correctly.
The test function raises exception if ``data_type=='unsupported'``, which causes the request to
return error message. Verify that correct error message is returned.
"""
monkeypatch.setenv(
"BLUESKY_HTTPSERVER_CUSTOM_MODULE",
"bluesky_queueserver.server.tests.http_custom_proc_functions",
prepend=False,
)
fastapi_server_fs()
plan_params = [["count", 5, 1], ["count", 6, 0.5]]
col_names = ["name", "num", "delay"]
ss_path, plans_expected = _create_test_excel_file1(tmp_path,
plan_params=plan_params,
col_names=col_names)
# Send the Excel file to the server
files = {"spreadsheet": open(ss_path, "rb")}
data = {"data_type": "unsupported"}
resp1 = request_to_json("post",
"/queue/upload/spreadsheet",
files=files,
data=data)
assert resp1["success"] is False, str(resp1)
assert resp1["msg"] == "Unsupported data type: 'unsupported'"
assert resp1["items"] == []
assert resp1["results"] == []
def test_http_server_queue_upload_spreasheet_3(re_manager, fastapi_server_fs,
tmp_path,
monkeypatch): # noqa F811
"""
Test for ``/queue/upload/spreadsheet`` API. Pass file of unsupported type (file types are found based
on file extension) and check the returned error message.
"""
monkeypatch.setenv(
"BLUESKY_HTTPSERVER_CUSTOM_MODULE",
"bluesky_queueserver.server.tests.http_custom_proc_functions",
prepend=False,
)
fastapi_server_fs()
plan_params = [["count", 5, 1], ["count", 6, 0.5]]
col_names = ["name", "num", "delay"]
ss_path, plans_expected = _create_test_excel_file1(tmp_path,
plan_params=plan_params,
col_names=col_names)
# Rename .xlsx file to .txt file. This should cause processing error, since only .xlsx files are supported.
new_ext = ".txt"
new_path = os.path.splitext(ss_path)[0] + new_ext
os.rename(ss_path, new_path)
# Send the Excel file to the server
files = {"spreadsheet": open(new_path, "rb")}
resp1 = request_to_json("post", "/queue/upload/spreadsheet", files=files)
assert resp1["success"] is False, str(resp1)
assert resp1["msg"] == f"Unsupported file (extension '{new_ext}')"
def test_http_server_manager_kill(re_manager, fastapi_server): # noqa F811
request_to_json("post", "/environment/open")
assert wait_for_environment_to_be_created(10), "Timeout"
resp = request_to_json("post", "/test/manager/kill")
assert resp["success"] is False
assert "ZMQ communication error:" in resp["msg"]
ttime.sleep(10)
resp = request_to_json("get", "/status")
assert resp["msg"] == "RE Manager"
assert resp["manager_state"] == "idle"
assert resp["items_in_queue"] == 0
assert resp["running_item_uid"] is None
assert resp["worker_environment_exists"] is True
def test_http_server_re_runs(re_manager, fastapi_server, suffix,
expected_n_items): # noqa F811
"""
Basic test for ``/re/run/...`` API. The API is tested on a single run plan.
"""
resp1 = request_to_json("post", "/queue/item/add", json={"item": _plan3})
assert resp1["success"] is True
assert resp1["qsize"] == 1
request_to_json("post", "/environment/open")
assert wait_for_environment_to_be_created(10), "Timeout"
request_to_json("post", "/queue/start")
ttime.sleep(2)
status = request_to_json("get", "/status")
assert status["manager_state"] == "executing_queue"
run_list_uid = status["run_list_uid"]
assert isinstance(run_list_uid, str)
req = "/re/runs" + suffix
resp2 = request_to_json("get", req)
assert resp2["success"] is True
assert len(resp2["run_list"]) == expected_n_items
assert resp2["run_list_uid"] == run_list_uid
assert wait_for_manager_state_idle(30), "Timeout"
def test_http_server_close_print_db_uids_handler(re_manager,
fastapi_server): # noqa F811
add_plans_to_queue()
resp1 = request_to_json("post", "/environment/open")
assert resp1 == {"success": True, "msg": ""}
assert wait_for_environment_to_be_created(10), "Timeout"
resp2 = request_to_json("post", "/queue/start")
assert resp2 == {"success": True, "msg": ""}
ttime.sleep(15)
resp2a = request_to_json("get", "/queue/get")
assert len(resp2a["items"]) == 0
assert resp2a["running_item"] == {}
def test_http_server_close_environment_handler(re_manager,
fastapi_server): # noqa F811
resp1 = request_to_json("post", "/environment/open")
assert resp1 == {"success": True, "msg": ""}
assert wait_for_environment_to_be_created(10), "Timeout"
resp2 = request_to_json("post", "/environment/close")
assert resp2 == {"success": True, "msg": ""}
ttime.sleep(
3
) # TODO: API needed to test if environment is closed. Use delay for now.
resp3 = request_to_json("post", "/environment/close")
assert resp3 == {
"success": False,
"msg": "RE Worker environment does not exist."
}
def test_http_server_queue_item_add_handler_5_fail(
re_manager, fastapi_server): # noqa F811
"""
Failing case: call without sending a plan.
"""
resp1 = request_to_json("post", "/queue/item/add", json={})
assert resp1["success"] is False
assert resp1["qsize"] is None
assert resp1["item"] is None
assert "Incorrect request format: request contains no item info" in resp1[
"msg"]
def test_http_server_re_pause_continue_handlers(
re_manager,
fastapi_server,
option_pause,
option_continue # noqa F811
):
resp1 = request_to_json("post", "/environment/open")
assert resp1 == {"success": True, "msg": ""}
assert wait_for_environment_to_be_created(10), "Timeout"
resp2 = request_to_json(
"post",
"/queue/item/add",
json={
"item": {
"name": "count",
"args": [["det1", "det2"]],
"kwargs": {
"num": 10,
"delay": 1
},
"item_type": "plan",
}
},
)
assert resp2["success"] is True
assert resp2["qsize"] == 1
assert resp2["item"]["name"] == "count"
assert resp2["item"]["args"] == [["det1", "det2"]]
assert "item_uid" in resp2["item"]
resp3 = request_to_json("post", "/queue/start")
assert resp3 == {"success": True, "msg": ""}
ttime.sleep(
3.5
) # Let some time pass before pausing the plan (fractional number of seconds)
resp3a = request_to_json("post",
"/re/pause",
json={"option": option_pause})
assert resp3a == {"msg": "", "success": True}
ttime.sleep(2) # TODO: API is needed
resp3b = request_to_json("get", "/queue/get")
assert len(
resp3b["items"]) == 0 # The plan is paused, but it is not in the queue
assert resp3b["running_item"] != {} # Running plan is set
resp4 = request_to_json("post", f"/re/{option_continue}")
assert resp4 == {"msg": "", "success": True}
ttime.sleep(15) # TODO: we need to wait for plan completion
resp4a = request_to_json("get", "/queue/get")
# The plan returns to the queue if it is stopped
assert len(resp4a["items"]) == 0 if option_continue == "resume" else 1
assert resp4a["running_item"] == {}
def test_http_server_queue_start_handler(re_manager,
fastapi_server): # noqa F811
add_plans_to_queue()
resp1 = request_to_json("post", "/queue/start")
assert resp1 == {
"success": False,
"msg": "RE Worker environment does not exist."
}
resp2 = request_to_json("post", "/environment/open")
assert resp2 == {"success": True, "msg": ""}
resp2a = request_to_json("get", "/queue/get")
assert len(resp2a["items"]) == 3
assert resp2a["running_item"] == {}
assert wait_for_environment_to_be_created(10), "Timeout"
resp3 = request_to_json("post", "/queue/start")
assert resp3 == {"success": True, "msg": ""}
ttime.sleep(1)
# The plan is currently being executed. 'get_queue' is expected to return currently executed plan.
resp4 = request_to_json("get", "/queue/get")
assert len(resp4["items"]) == 2
assert resp4["running_item"][
"name"] == "count" # Check name of the running plan
ttime.sleep(25) # Wait until all plans are executed
resp4 = request_to_json("get", "/queue/get")
assert len(resp4["items"]) == 0
assert resp2a["running_item"] == {}
def test_http_server_queue_item_add_handler_2(re_manager, fastapi_server, pos,
pos_result,
success): # noqa F811
plan1 = {"name": "count", "args": [["det1"]], "item_type": "plan"}
plan2 = {"name": "count", "args": [["det1", "det2"]], "item_type": "plan"}
# Create the queue with 2 entries
request_to_json("post", "/queue/item/add", json={"item": plan1})
request_to_json("post", "/queue/item/add", json={"item": plan1})
# Add another entry at the specified position
params = {"item": plan2}
if pos is not None:
params.update({"pos": pos})
resp1 = request_to_json("post", "/queue/item/add", json=params)
assert resp1["success"] is success
assert resp1["qsize"] == (3 if success else None)
assert resp1["item"]["name"] == "count"
assert resp1["item"]["args"] == plan2["args"]
assert "item_uid" in resp1["item"]
resp2 = request_to_json("get", "/queue/get")
assert len(resp2["items"]) == (3 if success else 2)
assert resp2["running_item"] == {}
if success:
assert resp2["items"][pos_result]["args"] == plan2["args"]
def test_http_server_queue_item_update_1(re_manager, fastapi_server,
replace): # noqa F811
"""
Basic test for `/queue/item/update` API.
"""
resp1 = request_to_json("post", "/queue/item/add", json={"item": _plan1})
assert resp1["success"] is True, f"resp={resp1}"
assert resp1["qsize"] == 1
assert resp1["item"]["name"] == _plan1["name"]
assert resp1["item"]["args"] == _plan1["args"]
assert "item_uid" in resp1["item"]
plan = resp1["item"]
uid = plan["item_uid"]
plan_changed = plan.copy()
plan_new_args = [["det1"]]
plan_changed["args"] = plan_new_args
params = {"item": plan_changed}
if replace is not None:
params["replace"] = replace
resp2 = request_to_json("post", "/queue/item/update", json=params)
assert resp2["success"] is True
assert resp2["qsize"] == 1
assert resp2["item"]["name"] == _plan1["name"]
assert resp2["item"]["args"] == plan_new_args
assert "item_uid" in resp2["item"]
if replace:
assert resp2["item"]["item_uid"] != uid
else:
assert resp2["item"]["item_uid"] == uid
resp3 = request_to_json("get", "/queue/get")
assert resp3["items"] != []
assert len(resp3["items"]) == 1
assert resp3["items"][0] == resp2["item"]
assert resp3["running_item"] == {}
def test_http_server_queue_item_get_remove_handler_1(
re_manager, fastapi_server): # noqa F811
add_plans_to_queue()
resp1 = request_to_json("get", "/queue/get")
assert resp1["items"] != []
assert len(resp1["items"]) == 3
assert resp1["running_item"] == {}
resp2 = request_to_json("post", "/queue/item/get", json={})
assert resp2["success"] is True
assert resp2["item"]["name"] == "count"
assert resp2["item"]["args"] == [["det1", "det2"]]
assert "item_uid" in resp2["item"]
resp3 = request_to_json("post", "/queue/item/remove", json={})
assert resp3["success"] is True
assert resp3["qsize"] == 2
assert resp3["item"]["name"] == "count"
assert resp3["item"]["args"] == [["det1", "det2"]]
assert "item_uid" in resp3["item"]
def test_http_server_queue_item_add_handler_1(re_manager,
fastapi_server): # noqa F811
resp1 = request_to_json(
"post",
"/queue/item/add",
json={
"item": {
"name": "count",
"args": [["det1", "det2"]],
"item_type": "plan"
}
},
)
assert resp1["success"] is True
assert resp1["qsize"] == 1
assert resp1["item"]["name"] == "count"
assert resp1["item"]["args"] == [["det1", "det2"]]
assert "item_uid" in resp1["item"]
resp2 = request_to_json("get", "/queue/get")
assert resp2["items"] != []
assert len(resp2["items"]) == 1
assert resp2["items"][0] == resp1["item"]
assert resp2["running_item"] == {}
def test_http_server_queue_item_get_remove_handler_4_failing(
re_manager, fastapi_server): # noqa F811
"""
Failing cases that are not tested in other places.
Note: derived from ``test_zmq_api_queue_item_get_remove_4_failing()``
"""
# Ambiguous parameters
resp1 = request_to_json("post",
"/queue/item/get",
json={
"pos": 5,
"uid": "some_uid",
"item_uid": "plan"
})
assert resp1["success"] is False
assert "Ambiguous parameters" in resp1["msg"]
def test_http_server_manager_stop_handler_2(re_manager, fastapi_server,
option): # noqa F811
add_plans_to_queue()
request_to_json("post", "/environment/open")
assert wait_for_environment_to_be_created(10), "Timeout"
request_to_json("post", "/queue/start")
ttime.sleep(2)
resp = request_to_json("get", "/status")
assert resp["msg"] == "RE Manager"
assert resp["manager_state"] == "executing_queue"
assert resp["items_in_queue"] == 2
assert resp["running_item_uid"] is not None
assert resp["items_in_history"] == 0
assert resp["worker_environment_exists"] is True
# Attempt to stop
kwargs = {"json": {"option": option} if option else {}}
resp1 = request_to_json("post", "/manager/stop", **kwargs)
assert resp1["success"] == (option == "safe_off")
if option == "safe_off":
assert re_manager.check_if_stopped() is True
else:
# The queue is expected to be running
ttime.sleep(15)
resp = request_to_json("get", "/status")
assert resp["msg"] == "RE Manager"
assert resp["manager_state"] == "idle"
assert resp["items_in_queue"] == 0
assert resp["items_in_history"] == 3
assert resp["running_item_uid"] is None
assert resp["worker_environment_exists"] is True
def test_http_server_set_zmq_address_1(monkeypatch, re_manager_cmd,
fastapi_server_fs): # noqa: F811
"""
Test if ZMQ address of RE Manager is passed to the HTTP server using 'QSERVER_ZMQ_ADDRESS' environment
variable. Start RE Manager and HTTP server with ZMQ address for control communication channel
different from default address, add and execute a plan.
"""
# Change ZMQ address to use port 60616 instead of the default port 60615.
zmq_server_address = "tcp://localhost:60616"
monkeypatch.setenv("QSERVER_ZMQ_ADDRESS", zmq_server_address) # RE Manager
fastapi_server_fs()
set_qserver_zmq_address(monkeypatch, zmq_server_address=zmq_server_address)
re_manager_cmd(["--zmq-addr", "tcp://*:60616"])
# Now execute a plan to make sure everything works as expected
resp1 = request_to_json("post", "/queue/item/add", json={"item": _plan1})
assert resp1["success"] is True, str(resp1)
resp5 = request_to_json("post", "/environment/open")
assert resp5["success"] is True
assert wait_for_environment_to_be_created(10)
resp6 = request_to_json("get", "/status")
assert resp6["items_in_queue"] == 1
assert resp6["items_in_history"] == 0
resp7 = request_to_json("post", "/queue/start")
assert resp7["success"] is True
wait_for_queue_execution_to_complete(20)
resp8 = request_to_json("get", "/status")
assert resp8["items_in_queue"] == 0
assert resp8["items_in_history"] == 1
# Close the environment
resp9 = request_to_json("post", "/environment/close")
assert resp9 == {"success": True, "msg": ""}
wait_for_manager_state_idle(10)
def test_http_server_queue_stop(re_manager, fastapi_server,
deactivate): # noqa F811
"""
Methods ``queue_stop_activate`` and ``queue_stop_deactivate``.
"""
add_plans_to_queue()
request_to_json("post", "/environment/open")
assert wait_for_environment_to_be_created(10), "Timeout"
# Queue is not running, so the request is expected to fail
resp1 = request_to_json("post", "/queue/stop")
assert resp1["success"] is False
status = request_to_json("get", "/status")
assert status["queue_stop_pending"] is False
request_to_json("post", "/queue/start")
ttime.sleep(2)
status = request_to_json("get", "/status")
assert status["manager_state"] == "executing_queue"
resp2 = request_to_json("post", "/queue/stop")
assert resp2["success"] is True
status = request_to_json("get", "/status")
assert status["queue_stop_pending"] is True
if deactivate:
ttime.sleep(1)
resp3 = request_to_json("post", "/queue/stop/cancel")
assert resp3["success"] is True
status = request_to_json("get", "/status")
assert status["queue_stop_pending"] is False
ttime.sleep(15)
status = request_to_json("get", "/status")
assert status["manager_state"] == "idle"
assert status["items_in_queue"] == (0 if deactivate else 2)
assert status["items_in_history"] == (3 if deactivate else 1)
assert status["running_item_uid"] is None
assert status["worker_environment_exists"] is True
assert status["queue_stop_pending"] is False
