cloudos-cli 2.17.0__py3-none-any.whl

tests/test_clos/test_get_user_info.py

@@ -0,0 +1,68 @@
+import mock
+import json
+import pytest
+import responses
+from cloudos_cli.clos import Cloudos
+from cloudos_cli.utils.errors import BadRequestException
+
+APIKEY = 'vnoiweur89u2ongs'
+CLOUDOS_URL = 'http://cloudos.lifebit.ai'
+
+
+@mock.patch('cloudos_cli.clos', mock.MagicMock())
+@responses.activate
+def test_get_user_info_correct_response():
+    """
+    Test 'get_user_info' to work as intended
+    """
+    body = json.dumps({"dockerRegistriesCredentials": []})
+    header = {
+        "Accept": "application/json, text/plain, */*",
+        "Content-Type": "application/json;charset=UTF-8",
+        "apikey": APIKEY
+    }
+    # mock GET method with the .json
+    responses.add(
+            responses.GET,
+            body=body,
+            url=f"{CLOUDOS_URL}/api/v1/users/me",
+            headers=header,
+            status=200)
+    # start cloudOS service
+    clos = Cloudos(apikey=APIKEY, cromwell_token=None,
+                   cloudos_url=CLOUDOS_URL)
+    # get mock response
+    response = clos.get_user_info()
+    # check the response
+    assert response['dockerRegistriesCredentials'] == []
+
+
+@mock.patch('cloudos_cli.clos', mock.MagicMock())
+@responses.activate
+def test_get_user_info_incorrect_response():
+    """
+    Test 'get_user_info' to fail with '400' response
+    """
+    # prepare error message
+    error_message = {"statusCode": 400, "code": "BadRequest",
+                     "message": "Bad Request.", "time": "2022-11-23_17:31:07"}
+    error_json = json.dumps(error_message)
+    header = {
+        "Accept": "application/json, text/plain, */*",
+        "Content-Type": "application/json;charset=UTF-8",
+        "apikey": APIKEY
+    }
+    # mock GET method with the .json
+    responses.add(
+            responses.GET,
+            url=f"{CLOUDOS_URL}/api/v1/users/me",
+            body=error_json,
+            headers=header,
+            status=400)
+    # raise 400 error
+    with pytest.raises(BadRequestException) as error:
+        # check if it failed
+        clos = Cloudos(apikey=APIKEY, cromwell_token=None,
+                       cloudos_url=CLOUDOS_URL)
+        clos.get_user_info()
+    assert "Server returned status 400." in (str(error))

tests/test_clos/test_get_workflow_list.py

