def test_parse_args(delete_env_vars: None) -> None:
args: Namespace = \
parse_args(["--host", "127.0.0.1",
"--port", "8888",
"--debug",
"--run-dir", str(base_dir.joinpath("tests/run")),
"--disable-get-runs",
"--disable-workflow-attachment",
"--run-only-registered-workflows",
"--service-info",
str(base_dir.joinpath("sapporo/service-info.json")),
"--executable-workflows",
str(base_dir.joinpath("sapporo/executable_workflows.json")), # noqa: E501
"--run-sh",
str(base_dir.joinpath("sapporo/run.sh"))])
params: Dict[str, Union[str, int, Path]] = handle_default_params(args)
app: Flask = create_app(params)
assert params["host"] == "127.0.0.1"
assert params["port"] == 8888
assert params["debug"] is True
assert app.config["RUN_DIR"] == base_dir.joinpath("tests/run")
assert app.config["GET_RUNS"] is False
assert app.config["WORKFLOW_ATTACHMENT"] is False
assert app.config["REGISTERED_ONLY_MODE"] is True
assert app.config["SERVICE_INFO"] == \
base_dir.joinpath("sapporo/service-info.json")
assert app.config["EXECUTABLE_WORKFLOWS"] == \
base_dir.joinpath("sapporo/executable_workflows.json")
assert app.config["RUN_SH"] == \
base_dir.joinpath("sapporo/run.sh")
def test_get_runs(delete_env_vars: None, tmpdir: LocalPath) -> None:
args: Namespace = parse_args(["--run-dir", str(tmpdir)])
params: Dict[str, Union[str, int, Path]] = handle_default_params(args)
app: Flask = create_app(params)
app.debug = params["debug"] # type: ignore
app.testing = True
client: FlaskClient[Response] = app.test_client()
from .post_runs_tests.test_access_remote_files_cwltool \
import access_remote_files
posts_res: Response = access_remote_files(client)
posts_res_data: RunId = posts_res.get_json()
assert posts_res.status_code == 200
run_id: str = posts_res_data["run_id"]
sleep(3)
res: Response = get_runs(client)
res_data: RunListResponse = res.get_json()
assert res.status_code == 200
assert "runs" in res_data
assert len(res_data["runs"]) == 1
assert "run_id" in res_data["runs"][0]
assert "state" in res_data["runs"][0]
assert run_id == res_data["runs"][0]["run_id"]
def test_disable_workflow_attachment(delete_env_vars: None,
tmpdir: LocalPath) -> None:
args = parse_args(
["--disable-workflow-attachment", "--run-dir",
str(tmpdir)])
params = handle_default_params(args)
app = create_app(params)
app.debug = params["debug"] # type: ignore
app.testing = True
client = app.test_client()
from .test_post_runs.cwltool.test_attach_all_files import \
post_runs_attach_all_files_with_flask
post_runs_data = post_runs_attach_all_files_with_flask(client)
run_id = post_runs_data["run_id"]
from .test_get_run_id_status import get_run_id_status
count = 0
while count <= 120:
sleep(3)
get_status_res = get_run_id_status(client, run_id)
get_status_data = get_status_res.get_json()
if get_status_data["state"] == "EXECUTOR_ERROR":
break
count += 1
assert str(get_status_data["state"]) == "EXECUTOR_ERROR"
from .test_get_run_id import get_run_id
detail_res: Response = get_run_id(client, run_id)
detail_res_data: RunLog = detail_res.get_json()
assert detail_res.status_code == 200
assert detail_res_data["run_log"]["exit_code"] == 1
assert "Not found" in detail_res_data["run_log"]["stderr"]
def test_registered_only_mode(delete_env_vars: None) -> None:
args: Namespace = parse_args([
"--debug",
"--disable-get-runs",
"--run-only-registered-workflows",
])
params: Dict[str, Union[str, int, Path]] = handle_default_params(args)
app: Flask = create_app(params)
app.debug = params["debug"] # type: ignore
app.testing = True
client: FlaskClient[Response] = app.test_client()
res: Response = client.get("/service-info")
res_data: ServiceInfo = res.get_json()
assert res.status_code == 200
assert "auth_instructions_url" in res_data
assert "contact_info_url" in res_data
assert "default_workflow_engine_parameters" in res_data
assert "supported_wes_versions" in res_data
assert res_data["supported_wes_versions"][0] == "sapporo-wes-1.1"
assert "system_state_counts" in res_data
assert "tags" in res_data
assert bool(res_data["tags"]["debug"]) is True
assert bool(res_data["tags"]["get_runs"]) is False
assert bool(res_data["tags"]["registered_only_mode"]) is True
assert "run_dir" in res_data["tags"]
assert res_data["tags"]["wes_name"] == "sapporo"
assert "workflow_engine_versions" in res_data
assert "workflow_type_versions" in res_data
assert "executable_workflows" in res_data
def test_original_wes_mode(delete_env_vars: None) -> None:
args = parse_args([])
params = handle_default_params(args)
app = create_app(params)
app.debug = params["debug"] # type: ignore
app.testing = True
client = app.test_client()
res = client.get("/service-info")
res_data: ServiceInfo = res.get_json()
assert res.status_code == 200
assert "auth_instructions_url" in res_data
assert "contact_info_url" in res_data
assert "default_workflow_engine_parameters" in res_data
assert "executable_workflows" in res_data
assert "supported_filesystem_protocols" in res_data
assert "supported_wes_versions" in res_data
assert res_data["supported_wes_versions"][0] == "sapporo-wes-1.0.0"
assert "system_state_counts" in res_data
assert "tags" in res_data
assert bool(res_data["tags"]["debug"]) is False
assert bool(res_data["tags"]["get_runs"]) is True
assert bool(res_data["tags"]["registered_only_mode"]) is False
assert res_data["tags"]["wes_name"] == "sapporo"
assert bool(res_data["tags"]["workflow_attachment"]) is True
assert "workflow_engine_versions" in res_data
assert "workflow_type_versions" in res_data
def test_download_link(delete_env_vars: None, tmpdir: LocalPath) -> None:
args = parse_args(["--run-dir", str(tmpdir)])
params = handle_default_params(args)
app = create_app(params)
app.debug = params["debug"] # type: ignore
app.testing = True
client = app.test_client()
run_id = str(uuid4())
run_dir = Path(tmpdir).joinpath(f"{run_id[:2]}/{run_id}")
run_dir.mkdir(parents=True, exist_ok=True)
with run_dir.joinpath("run_request.json").open(mode="w") as f:
f.write("")
with run_dir.joinpath("test.txt").open(mode="w") as f:
f.write("test")
run_dir.joinpath("test").mkdir(parents=True, exist_ok=True)
with run_dir.joinpath("test/test.txt").open(mode="w") as f:
f.write("test")
res = client.get(f"/runs/{run_id}/data/test.txt")
assert res.data.decode("utf-8") == "test"
res = client.get(f"/runs/{run_id}/data/test")
res_data = res.json
assert "test" == res_data["name"]
assert "." == res_data["path"]
assert "directory" == res_data["type"]
assert "children" in res_data
assert "test.txt" == res_data["children"][0]["name"]
assert "test.txt" == res_data["children"][0]["path"]
assert "file" == res_data["children"][0]["type"]
res = client.get(f"/runs/{run_id}/data/test?download=true")
assert res.status_code == 200
def test_env_vars(delete_env_vars: None, monkeypatch: MonkeyPatch) -> None:
monkeypatch.setenv("SAPPORO_HOST", "127.0.0.1")
monkeypatch.setenv("SAPPORO_PORT", "8888")
monkeypatch.setenv("SAPPORO_DEBUG", "True")
monkeypatch.setenv("SAPPORO_RUN_DIR", str(base_dir.joinpath("tests/run")))
monkeypatch.setenv("SAPPORO_GET_RUNS", "False")
monkeypatch.setenv("SAPPORO_WORKFLOW_ATTACHMENT", "False")
monkeypatch.setenv("SAPPORO_RUN_ONLY_REGISTERED_WORKFLOWS", "True")
monkeypatch.setenv("SAPPORO_SERVICE_INFO",
str(base_dir.joinpath("sapporo/service-info.json")))
monkeypatch.setenv(
"SAPPORO_EXECUTABLE_WORKFLOWS",
str(base_dir.joinpath(
"sapporo/executable_workflows.json"))) # noqa: E501
monkeypatch.setenv("SAPPORO_RUN_SH",
str(base_dir.joinpath("sapporo/run.sh")))
args: Namespace = parse_args([])
params: Dict[str, Union[str, int, Path]] = handle_default_params(args)
app: Flask = create_app(params)
assert params["host"] == "127.0.0.1"
assert params["port"] == 8888
assert params["debug"] is True
assert app.config["RUN_DIR"] == base_dir.joinpath("tests/run")
assert app.config["GET_RUNS"] is False
assert app.config["WORKFLOW_ATTACHMENT"] is False
assert app.config["REGISTERED_ONLY_MODE"] is True
assert app.config["SERVICE_INFO"] == \
base_dir.joinpath("sapporo/service-info.json")
assert app.config["EXECUTABLE_WORKFLOWS"] == \
base_dir.joinpath("sapporo/executable_workflows.json")
assert app.config["RUN_SH"] == \
base_dir.joinpath("sapporo/run.sh")
def test_url_prefix(delete_env_vars: None) -> None:
args = parse_args(["--url-prefix", "/test"])
params = handle_default_params(args)
app = create_app(params)
app.debug = params["debug"] # type: ignore
app.testing = True
client = app.test_client()
res = client.get("/test/service-info")
assert res.status_code == 200
def test_cwl_attach_in_config(delete_env_vars: None, tmpdir: LocalPath) \
-> None:
args: Namespace = parse_args([
"--run-dir",
str(tmpdir), "--disable-workflow-attachment",
"--run-only-registered-workflows"
])
params: Dict[str, Union[str, int, Path]] = handle_default_params(args)
app: Flask = create_app(params)
app.debug = params["debug"] # type: ignore
app.testing = True
client: FlaskClient[Response] = app.test_client()
posts_res: Response = cwl_attach_in_config(client)
posts_res_data: RunId = posts_res.get_json()
assert posts_res.status_code == 200
assert "run_id" in posts_res_data
run_id: str = posts_res_data["run_id"]
from ..test_get_run_id_status import get_run_id_status
count: int = 0
while count <= 60:
get_status_res: Response = get_run_id_status(client, run_id)
get_status_data: RunStatus = get_status_res.get_json()
if get_status_data["state"] == "COMPLETE": # type: ignore
break
sleep(1)
count += 1
from ..test_get_run_id import get_run_id
detail_res: Response = get_run_id(client, run_id)
detail_res_data: RunLog = detail_res.get_json()
print(detail_res_data)
assert detail_res.status_code == 200
assert "ERR034597_1.small.fq.trimmed.1P.fq" in detail_res_data["outputs"]
assert "ERR034597_1.small.fq.trimmed.1U.fq" in detail_res_data["outputs"]
assert "ERR034597_1.small.fq.trimmed.2P.fq" in detail_res_data["outputs"]
assert "ERR034597_1.small.fq.trimmed.2U.fq" in detail_res_data["outputs"]
assert "ERR034597_1.small_fastqc.html" in detail_res_data["outputs"]
assert "ERR034597_2.small_fastqc.html" in detail_res_data["outputs"]
assert len(detail_res_data["request"]["workflow_attachment"]) == 2
assert "cwltool" == detail_res_data["request"]["workflow_engine_name"]
assert "CWL_trimming_and_qc_local" == \
detail_res_data["request"]["workflow_name"]
assert "CWL" == detail_res_data["request"]["workflow_type"]
assert "v1.0" == detail_res_data["request"]["workflow_type_version"]
assert REMOTE_LOCATION + "trimming_and_qc.cwl" == \
detail_res_data["request"]["workflow_url"]
assert run_id == detail_res_data["run_id"]
assert detail_res_data["run_log"]["exit_code"] == 0
assert "Final process status is success" in \
detail_res_data["run_log"]["stderr"]
assert "COMPLETE" == detail_res_data["state"] # type: ignore
def test_disable_get_runs(delete_env_vars: None, tmpdir: LocalPath) -> None:
args = parse_args(["--disable-get-runs", "--run-dir", str(tmpdir)])
params = handle_default_params(args)
app = create_app(params)
app.debug = params["debug"] # type: ignore
app.testing = True
client = app.test_client()
from .test_get_runs import get_runs
get_runs_res = get_runs(client)
get_runs_data = get_runs_res.get_json()
assert get_runs_res.status_code == 403
assert "status_code" in get_runs_data
assert get_runs_data["status_code"] == 403
assert "msg" in get_runs_data
def test_default_params(delete_env_vars: None) -> None:
args: Namespace = parse_args([])
params: Dict[str, Union[str, int, Path]] = handle_default_params(args)
app: Flask = create_app(params)
assert params["host"] == DEFAULT_HOST
assert params["port"] == DEFAULT_PORT
assert params["debug"] is False
assert app.config["GET_RUNS"] is True
assert app.config["WORKFLOW_ATTACHMENT"] is True
assert app.config["REGISTERED_ONLY_MODE"] is False
assert app.config["SERVICE_INFO"] == \
base_dir.joinpath("sapporo/service-info.json")
assert app.config["EXECUTABLE_WORKFLOWS"] == \
base_dir.joinpath("sapporo/executable_workflows.json")
assert app.config["RUN_SH"] == \
base_dir.joinpath("sapporo/run.sh")
def test_disable_get_runs(delete_env_vars: None, tmpdir: LocalPath) -> None:
args: Namespace = parse_args(
["--disable-get-runs", "--run-dir",
str(tmpdir)])
params: Dict[str, Union[str, int, Path]] = handle_default_params(args)
app: Flask = create_app(params)
app.debug = params["debug"] # type: ignore
app.testing = True
client: FlaskClient[Response] = app.test_client()
from .test_get_runs import get_runs
get_runs_res: Response = get_runs(client)
get_runs_data: ErrorResponse = get_runs_res.get_json()
assert get_runs_res.status_code == 403
assert "status_code" in get_runs_data
assert get_runs_data["status_code"] == 403
assert "msg" in get_runs_data
def test_get_run_id(delete_env_vars: None, tmpdir: LocalPath) -> None:
args: Namespace = parse_args(["--run-dir", str(tmpdir)])
params: Dict[str, Union[str, int, Path]] = handle_default_params(args)
app: Flask = create_app(params)
app.debug = params["debug"] # type: ignore
app.testing = True
client: FlaskClient[Response] = app.test_client()
from .post_runs_tests.test_access_remote_files_cwltool \
import access_remote_files
posts_res: Response = access_remote_files(client)
posts_res_data: RunId = posts_res.get_json()
assert posts_res.status_code == 200
run_id: str = posts_res_data["run_id"]
sleep(3)
res: Response = get_run_id(client, run_id)
res_data: RunLog = res.get_json()
assert res.status_code == 200
assert "run_id" in res_data
assert run_id == res_data["run_id"]
assert "request" in res_data
assert "workflow_params" in res_data["request"]
assert "workflow_type" in res_data["request"]
assert "workflow_type_version" in res_data["request"]
assert "tags" in res_data["request"]
assert "workflow_engine_name" in res_data["request"]
assert "workflow_engine_parameters" in res_data["request"]
assert "workflow_url" in res_data["request"]
assert "state" in res_data
assert "run_log" in res_data
assert "name" in res_data["run_log"]
assert "cmd" in res_data["run_log"]
assert "start_time" in res_data["run_log"]
assert "end_time" in res_data["run_log"]
assert "stdout" in res_data["run_log"]
assert "stderr" in res_data["run_log"]
assert "exit_code" in res_data["run_log"]
assert "task_logs" in res_data
assert "outputs" in res_data
def test_get_runs(delete_env_vars: None, tmpdir: LocalPath) -> None:
args = parse_args(["--run-dir", str(tmpdir)])
params = handle_default_params(args)
app = create_app(params)
app.debug = params["debug"] # type: ignore
app.testing = True
client = app.test_client()
from .test_post_runs.cwltool.test_remote_workflow import \
post_runs_remote_workflow_with_flask
posts_res_data = post_runs_remote_workflow_with_flask(client)
run_id: str = posts_res_data["run_id"]
sleep(3)
res = get_run_id_status(client, run_id)
res_data: RunStatus = res.get_json()
assert res.status_code == 200
assert "run_id" in res_data
assert "state" in res_data
assert run_id == res_data["run_id"]
def test_post_run_id_cancel(delete_env_vars: None, tmpdir: LocalPath) -> None:
args = parse_args(["--run-dir", str(tmpdir)])
params = handle_default_params(args)
app = create_app(params)
app.debug = params["debug"] # type: ignore
app.testing = True
client = app.test_client()
from .test_post_runs.cwltool.test_remote_workflow import \
post_runs_remote_workflow_with_flask
posts_res_data = post_runs_remote_workflow_with_flask(client)
run_id: str = posts_res_data["run_id"]
sleep(3)
posts_cancel_res: Response = post_run_id_cancel(client, run_id)
posts_cancel_res_data: RunId = posts_cancel_res.get_json()
assert posts_cancel_res.status_code == 200
assert "run_id" in posts_cancel_res_data
assert run_id == posts_cancel_res_data["run_id"]
from .test_get_run_id_status import get_run_id_status
count: int = 0
while count <= 120:
sleep(3)
get_status_res: Response = get_run_id_status(client, run_id)
get_status_data: RunStatus = get_status_res.get_json()
if str(get_status_data["state"]) in \
["COMPLETE", "EXECUTOR_ERROR", "SYSTEM_ERROR", "CANCELED"]:
break
count += 1
assert str(get_status_data["state"]) == "CANCELED"
from .test_get_run_id import get_run_id
detail_res: Response = get_run_id(client, run_id)
detail_res_data: RunLog = detail_res.get_json()
assert detail_res.status_code == 200
assert detail_res_data["run_log"]["exit_code"] == 138
def test_get_run_id(delete_env_vars: None, tmpdir: LocalPath) -> None:
args = parse_args(["--run-dir", str(tmpdir)])
params = handle_default_params(args)
app = create_app(params)
app.debug = params["debug"] # type: ignore
app.testing = True
client = app.test_client()
from .test_post_runs.cwltool.test_remote_workflow import \
post_runs_remote_workflow_with_flask
posts_res_data = post_runs_remote_workflow_with_flask(client)
run_id = posts_res_data["run_id"]
sleep(3)
res = get_run_id(client, run_id)
res_data: RunLog = res.get_json()
assert res.status_code == 200
assert "run_id" in res_data
assert run_id == res_data["run_id"]
assert "request" in res_data
assert "workflow_params" in res_data["request"]
assert "workflow_type" in res_data["request"]
assert "workflow_type_version" in res_data["request"]
assert "tags" in res_data["request"]
assert "workflow_engine_name" in res_data["request"]
assert "workflow_engine_parameters" in res_data["request"]
assert "workflow_url" in res_data["request"]
assert "state" in res_data
assert "run_log" in res_data
assert "name" in res_data["run_log"]
assert "cmd" in res_data["run_log"]
assert "start_time" in res_data["run_log"]
assert "end_time" in res_data["run_log"]
assert "stdout" in res_data["run_log"]
assert "stderr" in res_data["run_log"]
assert "exit_code" in res_data["run_log"]
assert "task_logs" in res_data
assert "outputs" in res_data
def test_post_run_id_cancel(delete_env_vars: None, tmpdir: LocalPath) -> None:
args: Namespace = parse_args(["--run-dir", str(tmpdir)])
params: Dict[str, Union[str, int, Path]] = handle_default_params(args)
app: Flask = create_app(params)
app.debug = params["debug"] # type: ignore
app.testing = True
client: FlaskClient[Response] = app.test_client()
from .post_runs_tests.test_access_remote_files_cwltool \
import access_remote_files
posts_res: Response = access_remote_files(client)
posts_res_data: RunId = posts_res.get_json()
assert posts_res.status_code == 200
run_id: str = posts_res_data["run_id"]
sleep(3)
posts_cancel_res: Response = post_run_id_cancel(client, run_id)
posts_cancel_res_data: RunId = posts_cancel_res.get_json()
assert posts_cancel_res.status_code == 200
assert "run_id" in posts_cancel_res_data
assert run_id == posts_cancel_res_data["run_id"]
from .test_get_run_id_status import get_run_id_status
count: int = 0
while count <= 60:
get_status_res: Response = get_run_id_status(client, run_id)
get_status_data: RunStatus = get_status_res.get_json()
if get_status_data["state"] == "CANCELED": # type: ignore
break
sleep(1)
count += 1
from .test_get_run_id import get_run_id
detail_res: Response = get_run_id(client, run_id)
detail_res_data: RunLog = detail_res.get_json()
assert detail_res.status_code == 200
assert detail_res_data["run_log"]["exit_code"] == 138
def test_disable_workflow_attachment(delete_env_vars: None,
tmpdir: LocalPath) -> None:
args: Namespace = parse_args(
["--disable-workflow-attachment", "--run-dir",
str(tmpdir)])
params: Dict[str, Union[str, int, Path]] = handle_default_params(args)
app: Flask = create_app(params)
app.debug = params["debug"] # type: ignore
app.testing = True
client: FlaskClient[Response] = app.test_client()
from .post_runs_tests.test_attach_all_files_cwltool \
import attach_all_files
post_runs_res: Response = attach_all_files(client)
post_runs_data: RunId = post_runs_res.get_json()
assert post_runs_res.status_code == 200
run_id: str = post_runs_data["run_id"]
from .test_get_run_id_status import get_run_id_status
count: int = 0
while count <= 60:
get_status_res: Response = get_run_id_status(client, run_id)
get_status_data: RunStatus = get_status_res.get_json()
if get_status_data["state"] == "EXECUTOR_ERROR": # type: ignore
break
sleep(1)
count += 1
from .test_get_run_id import get_run_id
detail_res: Response = get_run_id(client, run_id)
detail_res_data: RunLog = detail_res.get_json()
assert detail_res.status_code == 200
assert detail_res_data["run_log"]["exit_code"] == 1
assert "Not found" in detail_res_data["run_log"]["stderr"]
#!/usr/bin/env python3
# coding: utf-8
from pathlib import Path
from typing import Dict, Union
from flask import Flask
from sapporo.app import create_app, handle_default_params, parse_args
params: Dict[str, Union[str, int, Path]] = \
handle_default_params(parse_args([]))
app: Flask = create_app(params)