def test_move_files(app, default_user, _get_user_mock): """Test move_files view.""" with app.test_client() as client: with patch( "reana_server.rest.workflows.current_rwc_api_client", make_mock_api_client("reana-workflow-controller")(), ): res = client.put( url_for("workflows.move_files", workflow_id_or_name="1"), query_string={ "user": default_user.id_, "source": "source.txt", "target": "target.txt", }, ) assert res.status_code == 403 mock_response = Mock() mock_response.status_code = 200 mock_response.json.return_value = dict(key="value") with patch( "reana_server.rest.workflows.current_rwc_api_client", make_mock_api_client("reana-workflow-controller")( mock_http_response=mock_response ), ): res = client.put( url_for("workflows.move_files", workflow_id_or_name="1"), query_string={ "access_token": default_user.access_token, "source": "source.txt", "target": "target.txt", }, ) assert res.status_code == 200
def test_get_files(app, default_user, _get_user_mock): """Test get_files view.""" with app.test_client() as client: with patch("reana_server.rest.workflows.current_rwc_api_client", make_mock_api_client("reana-workflow-controller")()): res = client.get( url_for("workflows.get_files", workflow_id_or_name="1")) assert res.status_code == 403 res = client.get( url_for("workflows.get_files", workflow_id_or_name="1"), query_string={"access_token": default_user.access_token}) assert res.status_code == 500 mock_response = Mock() mock_response.status_code = 200 mock_response.json.return_value = dict(key='value') with patch( "reana_server.rest.workflows.current_rwc_api_client", make_mock_api_client("reana-workflow-controller")( mock_http_response=mock_response), ): res = client.get( url_for("workflows.get_files", workflow_id_or_name="1"), query_string={"access_token": default_user.access_token}) assert res.status_code == 200
def test_upload_file(create_yaml_workflow_schema): """Test upload file.""" status_code = 200 reana_token = '000000' file = 'file.txt' response = [file] env = {'REANA_SERVER_URL': 'localhost'} message = 'was successfully uploaded.' mock_http_response = Mock() mock_http_response.status_code = status_code mock_http_response.raw_bytes = str(response).encode() mock_response = response runner = CliRunner(env=env) with runner.isolation(): with patch( "reana_client.api.client.current_rs_api_client", make_mock_api_client('reana-server')(mock_response, mock_http_response)): with runner.isolated_filesystem(): with open(file, 'w') as f: f.write('test') with open('reana.yaml', 'w') as reana_schema: reana_schema.write(create_yaml_workflow_schema) result = runner.invoke(cli, [ 'upload', '-at', reana_token, '--workflow', 'mytest.1', file ]) assert result.exit_code == 0 assert message in result.output
def test_get_workflows(app, default_user, _get_user_mock): """Test get_workflows view.""" with app.test_client() as client: with patch( "reana_server.rest.workflows.current_rwc_api_client", make_mock_api_client("reana-workflow-controller")(), ): res = client.get( url_for("workflows.get_workflows"), query_string={"type": "batch"}, ) assert res.status_code == 401 res = client.get( url_for("workflows.get_workflows"), query_string={"access_token": "wrongtoken", "type": "batch"}, ) assert res.status_code == 403 res = client.get( url_for("workflows.get_workflows"), query_string={ "access_token": default_user.access_token, "type": "batch", }, ) assert res.status_code == 200
def test_open_interactive_session(interactive_session_type): """Test opening an interactive session.""" status_code = 200 workflow_id = "d9304bdf-0d19-45d9-ae87-d5fd18059193" response = {"path": "/{}".format(workflow_id)} reana_server_url = "http://localhost" env = {"REANA_SERVER_URL": reana_server_url} mock_http_response, mock_response = Mock(), Mock() mock_http_response.status_code = status_code mock_response = response reana_token = "000000" runner = CliRunner(env=env) with runner.isolation(): with patch( "reana_client.api.client.current_rs_api_client", make_mock_api_client("reana-server")(mock_response, mock_http_response), ): expected_message = "{reana_server_url}/{workflow_id}".format( reana_server_url=reana_server_url, workflow_id=workflow_id) result = runner.invoke( cli, [ "open", "-t", reana_token, "-w", workflow_id, interactive_session_type, ], ) assert expected_message in result.output
def test_create_workflow_from_json(create_yaml_workflow_schema): """Test create workflow from json specification.""" status_code = 201 response = { "message": "The workflow has been successfully created.", "workflow_id": "cdcf48b1-c2f3-4693-8230-b066e088c6ac", "workflow_name": "mytest", } env = {"REANA_SERVER_URL": "localhost"} reana_token = "000000" mock_http_response, mock_response = Mock(), Mock() mock_http_response.status_code = status_code mock_response = response workflow_json = yaml.load(create_yaml_workflow_schema, Loader=yaml.FullLoader) with patch.dict("os.environ", env): with patch( "reana_client.api.client.current_rs_api_client", make_mock_api_client("reana-server")(mock_response, mock_http_response), ): result = create_workflow_from_json( workflow_json=workflow_json["workflow"], name=response["workflow_name"], access_token=reana_token, parameters=workflow_json["inputs"], workflow_engine="serial", ) assert response["workflow_name"] == result["workflow_name"] assert response["message"] == result["message"]
def test_workflows_without_include_workspace_size(): """Test workflows command without --include-workspace-size flag.""" response = { "items": [{ "status": "running", "created": "2018-06-13T09:47:35.66097", "user": "******", "name": "mytest.1", "id": "256b25f4-4cfb-4684-b7a8-73872ef455a1", "size": { "human_readable": "", "raw": -1 }, }] } status_code = 200 mock_http_response, mock_response = Mock(), Mock() mock_http_response.status_code = status_code mock_response = response env = {"REANA_SERVER_URL": "localhost"} reana_token = "000000" runner = CliRunner(env=env) with runner.isolation(): with patch( "reana_client.api.client.current_rs_api_client", make_mock_api_client("reana-server")(mock_response, mock_http_response), ): result = runner.invoke(cli, ["list", "-t", reana_token]) assert result.exit_code == 0 assert "SIZE" not in result.output
def test_workflows_sessions(): """Test list command for getting interactive sessions.""" response = { "items": [{ "created": "2019-03-19T14:37:58", "id": "29136cd0-b259-4d48-8c1e-afe3572df408", "name": "workflow.1", "session_type": "jupyter", "session_uri": "/29136cd0-b259-4d48-8c1e-afe3572df408", "size": { "raw": 0, "human_readable": "0 Bytes" }, "status": "created", "user": "******", }] } status_code = 200 mock_http_response, mock_response = Mock(), Mock() mock_http_response.status_code = status_code mock_response = response env = {"REANA_SERVER_URL": "localhost", "REANA_WORKON": "mytest.1"} reana_token = "000000" runner = CliRunner(env=env) with runner.isolation(): with patch( "reana_client.api.client.current_rs_api_client", make_mock_api_client("reana-server")(mock_response, mock_http_response), ): result = runner.invoke(cli, ["list", "-t", reana_token, "--sessions"]) message = "RUN_NUMBER" assert result.exit_code == 0 assert message in result.output
def test_workflows_server_ok(): """Test workflows command when server is reachable.""" response = [{ "status": "running", "created": "2018-06-13T09:47:35.66097", "user": "******", "name": "mytest.1", "id": "256b25f4-4cfb-4684-b7a8-73872ef455a1", }] status_code = 200 mock_http_response, mock_response = Mock(), Mock() mock_http_response.status_code = status_code mock_response = response env = {'REANA_SERVER_URL': 'localhost', 'REANA_WORKON': 'mytest.1'} reana_token = '000000' runner = CliRunner(env=env) with runner.isolation(): with patch( "reana_client.api.client.current_rs_api_client", make_mock_api_client('reana-server')(mock_response, mock_http_response)): result = runner.invoke(cli, ['list', '-at', reana_token]) message = 'RUN_NUMBER' assert result.exit_code == 0 assert message in result.output
def test_move_file_running_workflow(): """Test move files when workflow is running.""" status_code = 200 reana_token = "000000" src_file = "file11" target = "file2" response = {"status": "running", "logs": "", "name": "mytest.1"} message = "File(s) could not be moved for running workflow" mock_http_response = Mock() mock_http_response.status_code = status_code mock_http_response.raw_bytes = str(response).encode() mock_response = response env = {"REANA_SERVER_URL": "localhost"} runner = CliRunner(env=env) with runner.isolation(): with patch( "reana_client.api.client.current_rs_api_client", make_mock_api_client("reana-server")(mock_response, mock_http_response), ): result = runner.invoke( cli, [ "mv", "-t", reana_token, "--workflow", "mytest.1", src_file, target ], ) assert result.exit_code == 1 assert message in result.output
def test_delete_non_existing_file(): """Test delete non existing file.""" status_code = 200 reana_token = "000000" filename = "file11" response = {"deleted": {}, "failed": {}} message = "{} did not match any existing file.".format(filename) mock_http_response = Mock() mock_http_response.status_code = status_code mock_http_response.raw_bytes = str(response).encode() mock_response = response env = {"REANA_SERVER_URL": "localhost"} runner = CliRunner(env=env) with runner.isolation(): with patch( "reana_client.api.client.current_rs_api_client", make_mock_api_client("reana-server")(mock_response, mock_http_response), ): with runner.isolated_filesystem(): result = runner.invoke(cli, [ "rm", "-t", reana_token, "--workflow", "mytest.1", filename ]) assert result.exit_code == 0 assert message in result.output
def test_get_workflow_specification(app, default_user, _get_user_mock, sample_yadage_workflow_in_db): """Test get_workflow_specification view.""" with app.test_client() as client: with patch("reana_server.rest.workflows.current_rwc_api_client", make_mock_api_client("reana-workflow-controller")()): res = client.get( url_for("workflows.get_workflow_specification", workflow_id_or_name="1")) assert res.status_code == 403 res = client.get( url_for("workflows.get_workflow_specification", workflow_id_or_name=sample_yadage_workflow_in_db.id_), headers={"Content-Type": "application/json"}, query_string={"access_token": default_user.access_token}, data=json.dumps(None)) parsed_res = json.loads(res.data) assert res.status_code == 200 assert parsed_res['workflow']['specification'] == \ sample_yadage_workflow_in_db.get_specification() assert parsed_res['inputs']['parameters'] == \ sample_yadage_workflow_in_db.get_input_parameters() assert parsed_res['workflow']['type'] == \ sample_yadage_workflow_in_db.type_
def test_download_file(): """Test file downloading.""" status_code = 200 response = 'Content of file to download' env = {'REANA_SERVER_URL': 'localhost'} mock_http_response = Mock() mock_http_response.status_code = status_code mock_http_response.raw_bytes = str(response).encode() mock_response = response reana_token = '000000' response_md5 = hashlib.md5(mock_response.encode('utf-8')).hexdigest() file = 'dummy_file.txt' message = 'File {0} downloaded to'.format(file) runner = CliRunner(env=env) with runner.isolation(): with patch( "reana_client.api.client.current_rs_api_client", make_mock_api_client('reana-server')(mock_response, mock_http_response)): result = runner.invoke(cli, [ 'download', '-t', reana_token, '--workflow', 'mytest.1', file ]) assert result.exit_code == 0 assert os.path.isfile(file) is True file_md5 = hashlib.md5(open(file, 'rb').read()).hexdigest() assert file_md5 == response_md5 assert message in result.output os.remove(file)
def test_move_file_running_workflow(): """Test move files when workflow is running.""" status_code = 200 reana_token = '000000' src_file = 'file11' target = 'file2' response = {"status": "running", "logs": "", "name": "mytest.1"} message = 'File(s) could not be moved for running workflow' mock_http_response = Mock() mock_http_response.status_code = status_code mock_http_response.raw_bytes = str(response).encode() mock_response = response env = {'REANA_SERVER_URL': 'localhost'} runner = CliRunner(env=env) with runner.isolation(): with patch( "reana_client.api.client.current_rs_api_client", make_mock_api_client('reana-server')(mock_response, mock_http_response)): result = runner.invoke(cli, [ 'mv', '-t', reana_token, '--workflow', 'mytest.1', src_file, target ]) assert result.exit_code == 1 assert message in result.output
def test_download_file(app, default_user): """Test download_file view.""" with app.test_client() as client: with patch( "reana_server.rest.workflows.current_rwc_api_client", make_mock_api_client("reana-workflow-controller")(), ): res = client.get( url_for("workflows.download_file", workflow_id_or_name="1", file_name="test_download"), query_string={ "user_id": default_user.id_, "file_name": "test_upload.txt" }, ) assert res.status_code == 302 res = client.get( url_for("workflows.download_file", workflow_id_or_name="1", file_name="test_download"), query_string={"access_token": default_user.access_token}, ) assert res.status_code == 200
def test_create_workflow_from_json(create_yaml_workflow_schema): """Test create workflow from json specification.""" status_code = 201 response = { "message": "The workflow has been successfully created.", "workflow_id": "cdcf48b1-c2f3-4693-8230-b066e088c6ac", "workflow_name": "mytest.1" } env = {'REANA_SERVER_URL': 'localhost'} reana_token = '000000' mock_http_response, mock_response = Mock(), Mock() mock_http_response.status_code = status_code mock_response = response workflow_json = yaml.load(create_yaml_workflow_schema, Loader=yaml.FullLoader) with patch.dict('os.environ', env): with patch( "reana_client.api.client.current_rs_api_client", make_mock_api_client('reana-server')(mock_response, mock_http_response)): result = create_workflow_from_json( workflow_json=workflow_json['workflow'], name=response['workflow_name'], access_token=reana_token, parameters=workflow_json['inputs'], workflow_engine='serial') assert response['workflow_name'] == result['workflow_name'] assert response['message'] == result['message']
def test_workflow_input_parameters(): """Test if not existing input parameters from CLI are applied.""" status_code = 200 response = { 'id': 'd9304bdf-0d19-45d9-ae87-d5fd18059193', 'name': 'workflow.19', 'type': 'serial', 'parameters': { 'helloworld': 'code/helloworld.py', 'inputfile': 'data/names.txt', 'outputfile': 'results/greetings.txt', 'sleeptime': 2 } } env = {'REANA_SERVER_URL': 'localhost'} mock_http_response, mock_response = Mock(), Mock() mock_http_response.status_code = status_code mock_response = response reana_token = '000000' runner = CliRunner(env=env) with runner.isolation(): with patch( "reana_client.api.client.current_rs_api_client", make_mock_api_client('reana-server')(mock_response, mock_http_response)): parameter = "Debug" expected_message = '{0}, is not in reana.yaml'.format(parameter) result = runner.invoke(cli, [ 'start', '-at', reana_token, '-w workflow.19', '-p {0}=True'.format(parameter) ]) assert expected_message in result.output
def test_list_disk_usage_with_invalid_filter(): """Test list disk usage info with invalid filter.""" status_code = 200 response = { "disk_usage_info": [], "user": "******", "workflow_id": "7767678-766787", "workflow_name": "workflow", } env = {"REANA_SERVER_URL": "localhost"} mock_http_response, mock_response = Mock(), Mock() mock_http_response.status_code = status_code mock_response = response reana_token = "000000" runner = CliRunner(env=env) with runner.isolation(): with patch( "reana_client.api.client.current_rs_api_client", make_mock_api_client("reana-server")(mock_response, mock_http_response), ): result = runner.invoke( cli, [ "du", "-t", reana_token, "--workflow", "workflow.1", "--filter", "name=not_valid", ], ) assert result.exit_code == 1 assert "No files matching filter criteria." in result.output
def test_workflows_sessions(): """Test list command for getting interactive sessions.""" response = [{ 'created': '2019-03-19T14:37:58', 'id': '29136cd0-b259-4d48-8c1e-afe3572df408', 'name': 'workflow.1', 'session_type': 'jupyter', 'session_uri': '/29136cd0-b259-4d48-8c1e-afe3572df408', 'size': '0', 'status': 'created', 'user': '******' }] status_code = 200 mock_http_response, mock_response = Mock(), Mock() mock_http_response.status_code = status_code mock_response = response env = {'REANA_SERVER_URL': 'localhost', 'REANA_WORKON': 'mytest.1'} reana_token = '000000' runner = CliRunner(env=env) with runner.isolation(): with patch( "reana_client.api.client.current_rs_api_client", make_mock_api_client('reana-server')(mock_response, mock_http_response)): result = runner.invoke(cli, ['list', '-at', reana_token, '--sessions']) message = 'RUN_NUMBER' assert result.exit_code == 0 assert message in result.output
def test_list_files_ok(): """Test list workflow workspace files successfull.""" status_code = 200 response = { "items": [{ "last-modified": "string", "name": "string", "size": { "raw": 0, "human_readable": "0 Bytes" }, }] } env = {"REANA_SERVER_URL": "localhost"} mock_http_response, mock_response = Mock(), Mock() mock_http_response.status_code = status_code mock_response = response reana_token = "000000" runner = CliRunner(env=env) with runner.isolation(): with patch( "reana_client.api.client.current_rs_api_client", make_mock_api_client("reana-server")(mock_response, mock_http_response), ): result = runner.invoke( cli, ["ls", "-t", reana_token, "--workflow", "mytest.1", "--json"]) json_response = json.loads(result.output) assert result.exit_code == 0 assert isinstance(json_response, list) assert len(json_response) == 1 assert json_response[0]["name"] in response["items"][0]["name"]
def test_workflows_valid_json(): """Test workflows command with --json and -v flags.""" response = { "items": [{ "status": "running", "created": "2018-06-13T09:47:35.66097", "user": "******", "name": "mytest.1", "id": "256b25f4-4cfb-4684-b7a8-73872ef455a1", "size": { "raw": 0, "human_readable": "0 Bytes" }, }] } status_code = 200 mock_http_response, mock_response = Mock(), Mock() mock_http_response.status_code = status_code mock_response = response env = {"REANA_SERVER_URL": "localhost"} reana_token = "000000" runner = CliRunner(env=env) with runner.isolation(): with patch( "reana_client.api.client.current_rs_api_client", make_mock_api_client("reana-server")(mock_response, mock_http_response), ): result = runner.invoke(cli, ["list", "-v", "-t", reana_token, "--json"]) assert result.exit_code == 0
def test_list_files_url(): """Test list workflow workspace files' urls.""" status_code = 200 response = { "items": [{ "last-modified": "string", "name": "string", "size": { "raw": 0, "human_readable": "0 Bytes" }, }] } env = {"REANA_SERVER_URL": "localhost"} mock_http_response, mock_response = Mock(), Mock() mock_http_response.status_code = status_code mock_response = response workflow_name = "mytest" reana_token = "000000" runner = CliRunner(env=env) with runner.isolation(): with patch( "reana_client.api.client.current_rs_api_client", make_mock_api_client("reana-server")(mock_response, mock_http_response), ): result = runner.invoke(cli, [ "ls", "-t", reana_token, "--workflow", workflow_name, "--url" ]) assert result.exit_code == 0 assert workflow_name in result.output assert response["items"][0]["name"] in result.output
def test_workflow_create_successful(create_yaml_workflow_schema): """Test workflow create when creation is successfull.""" status_code = 201 response = { "message": "The workflow has been successfully created.", "workflow_id": "cdcf48b1-c2f3-4693-8230-b066e088c6ac", "workflow_name": "mytest.1", } env = {"REANA_SERVER_URL": "localhost"} reana_token = "000000" mock_http_response, mock_response = Mock(), Mock() mock_http_response.status_code = status_code mock_response = response runner = CliRunner(env=env) with runner.isolation(): with patch( "reana_client.api.client.current_rs_api_client", make_mock_api_client("reana-server")(mock_response, mock_http_response), ): with runner.isolated_filesystem(): with open("reana.yaml", "w") as f: f.write(create_yaml_workflow_schema) result = runner.invoke( cli, ["create", "-t", reana_token, "--skip-validation"]) assert result.exit_code == 0 assert response["workflow_name"] in result.output
def test_secrets_add(secret): """Test secrets add.""" status_code = 201 reana_token = '000000' secret_file = 'file.txt' response = [secret_file] env = {'REANA_SERVER_URL': 'localhost'} message = 'were successfully uploaded.' mock_http_response = Mock() mock_http_response.status_code = status_code mock_http_response.raw_bytes = str(response).encode() mock_response = response runner = CliRunner(env=env) with runner.isolation(): with patch( "reana_client.api.client.current_rs_api_client", make_mock_api_client('reana-server')(mock_response, mock_http_response)): with runner.isolated_filesystem(): with open(secret_file, 'w') as f: f.write('test') result = runner.invoke(cli, [ 'secrets-add', '-t', reana_token, '--file', secret_file, '--env', secret ]) assert result.exit_code == 0 assert message in result.output
def test_workflow_start_successful(status): """Test workflow start when creation is successfull.""" workflow_name = "mytest.1" response = { "status": status, "message": "Server message", "id": "256b25f4-4cfb-4684-b7a8-73872ef455a1", "workflow_name": workflow_name, "user": "******", } status_code = 200 reana_token = "000000" expected_message = get_workflow_status_change_msg(workflow_name, status) mock_http_response = Mock() mock_http_response.status_code = status_code mock_response = response env = {"REANA_SERVER_URL": "localhost"} runner = CliRunner(env=env) with runner.isolation(): with patch( "reana_client.api.client.current_rs_api_client", make_mock_api_client("reana-server")(mock_response, mock_http_response), ): result = runner.invoke( cli, ["start", "-t", reana_token, "-w", response["workflow_name"]]) assert result.exit_code == 0 assert expected_message in result.output
def test_delete_file(app, default_user, _get_user_mock): """Test delete_file view.""" mock_response = Mock() mock_response.headers = {"Content-Type": "multipart/form-data"} mock_response.json = Mock(return_value={}) mock_response.status_code = 200 with app.test_client() as client: with patch( "reana_server.rest.workflows.current_rwc_api_client", make_mock_api_client("reana-workflow-controller")( mock_http_response=mock_response ), ): res = client.delete( url_for( "workflows.delete_file", workflow_id_or_name="1", file_name="test_delete.txt", ) ) assert res.status_code == 403 res = client.delete( url_for( "workflows.delete_file", workflow_id_or_name="1", file_name="test_delete.txt", ), query_string={"access_token": default_user.access_token}, ) assert res.status_code == 200
def test_set_workflow_status(app, default_user, _get_user_mock): """Test get_workflow_logs view.""" with app.test_client() as client: with patch( "reana_server.rest.workflows.current_rwc_api_client", make_mock_api_client("reana-workflow-controller")(), ): res = client.put( url_for("workflows.set_workflow_status", workflow_id_or_name="1") ) assert res.status_code == 401 res = client.put( url_for("workflows.set_workflow_status", workflow_id_or_name="1"), query_string={"access_token": "wrongtoken"}, ) assert res.status_code == 403 res = client.put( url_for("workflows.set_workflow_status", workflow_id_or_name="1"), headers={"Content-Type": "application/json"}, query_string={"access_token": default_user.access_token}, ) assert res.status_code == 500 res = client.put( url_for("workflows.set_workflow_status", workflow_id_or_name="1"), headers={"Content-Type": "application/json"}, query_string={ "access_token": default_user.access_token, "status": "stop", }, data=json.dumps(dict(parameters=None)), ) assert res.status_code == 200
def test_workflows_valid_json(): """Test workflows command with --json and -v flags.""" response = [{ "status": "running", "created": "2018-06-13T09:47:35.66097", "user": "******", "name": "mytest.1", "id": "256b25f4-4cfb-4684-b7a8-73872ef455a1", "size": "0K" }] status_code = 200 mock_http_response, mock_response = Mock(), Mock() mock_http_response.status_code = status_code mock_response = response env = {'REANA_SERVER_URL': 'localhost'} reana_token = '000000' runner = CliRunner(env=env) with runner.isolation(): with patch( "reana_client.api.client.current_rs_api_client", make_mock_api_client('reana-server')(mock_response, mock_http_response)): result = runner.invoke( cli, ['list', '-v', '-at', reana_token, '--json']) json_response = json.loads(result.output) assert result.exit_code == 0 assert isinstance(json_response, list) assert len(json_response) == 1 assert 'name' in json_response[0] assert 'run_number' in json_response[0] assert 'created' in json_response[0] assert 'status' in json_response[0] assert 'id' in json_response[0] assert 'user' in json_response[0]
def test_secrets_add(secret): """Test secrets add.""" status_code = 201 reana_token = "000000" secret_file = "file.txt" response = [secret_file] env = {"REANA_SERVER_URL": "localhost"} message = "were successfully uploaded." mock_http_response = Mock() mock_http_response.status_code = status_code mock_http_response.raw_bytes = str(response).encode() mock_response = response runner = CliRunner(env=env) with runner.isolation(): with patch( "reana_client.api.client.current_rs_api_client", make_mock_api_client("reana-server")(mock_response, mock_http_response), ): with runner.isolated_filesystem(): with open(secret_file, "w") as f: f.write("test") result = runner.invoke( cli, [ "secrets-add", "-t", reana_token, "--file", secret_file, "--env", secret, ], ) assert result.exit_code == 0 assert message in result.output
def test_delete_non_existing_file(): """Test delete non existing file.""" status_code = 200 reana_token = '000000' filename = 'file11' response = {'deleted': {}, 'failed': {}} message = '{} did not match any existing file.'.format(filename) mock_http_response = Mock() mock_http_response.status_code = status_code mock_http_response.raw_bytes = str(response).encode() mock_response = response env = {'REANA_SERVER_URL': 'localhost'} runner = CliRunner(env=env) with runner.isolation(): with patch( "reana_client.api.client.current_rs_api_client", make_mock_api_client('reana-server')(mock_response, mock_http_response)): with runner.isolated_filesystem(): result = runner.invoke(cli, [ 'rm', '-at', reana_token, '--workflow', 'mytest.1', filename ]) assert result.exit_code == 0 assert message in result.output