@@ -0,0 +1,87 @@
+import mock
+import json
+import pytest
+import responses
+from responses import matchers
+from cloudos_cli.clos import Cloudos
+from cloudos_cli.utils.errors import BadRequestException
+from tests.functions_for_pytest import load_json_file
+
+INPUT = "tests/test_data/workflows/workflows.json"
+APIKEY = 'vnoiweur89u2ongs'
+CLOUDOS_URL = 'http://cloudos.lifebit.ai'
+WORKSPACE_ID = 'lv89ufc838sdig'
+PAGE_SIZE = 10
+PAGE = 1
+ARCHIVED_STATUS = "false"
+
+
+@mock.patch('cloudos_cli.clos', mock.MagicMock())
+@responses.activate
+def test_get_workflow_list_correct_response():
+    """
+    Test 'get_workflow_list' to work as intended
+    API request is mocked and replicated with json files
+    """
+    create_json = load_json_file(INPUT)
+    params = {"teamId": WORKSPACE_ID,
+              "pageSize": PAGE_SIZE,
+              "page": PAGE,
+              "archived.status": ARCHIVED_STATUS}
+    header = {
+        "Accept": "application/json, text/plain, */*",
+        "Content-Type": "application/json;charset=UTF-8",
+        "apikey": APIKEY
+    }
+    search_str = f"teamId={WORKSPACE_ID}&pageSize={PAGE_SIZE}&page={PAGE}&archived.status={ARCHIVED_STATUS}"
+    # mock GET method with the .json
+    responses.add(
+            responses.GET,
+            url=f"{CLOUDOS_URL}/api/v3/workflows?{search_str}",
+            body=create_json,
+            headers=header,
+            match=[matchers.query_param_matcher(params)],
+            status=200)
+    # start cloudOS service
+    clos = Cloudos(apikey=APIKEY, cromwell_token=None, cloudos_url=CLOUDOS_URL)
+    # get mock response
+    response = clos.get_workflow_list(WORKSPACE_ID)
+    # check the response
+    assert isinstance(response, list)
+    assert len(response) == 1
+
+
+@mock.patch('cloudos_cli.clos', mock.MagicMock())
+@responses.activate
+def test_get_workflow_list_incorrect_response():
+    """
+    Test 'get_workflow_list' to fail with '400' response
+    """
+    # prepare error message
+    error_message = {"statusCode": 400, "code": "BadRequest",
+                     "message": "Bad Request.", "time": "2022-11-23_17:31:07"}
+    error_json = json.dumps(error_message)
+    params = {"teamId": WORKSPACE_ID,
+              "pageSize": PAGE_SIZE,
+              "page": PAGE,
+              "archived.status": ARCHIVED_STATUS}
+    header = {
+        "Accept": "application/json, text/plain, */*",
+        "Content-Type": "application/json;charset=UTF-8",
+        "apikey": APIKEY
+    }
+    search_str = f"teamId={WORKSPACE_ID}&pageSize={PAGE_SIZE}&page={PAGE}&archived.status={ARCHIVED_STATUS}"
+    # mock GET method with the .json
+    responses.add(
+            responses.GET,
+            url=f"{CLOUDOS_URL}/api/v3/workflows?{search_str}",
+            body=error_json,
+            headers=header,
+            match=[matchers.query_param_matcher(params)],
+            status=400)
+    # raise 400 error
+    with pytest.raises(BadRequestException) as error:
+        # check if it failed
+        clos = Cloudos(apikey=APIKEY, cromwell_token=None, cloudos_url=CLOUDOS_URL)
+        clos.get_workflow_list(WORKSPACE_ID)
+    assert "Server returned status 400." in (str(error))

tests/test_clos/test_is_module.py

@@ -0,0 +1,48 @@
+"""Pytest for method Cloudos.is_module"""
+import mock
+import responses
+from responses import matchers
+from cloudos_cli.clos import Cloudos
+from tests.functions_for_pytest import load_json_file
+
+INPUT = "tests/test_data/process_workflow_list_initial_request.json"
+APIKEY = 'vnoiweur89u2ongs'
+CLOUDOS_URL = 'http://cloudos.lifebit.ai'
+WORKSPACE_ID = 'lv89ufc838sdig'
+PAGE_SIZE = 10
+PAGE = 1
+ARCHIVED_STATUS = "false"
+
+
+@mock.patch('cloudos_cli.clos', mock.MagicMock())
+@responses.activate
+def test_is_module():
+    """
+    Test 'is_module' to work as intended
+    API request is mocked and replicated with json files
+    """
+    json_data = load_json_file(INPUT)
+    params = {"teamId": WORKSPACE_ID,
+              "pageSize": PAGE_SIZE,
+              "page": PAGE,
+              "archived.status": ARCHIVED_STATUS}
+    header = {
+        "Accept": "application/json, text/plain, */*",
+        "Content-Type": "application/json;charset=UTF-8",
+        "apikey": APIKEY
+    }
+    search_str = f"teamId={WORKSPACE_ID}&pageSize={PAGE_SIZE}&page={PAGE}&archived.status={ARCHIVED_STATUS}"
+    # mock GET method with the .json
+    responses.add(
+            responses.GET,
+            url=f"{CLOUDOS_URL}/api/v3/workflows?{search_str}",
+            body=json_data,
+            headers=header,
+            match=[matchers.query_param_matcher(params)],
+            status=200)
+    # start cloudOS service
+    clos = Cloudos(apikey=APIKEY, cromwell_token=None, cloudos_url=CLOUDOS_URL)
+    # get mock response
+    response = clos.is_module(workspace_id=WORKSPACE_ID,
+                              workflow_name="multiqc")
+    assert response

tests/test_clos/test_process_job_list.py

@@ -0,0 +1,74 @@
+import json
+import pytest
+import requests_mock
+import requests
+import pandas as pd
+import numpy as np
+from cloudos_cli.clos import Cloudos
+
+input_json = "tests/test_data/process_job_list_initial_json.json"
+output_df = pd.read_csv("tests/test_data/output_df_of_results.csv",
+                        index_col=0)
+output_df_full = pd.read_csv("tests/test_data/output_df_of_results_FULL.csv",
+                             index_col=0)
+
+
+@pytest.fixture()
+def mocked_requests_get():
+    test_workspace_id = 1
+    with open(input_json) as json_data:
+        d = json.load(json_data)
+    with requests_mock.Mocker() as mock:
+        mock.get(f"http://test_cloud_os/api/v1/jobs?teamId={test_workspace_id}&page=1",
+                 json=d)
+        r = requests.get(f"http://test_cloud_os/api/v1/jobs?teamId={test_workspace_id}&page=1")
+    return json.loads(r.content)['jobs']
+
+
+def test_process_job_list_output_correct_shape(mocked_requests_get,):
+    df = Cloudos.process_job_list(mocked_requests_get, all_fields=False)
+    assert df.shape == output_df.shape
+
+
+def test_process_job_list_output_correct_headers(mocked_requests_get):
+    df = Cloudos.process_job_list(mocked_requests_get, all_fields=False)
+    correct_headers = list(output_df.columns)
+    actual_headers = list(df.columns)
+    assert correct_headers == actual_headers
+
+
+def test_process_job_list_df_values_equal(mocked_requests_get,):
+    """
+    Testing to check the values are the same. 3 columns (parameters,
+    workflow.description and masterInstanceStorageCost) have been removed.
+    Parameters has" added during making the csv, masterInstanceStorageCost
+    there is a rounding error and workflow.description has nan.
+    """
+    df = Cloudos.process_job_list(mocked_requests_get)
+    columns_to_compare = ['_id', 'team', 'name', 'status',
+                          'startTime', 'endTime', 'createdAt', 'updatedAt',
+                          'computeCostSpent', 'user.id',
+                          'workflow._id', 'workflow.name', 'workflow.createdAt',
+                          'workflow.updatedAt', 'workflow.workflowType',
+                          'project._id', 'project.name',
+                          'project.createdAt', 'project.updatedAt']
+    assert np.all(df[columns_to_compare] == output_df[columns_to_compare])
+
+
+def test_process_job_list_full_has_correct_columns(mocked_requests_get):
+    df = Cloudos.process_job_list(mocked_requests_get, all_fields=True)
+    correct_headers = list(output_df_full.columns)
+    actual_headers = list(df.columns)
+    assert correct_headers == actual_headers
+
+
+def test_process_job_list_empty_json():
+    test_workspace_id = 1
+    empty_json = {"a": {"b": ""}}
+    with requests_mock.Mocker() as mock:
+        mock.get(f"http://test_cloud_os/api/v1/jobs?teamId={test_workspace_id}&page=1",
+                 json=empty_json)
+        r = requests.get(f"http://test_cloud_os/api/v1/jobs?teamId={test_workspace_id}&page=1")
+    with pytest.raises(KeyError) as excinfo:
+        Cloudos.process_job_list(json.loads(r.content)['jobs'])
+    assert "jobs" in str(excinfo.value)

tests/test_clos/test_process_project_list.py

@@ -0,0 +1,36 @@
+"""pytest for method Cloudos.process_project_list"""
+import json
+import requests
+from cloudos_cli.clos import Cloudos
+import pytest
+import requests_mock
+import pandas as pd
+
+INPUT_JSON = "tests/test_data/projects.json"
+output_df = pd.read_csv("tests/test_data/process_project_list_results.csv")
+output_df_full = pd.read_csv("tests/test_data/process_project_list_results_FULL.csv")
+
+
+@pytest.fixture(name="mocked_requests_get")
+def fixture_mocked_requests_get():
+    """Creating a mock request"""
+    test_workspace_id = 1
+    with open(INPUT_JSON, encoding="utf-8") as json_data:
+        data_d = json.load(json_data)
+    with requests_mock.Mocker() as mock:
+        mock.get(f"http://test_cloud_os/api/v1/projects?teamId={test_workspace_id}",
+                 json=data_d)
+        r_get = requests.get(f"http://test_cloud_os/api/v1/projects?teamId={test_workspace_id}")
+    return r_get
+
+
+def test_process_project_list_all_fields_false(mocked_requests_get):
+    """Test function parameter 'all_fields=False'"""
+    df_ = Cloudos.process_project_list(mocked_requests_get, all_fields=False)
+    assert (df_.columns == output_df.columns).any()
+
+
+def test_process_project_list_all_fields_true(mocked_requests_get):
+    """Test function parameter 'all_fields=True'"""
+    df_ = Cloudos.process_project_list(mocked_requests_get, all_fields=True)
+    assert (df_.columns == output_df_full.columns).any()

tests/test_clos/test_process_workflow_list.py

@@ -0,0 +1,36 @@
+"""pytest for method Cloudos.process_workflow_list"""
+import json
+import requests
+from cloudos_cli.clos import Cloudos
+import pytest
+import requests_mock
+import pandas as pd
+
+INPUT_JSON = "tests/test_data/process_workflow_list_initial_request.json"
+output_df = pd.read_csv("tests/test_data/process_workflow_list_results.csv")
+output_df_full = pd.read_csv("tests/test_data/process_workflow_list_results_FULL.csv")
+
+
+@pytest.fixture(name="mocked_requests_get")
+def fixture_mocked_requests_get():
+    """Creating a mock request"""
+    test_workspace_id = 1
+    with open(INPUT_JSON, encoding="utf-8") as json_data:
+        data_d = json.load(json_data)
+    with requests_mock.Mocker() as mock:
+        mock.get(f"http://test_cloud_os/api/v1/jobs?teamId={test_workspace_id}",
+                 json=data_d)
+        r_get = requests.get(f"http://test_cloud_os/api/v1/jobs?teamId={test_workspace_id}")
+    return json.loads(r_get.content)['workflows']
+
+
+def test_process_workflow_list_all_fields_false(mocked_requests_get):
+    """Test function parameter 'all_fields=False'"""
+    df_ = Cloudos.process_workflow_list(mocked_requests_get, all_fields=False)
+    assert (df_.columns == output_df.columns).any()
+
+
+def test_process_workflow_list_all_fields_true(mocked_requests_get):
+    """Test function parameter 'all_fields=True'"""
+    df_ = Cloudos.process_workflow_list(mocked_requests_get, all_fields=True)
+    assert (df_.columns == output_df_full.columns).any()

tests/test_clos/test_wait_job_completion.py

@@ -0,0 +1,40 @@
+"""Pytest for method Cloudos.wait_job_completion"""
+import mock
+import responses
+from cloudos_cli.clos import Cloudos
+from tests.functions_for_pytest import load_json_file
+
+INPUT = "tests/test_data/get_job_status.json"
+APIKEY = 'vnoiweur89u2ongs'
+CLOUDOS_URL = 'http://cloudos.lifebit.ai'
+JOB_ID = '63bd590f72c38201551c3824'
+
+
+@mock.patch('cloudos_cli.clos', mock.MagicMock())
+@responses.activate
+def test_wait_job_completion():
+    """
+    Test 'wait_job_completion' to work as intended
+    API request is mocked and replicated with json files
+    """
+    json_data = load_json_file(INPUT)
+    header = {
+        "Accept": "application/json, text/plain, */*",
+        "Content-Type": "application/json;charset=UTF-8",
+        "apikey": APIKEY
+    }
+    # mock GET method with the .json
+    responses.add(
+            responses.GET,
+            url=f"{CLOUDOS_URL}/api/v1/jobs/{JOB_ID}",
+            body=json_data,
+            headers=header,
+            status=200)
+    # start cloudOS service
+    cl = Cloudos(apikey=APIKEY, cromwell_token=None, cloudos_url=CLOUDOS_URL)
+    # get mock job status
+    status = cl.wait_job_completion(job_id=JOB_ID,
+                                    wait_time=0.01,
+                                    request_interval=0.01)
+    assert isinstance(status, dict)
+    assert status['status'] == 'running'

tests/test_clos/test_workflow_import.py

@@ -0,0 +1,77 @@
+import mock
+import json
+import pytest
+import responses
+from cloudos_cli.clos import Cloudos
+from cloudos_cli.utils.errors import BadRequestException
+from tests.functions_for_pytest import load_json_file
+
+OUTPUT = "tests/test_data/workflows/workflow_import.json"
+APIKEY = 'vnoiweur89u2ongs'
+CLOUDOS_URL = 'http://cloudos.lifebit.ai'
+WORKSPACE_ID = 'lv89ufc838sdig'
+WORKFLOW_URL = 'https://github.com/lifebit-ai/repo'
+WORKFLOW_NAME = 'test-repo'
+WORKFLOW_DOCS_LINK = ''
+REPOSITORY_PROJECT_ID = 1234
+REPOSITORY_ID = 567
+
+
+@mock.patch('cloudos_cli.clos', mock.MagicMock())
+@responses.activate
+def test_workflow_import_correct():
+    """
+    Test 'import_workflows' to work as intended
+    API request is mocked and replicated with json files
+    """
+    create_json = load_json_file(OUTPUT)
+    search_str = f"teamId={WORKSPACE_ID}"
+    # mock POST method with the .json
+    responses.add(
+            responses.POST,
+            url=f"{CLOUDOS_URL}/api/v1/workflows?{search_str}",
+            body=create_json,
+            status=200)
+    # start cloudOS service
+    clos = Cloudos(apikey=APIKEY, cromwell_token=None, cloudos_url=CLOUDOS_URL)
+    # get mock response
+    workflow_id = clos.workflow_import(WORKSPACE_ID,
+                                       WORKFLOW_URL,
+                                       WORKFLOW_NAME,
+                                       REPOSITORY_PROJECT_ID,
+                                       WORKFLOW_DOCS_LINK,
+                                       REPOSITORY_ID)
+    # check the response
+    assert isinstance(workflow_id, str)
+    assert workflow_id == '66156ba61d5f06a39b1da573'
+
+
+@mock.patch('cloudos_cli.clos', mock.MagicMock())
+@responses.activate
+def test_workflow_import_incorrect():
+    """
+    Test 'workflow_import' to fail with '400' response
+    """
+    # prepare error message
+    error_message = {"statusCode": 400, "code": "BadRequest",
+                     "message": "Bad Request.", "time": "2022-11-23_17:31:07"}
+    error_json = json.dumps(error_message)
+    search_str = f"teamId={WORKSPACE_ID}"
+    # mock POST method with the .json
+    responses.add(
+            responses.POST,
+            url=f"{CLOUDOS_URL}/api/v1/workflows?{search_str}",
+            body=error_json,
+            status=400)
+    # raise 400 error
+    with pytest.raises(BadRequestException) as error:
+        # check if it failed
+        clos = Cloudos(apikey=APIKEY, cromwell_token=None,
+                       cloudos_url=CLOUDOS_URL)
+        clos.workflow_import(WORKSPACE_ID,
+                             WORKFLOW_URL,
+                             WORKFLOW_NAME,
+                             REPOSITORY_PROJECT_ID,
+                             WORKFLOW_DOCS_LINK,
+                             REPOSITORY_ID)
+    assert "Server returned status 400." in (str(error))

tests/test_jobs/test_convert_nextflow_to_json.py

@@ -0,0 +1,104 @@
+import pytest
+import json
+
+from cloudos_cli.jobs.job import Job
+
+actual_json_file = "tests/test_data/convert_nextflow_to_json_params.json"
+
+param_dict = {
+    "config": "cloudos_cli/examples/rnatoy.config",
+    "parameter": (),
+    "example_parameters": [],
+    "git_commit": None,
+    "git_tag": None,
+    "project_id": "6054754029b82f0112762b9c",
+    "workflow_id": "60b0ca54303ee601a69b42d1",
+    "job_name": "new_job",
+    "resumable": True,
+    "save_logs": True,
+    "batch": False,
+    "job_queue_id": None,
+    "nextflow_profile": None,
+    "nextflow_version": '22.10.8',
+    "instance_type": "c5.xlarge",
+    "instance_disk": 500,
+    "storage_mode": 'regular',
+    "lustre_size": 1200,
+    "execution_platform": "aws",
+    "hpc_id": None,
+    "workflow_type": 'nextflow',
+    "cromwell_id": None,
+    "cost_limit": -1,
+    "use_mountpoints": False,
+    "docker_login": False
+}
+
+
+def test_convert_nextflow_to_json_output_correct():
+    job_json = Job.convert_nextflow_to_json(
+        1, param_dict["config"],
+        parameter=param_dict["parameter"],
+        example_parameters=param_dict["example_parameters"],
+        git_commit=param_dict["git_commit"],
+        git_tag=param_dict["git_tag"],
+        project_id=param_dict["project_id"],
+        workflow_id=param_dict["workflow_id"],
+        job_name=param_dict["job_name"],
+        resumable=param_dict["resumable"],
+        save_logs=param_dict["save_logs"],
+        batch=param_dict["batch"],
+        job_queue_id=param_dict["job_queue_id"],
+        nextflow_profile=param_dict["nextflow_profile"],
+        nextflow_version=param_dict["nextflow_version"],
+        instance_type=param_dict["instance_type"],
+        instance_disk=param_dict["instance_disk"],
+        storage_mode=param_dict["storage_mode"],
+        lustre_size=param_dict["lustre_size"],
+        execution_platform=param_dict["execution_platform"],
+        hpc_id=param_dict["hpc_id"],
+        workflow_type=param_dict["workflow_type"],
+        cromwell_id=param_dict["cromwell_id"],
+        cost_limit=param_dict["cost_limit"],
+        use_mountpoints=param_dict["use_mountpoints"],
+        docker_login=param_dict["docker_login"]
+        )
+    with open(actual_json_file) as json_data:
+        correct_json = json.load(json_data)
+    assert job_json == correct_json
+
+
+def test_convert_nextflow_to_json_badly_formed_config():
+    no_equals_config = "tests/test_data/wrong_params.config"
+    with pytest.raises(ValueError) as excinfo:
+        Job.convert_nextflow_to_json(
+            1, no_equals_config,
+            parameter=param_dict["parameter"],
+            example_parameters=param_dict["example_parameters"],
+            git_commit=param_dict["git_commit"],
+            git_tag=param_dict["git_tag"],
+            project_id=param_dict["project_id"],
+            workflow_id=param_dict["workflow_id"],
+            job_name=param_dict["job_name"],
+            resumable=param_dict["resumable"],
+            save_logs=param_dict["save_logs"],
+            batch=param_dict["batch"],
+            job_queue_id=param_dict["job_queue_id"],
+            nextflow_profile=param_dict["nextflow_profile"],
+            nextflow_version=param_dict["nextflow_version"],
+            instance_type=param_dict["instance_type"],
+            instance_disk=param_dict["instance_disk"],
+            storage_mode=param_dict["storage_mode"],
+            lustre_size=param_dict["lustre_size"],
+            execution_platform=param_dict["execution_platform"],
+            hpc_id=param_dict["hpc_id"],
+            workflow_type=param_dict["workflow_type"],
+            cromwell_id=param_dict["cromwell_id"],
+            cost_limit=param_dict["cost_limit"],
+            use_mountpoints=param_dict["use_mountpoints"],
+            docker_login=param_dict["docker_login"]
+            )
+        print(str(excinfo.value))
+    assert "Please, specify your parameters in\
+            tests/test_data/wrong_params.config\
+            using the \'=\' as spacer.\
+            E.g: name = my_name".replace("           ", "") in str(excinfo.value)

tests/test_jobs/test_project_id.py

@@ -0,0 +1,67 @@
+"""Pytest added for checking Job.project_id"""
+import mock
+import responses
+from responses import matchers
+from cloudos_cli.jobs import Job
+from tests.functions_for_pytest import load_json_file
+
+INPUT_PROJECT = "tests/test_data/projects.json"
+INPUT_WORKFLOW = "tests/test_data/workflows.json"
+APIKEY = 'vnoiweur89u2ongs'
+CLOUDOS_URL = 'http://cloudos.lifebit.ai'
+WORKSPACE_ID = 'lv89ufc838sdig'
+PROJECT_NAME = "lifebit-testing"
+WORKFLOW_NAME = "nf-core-deepvariant"
+PAGE_SIZE = 10
+PAGE = 1
+ARCHIVED_STATUS = "false"
+
+
+@mock.patch('cloudos_cli.clos', mock.MagicMock())
+@responses.activate
+def test_project_id():
+    """
+    Test 'project_id' to work as intended
+    API request is mocked and replicated with json files
+    """
+    create_json_project = load_json_file(INPUT_PROJECT)
+    create_json_workflow = load_json_file(INPUT_WORKFLOW)
+    params_projects = {"teamId": WORKSPACE_ID}
+    params_workflows = {
+        "teamId": WORKSPACE_ID,
+        "pageSize": PAGE_SIZE,
+        "page": PAGE,
+        "archived.status": ARCHIVED_STATUS}
+    header = {
+        "Accept": "application/json, text/plain, */*",
+        "Content-Type": "application/json;charset=UTF-8",
+        "apikey": APIKEY
+    }
+    search_str_projects = f"teamId={WORKSPACE_ID}"
+    search_str_workflows = f"teamId={WORKSPACE_ID}&pageSize={PAGE_SIZE}&page={PAGE}&archived.status={ARCHIVED_STATUS}"
+    # mock GET method with the .json
+    responses.add(
+            responses.GET,
+            url=f"{CLOUDOS_URL}/api/v1/projects?{search_str_projects}",
+            body=create_json_project,
+            headers=header,
+            match=[matchers.query_param_matcher(params_projects)],
+            status=200)
+    responses.add(
+            responses.GET,
+            url=f"{CLOUDOS_URL}/api/v3/workflows?{search_str_workflows}",
+            body=create_json_workflow,
+            headers=header,
+            match=[matchers.query_param_matcher(params_workflows)],
+            status=201)
+    # start cloudOS service
+    job = Job(apikey=APIKEY,
+              cloudos_url=CLOUDOS_URL,
+              workspace_id=WORKSPACE_ID,
+              cromwell_token=None,
+              project_name=PROJECT_NAME,
+              workflow_name=WORKFLOW_NAME)
+    # get mock response
+    project_id = job.project_id
+    # check the response
+    assert project_id == '1234bc123125'