def test_samples_download_file_stdout(credentials, mocker, recording, sample_id_download, vcr): """Test command outputs to stdout.""" runner = CliRunner() file_type = "fastq-r1" if not recording: # Mock only if using the cassettes, since we mock the return value. get_sample_details_response = get_vcr_response("/api/v2/samples/", vcr, operator.contains) mocked_sample_details = mocker.patch.object( APIClient, "get_sample_details", return_value=SampleDetails(**get_sample_details_response), ) file_content = get_vcr_response("/r1.fastq.gz", vcr) file_content = file_content["body"]["string"] res = runner.invoke( download_file, [ sample_id_download, file_type, "-", *credentials, ], ) assert res.exit_code == 0 if not recording: mocked_sample_details.assert_called_once() assert file_content == res.output.encode()
def test_sample_ids_provided( credentials, mocker, recording, sample_id_download, vcr ): """Check happy flow with sample ids.""" runner = CliRunner() with runner.isolated_filesystem(): if not recording: # Mock only if using the cassettes, since we mock the return value. get_sample_details_response = get_vcr_response( "/api/v2/samples/", vcr, operator.contains ) mocked_sample_details = mocker.patch.object( APIClient, "get_sample_details", return_value=SampleDetails(**get_sample_details_response), ) get_sample_qc_metrics_response = get_vcr_response( "/api/v2/sample-quality-controls/", vcr, operator.contains ) mocked_qc_metrics = mocker.patch.object( APIClient, "get_sample_qc_metrics", return_value=SampleQC(**get_sample_qc_metrics_response), ) get_metadata_response = get_vcr_response( "/api/v2/sample-metadata/", vcr, operator.contains ) mocked_get_metadata = mocker.patch.object( APIClient, "get_metadata", return_value=SampleMetadata(**get_metadata_response), ) mocked_download_file = mocker.patch( "gencove.command.download.main.download_file", side_effect=download_file, ) res = runner.invoke( download, [ "cli_test_data", "--sample-ids", sample_id_download, *credentials, ], ) assert res.exit_code == 0 if not recording: mocked_sample_details.assert_called_once() mocked_qc_metrics.assert_called_once() mocked_get_metadata.assert_called_once() mocked_download_file.assert_called_once_with( f"cli_test_data/mock_client_id/{MOCK_UUID}/r1.fastq.gz", HttpUrl( url="https://example.com/r1.fastq.gz", scheme="https", host="example.com", ), True, False, )
def test_samples_download_file_local(credentials, mocker, recording, sample_id_download, vcr): """Test command outputs to local destination.""" runner = CliRunner() with runner.isolated_filesystem(): file_type = "fastq-r1" file_path = "r1.fastq.gz" if not recording: # Mock only if using the cassettes, since we mock the return value. get_sample_details_response = get_vcr_response( "/api/v2/samples/", vcr, operator.contains) mocked_sample_details = mocker.patch.object( APIClient, "get_sample_details", return_value=SampleDetails(**get_sample_details_response), ) file_content = get_vcr_response(f"/{file_path}", vcr) file_content = file_content["body"]["string"] res = runner.invoke( download_file, [ sample_id_download, file_type, file_path, *credentials, ], ) assert res.exit_code == 0 if not recording: mocked_sample_details.assert_called_once() with open(file_path, "rb") as local_file: assert file_content == local_file.read()
def test_restore_project_samples__success__empty_sample_ids( credentials, mocker, project_id, recording, vcr): """Test restore project samples success when an empty list of sample ids is sent.""" runner = CliRunner() if not recording: # Mock restore_project_samples only if using the cassettes, since we # mock the return value. restore_project_samples_response = get_vcr_response( "/api/v2/project-restore-samples/", vcr, operator.contains) mocked_restore_project_samples = mocker.patch.object( APIClient, "restore_project_samples", return_value=restore_project_samples_response, ) res = runner.invoke( restore_project_samples, [ project_id, *credentials, "--sample-ids", "", ], ) assert res.exit_code == 0 if not recording: mocked_restore_project_samples.assert_called_once()
def test_restore_project_samples__success(archived_sample, credentials, mocker, project_id, recording, vcr): # pylint: disable=too-many-arguments """Test restore project samples success.""" runner = CliRunner() if not recording: # Mock restore_project_samples only if using the cassettes, since we # mock the return value. restore_project_samples_response = get_vcr_response( "/api/v2/project-restore-samples/", vcr, operator.contains) mocked_restore_project_samples = mocker.patch.object( APIClient, "restore_project_samples", return_value=restore_project_samples_response, ) res = runner.invoke( restore_project_samples, [ project_id, *credentials, "--sample-ids", archived_sample, ], ) assert res.exit_code == 0 if not recording: mocked_restore_project_samples.assert_called_once() assert "Request to restore samples accepted" in res.output
def test_list_project_batch_types__not_empty(mocker, credentials, project_id_batches, recording, vcr): """Test project batch types being outputed to the shell.""" runner = CliRunner() if not recording: # Mock get_project_batch_types only if using the cassettes, since we # mock the return value. get_project_batch_types_response = get_vcr_response( "/api/v2/project-batch-types/", vcr, operator.contains) mocked_get_project_batch_types = mocker.patch.object( APIClient, "get_project_batch_types", return_value=ProjectBatchTypes(**get_project_batch_types_response), ) res = runner.invoke( list_project_batch_types, [project_id_batches, *credentials], ) assert res.exit_code == 0 assert res.output != "" if not recording: mocked_get_project_batch_types.assert_called_once() output_line = io.BytesIO() sys.stdout = output_line batches_output = [ f"{batch_type['key']}\t{batch_type['description']}" for batch_type in get_project_batch_types_response["results"] ] echo("\n".join(batches_output)) assert output_line.getvalue() == res.output.encode()
def test_list_project_batches__not_empty(credentials, mocker, project_id_batches, recording, vcr): """Test project batches being outputed to the shell.""" runner = CliRunner() if not recording: # Mock create_project_batch only if using the cassettes, since we # mock the return value. get_project_batches_response = get_vcr_response( "/api/v2/project-batches/", vcr, operator.contains) mocked_get_project_batches = mocker.patch.object( APIClient, "get_project_batches", return_value=ProjectBatches(**get_project_batches_response), ) res = runner.invoke( list_project_batches, [project_id_batches, *credentials], ) assert res.exit_code == 0 if not recording: mocked_get_project_batches.assert_called_once() output_line = io.BytesIO() sys.stdout = output_line for response in ProjectBatches(**get_project_batches_response).results: echo("\t".join([ str(response.id), response.last_status.created.isoformat(), response.last_status.status, response.batch_type, response.name, ])) assert output_line.getvalue() == res.output.encode()
def test_list_project_samples(mocker, credentials, project_id, recording, vcr): # pylint: disable=unused-argument """Test project samples being outputed to the shell.""" runner = CliRunner() if not recording: # Mock get_project_samples only if using the cassettes, # since we mock the return value. mocked_samples = get_vcr_response("/api/v2/project-samples/", vcr, operator.contains) mocked_get_project_samples = mocker.patch.object( APIClient, "get_project_samples", return_value=ProjectSamples(**mocked_samples), ) res = runner.invoke( list_project_samples, [project_id, *credentials], ) assert res.exit_code == 0 if not recording: mocked_get_project_samples.assert_called_once() output_line = io.BytesIO() sys.stdout = output_line for mocked_sample in mocked_samples["results"]: mocked_sample = SampleDetails(**mocked_sample) echo_data("\t".join([ str(mocked_sample.last_status.created.isoformat()), str(mocked_sample.id), mocked_sample.client_id, mocked_sample.last_status.status, mocked_sample.archive_last_status.status, ])) assert output_line.getvalue() == res.output.encode()
def test_download_stdout_no_flag( credentials, mocker, project_id_download, recording, vcr ): """Test command exits if no flag provided and stdout defined.""" runner = CliRunner() if not recording: # Mock only if using the cassettes, since we mock the return value. get_project_samples_response = get_vcr_response( "/api/v2/project-samples/", vcr, operator.contains ) mocked_project_samples = mocker.patch.object( APIClient, "get_project_samples", return_value=ProjectSamples(**get_project_samples_response), ) res = runner.invoke( download, [ "-", "--project-id", project_id_download, *credentials, ], ) assert res.exit_code == 1 output_line = io.BytesIO() sys.stdout = output_line echo("ERROR: Cannot have - as a destination without download-urls.") assert output_line.getvalue() in res.output.encode() if not recording: mocked_project_samples.assert_called_once()
def test_delete_project_samples__success(deleted_sample, credentials, mocker, project_id, recording, vcr): # pylint: disable=too-many-arguments """Test delete project samples success.""" runner = CliRunner() if not recording: # Mock delete_project_samples only if using the cassettes, since we # mock the return value. delete_project_samples_response = get_vcr_response( "/api/v2/project-delete-samples/", vcr, operator.contains) mocked_delete_project_samples = mocker.patch.object( APIClient, "delete_project_samples", return_value=delete_project_samples_response, ) res = runner.invoke( delete_project_samples, [ project_id, *credentials, "--sample-ids", deleted_sample, ], ) assert res.exit_code == 0 if not recording: mocked_delete_project_samples.assert_called_once() assert ("The following samples have been deleted successfully" in res.output)
def test_create_project_batches__success__with_sample_ids( batch_name, batch_type, credentials, mocker, project_id_batches, recording, sample_id_batches, vcr, ): # pylint: disable=too-many-arguments """Test batch creation success when when sample ids are explicitly sent.""" runner = CliRunner() if not recording: # Mock create_project_batch only if using the cassettes, since we # mock the return value. create_project_batch_response = get_vcr_response( "/api/v2/project-batches/", vcr, operator.contains ) mocked_create_project_batch = mocker.patch.object( APIClient, "create_project_batch", return_value=ProjectBatches(**create_project_batch_response), ) res = runner.invoke( create_project_batch, [ project_id_batches, *credentials, "--batch-type", batch_type, "--batch-name", batch_name, "--sample-ids", sample_id_batches, ], ) assert res.exit_code == 0 if not recording: mocked_create_project_batch.assert_called_once() output_line = io.BytesIO() sys.stdout = output_line for response in ProjectBatches( **create_project_batch_response ).results: echo( "\t".join( [ str(response.id), response.last_status.created.isoformat(), response.last_status.status, response.batch_type, response.name, ] ) ) assert output_line.getvalue() == res.output.encode()
def test_upload_and_run_immediately_something_went_wrong( credentials, mocker, project_id, recording, vcr ): """Upload and assign right away did't work.""" runner = CliRunner() with runner.isolated_filesystem(): os.mkdir("cli_test_data") with open("cli_test_data/test.fastq.gz", "w") as fastq_file: fastq_file.write("AAABBB") mocked_get_credentials = mocker.patch( "gencove.command.upload.main.get_s3_client_refreshable", side_effect=get_s3_client_refreshable, ) mocked_upload_file = mocker.patch( "gencove.command.upload.main.upload_file", side_effect=upload_file ) if not recording: # Mock get_upload credentials only if using the cassettes, since # we mock the return value. upload_details_response = get_vcr_response( "/api/v2/uploads-post-data/", vcr ) mocked_get_upload_details = mocker.patch.object( APIClient, "get_upload_details", return_value=UploadsPostData(**upload_details_response), ) mocked_get_sample_sheet = mocker.patch.object( APIClient, "get_sample_sheet", return_value=SampleSheet( **{"meta": {"next": None}, "results": []} ), ) mocked_assign_sample = mocker.patch.object( APIClient, "add_samples_to_project" ) res = runner.invoke( upload, [ "cli_test_data", *credentials, "--run-project-id", project_id, ], ) assert res.exit_code == 0 mocked_get_credentials.assert_called_once() if not recording: mocked_get_upload_details.assert_called_once() mocked_upload_file.assert_called_once() mocked_get_sample_sheet.assert_called() mocked_assign_sample.assert_not_called()
def test_download_urls_to_file( credentials, mocker, project_id_download, recording, vcr ): """Test saving downloaded urls output to a json file.""" runner = CliRunner() if not recording: # Mock only if using the cassettes, since we mock the return value. get_project_samples_response = get_vcr_response( "/api/v2/project-samples/", vcr, operator.contains ) mocked_project_samples = mocker.patch.object( APIClient, "get_project_samples", return_value=ProjectSamples(**get_project_samples_response), ) get_sample_details_response = get_vcr_response( "/api/v2/samples/", vcr, operator.contains ) sample = SampleDetails(**get_sample_details_response) mocked_sample_details = mocker.patch.object( APIClient, "get_sample_details", return_value=sample, ) mocked_output_list = mocker.patch( "gencove.command.download.main.Download.output_list" ) with runner.isolated_filesystem(): res = runner.invoke( download, [ "output.json", "--project-id", project_id_download, *credentials, "--download-urls", ], ) assert res.exit_code == 0 mocked_output_list.assert_called_once() if not recording: mocked_project_samples.assert_called_once() mocked_sample_details.assert_called_once()
def test_upload_and_run_immediately_slow_response_retry( credentials, mocker, project_id, recording, vcr ): """Upload and assign right away and retry on slow response.""" runner = CliRunner() with runner.isolated_filesystem(): os.mkdir("cli_test_data") with open("cli_test_data/test.fastq.gz", "w") as fastq_file: fastq_file.write("AAABBB") mocked_get_credentials = mocker.patch( "gencove.command.upload.main.get_s3_client_refreshable", side_effect=get_s3_client_refreshable, ) mocked_upload_file = mocker.patch( "gencove.command.upload.main.upload_file", side_effect=upload_file ) if not recording: # Mock get_upload credentials only if using the cassettes, since # we mock the return value. upload_details_response = get_vcr_response( "/api/v2/uploads-post-data/", vcr ) mocked_get_upload_details = mocker.patch.object( APIClient, "get_upload_details", return_value=UploadsPostData(**upload_details_response), ) mocked_get_sample_sheet = mocker.patch.object( APIClient, "get_sample_sheet", side_effect=APIClientTimeout( "Could not connect to the api server" ), ) res = runner.invoke( upload, [ "cli_test_data", *credentials, "--run-project-id", project_id, "--no-progress", ], ) assert res.exit_code == 0 mocked_get_credentials.assert_called_once() mocked_upload_file.assert_called_once() if not recording: mocked_get_upload_details.assert_called_once() assert mocked_get_sample_sheet.call_count == 5 assert "there was an error automatically running them" in res.output
def test_list_projects(mocker, credentials, recording, vcr): """Test projects being outputed to the shell.""" runner = CliRunner() if not recording: # Mock list_projects only if using the cassettes, since we mock the # return value. list_projects_response = get_vcr_response("/api/v2/projects/", vcr) mocked_get_projects = mocker.patch.object( APIClient, "list_projects", return_value=Projects(**list_projects_response), ) get_pipeline_capabilities_response = get_vcr_response( "/api/v2/pipeline-capabilities/", vcr, operator.contains) mocked_get_pipeline_capabilities = mocker.patch.object( APIClient, "get_pipeline_capabilities", return_value=PipelineCapabilities( **get_pipeline_capabilities_response), ) res = runner.invoke(list_projects, credentials) assert res.exit_code == 0 if not recording: mocked_get_projects.assert_called_once() projects = list_projects_response["results"] assert mocked_get_pipeline_capabilities.call_count == len(projects) output_line = io.BytesIO() sys.stdout = output_line for project in projects: project = Project(**project) echo("\t".join([ str(project.created), str(project.id), project.name.replace("\t", " "), get_pipeline_capabilities_response["name"], ])) assert output_line.getvalue() == res.output.encode()
def test_upload_without_progressbar(credentials, mocker, recording, vcr): """Upload do not show the progress bar.""" runner = CliRunner() with runner.isolated_filesystem(): os.mkdir("cli_test_data") with open("cli_test_data/test.fastq.gz", "w") as fastq_file: fastq_file.write("AAABBB") mocked_get_credentials = mocker.patch( "gencove.command.upload.main.get_s3_client_refreshable", side_effect=get_s3_client_refreshable, ) mocked_upload_file = mocker.patch( "gencove.command.upload.main.upload_file" ) if not recording: # Mock get_upload_details only if using the cassettes, since # we mock the return value. upload_details_response = get_vcr_response( "/api/v2/uploads-post-data/", vcr ) mocked_get_upload_details = mocker.patch.object( APIClient, "get_upload_details", return_value=UploadsPostData(**upload_details_response), ) res = runner.invoke( upload, [ "cli_test_data", *credentials, "--no-progress", ], ) assert res.exit_code == 0 mocked_get_credentials.assert_called_once() mocked_upload_file.assert_called_once() assert mocked_upload_file.call_args[1]["no_progress"] if not recording: mocked_get_upload_details.assert_called_once()
def test_get_batch__no_progress_not_empty(batch_id, credentials, mocker, recording, vcr): """Test project batches being outputed to the shell without progress.""" runner = CliRunner() with runner.isolated_filesystem(): if not recording: # Mock get_batch only if using the cassettes, since we mock the # return value. get_batch_response = get_vcr_response("/api/v2/batches/", vcr, operator.contains) mocked_get_batch = mocker.patch.object( APIClient, "get_batch", return_value=BatchDetail(**get_batch_response), ) mocked_download_file = mocker.patch( "gencove.command.projects.get_batch.main.download.utils." "download_file", side_effect=download_file, ) res = runner.invoke( get_batch, [ batch_id, *credentials, "--output-filename", "test.zip", "--no-progress", ], ) assert res.exit_code == 0 if not recording: mocked_get_batch.assert_called_once() mocked_download_file.assert_called_once_with( "test.zip", HttpUrl( url="https://example.com/report.zip", scheme="https", host="example.com", ), no_progress=True, )
def test_list_project_batches__empty(credentials, mocker, project_id, recording, vcr): """Test project has not batches.""" runner = CliRunner() if not recording: # Mock create_project_batch only if using the cassettes, since we # mock the return value. get_project_batches_response = get_vcr_response( "/api/v2/project-batches/", vcr, operator.contains) mocked_get_project_batches = mocker.patch.object( APIClient, "get_project_batches", return_value=ProjectBatches(**get_project_batches_response), ) res = runner.invoke( list_project_batches, [project_id, *credentials], ) assert res.exit_code == 0 if not recording: mocked_get_project_batches.assert_called_once() assert res.output == ""
def test_upload(credentials, vcr, recording, mocker): """Sanity check that upload is ok.""" runner = CliRunner() with runner.isolated_filesystem(): os.mkdir("cli_test_data") with open("cli_test_data/test.fastq.gz", "w") as fastq_file: fastq_file.write("AAABBB") mocked_get_credentials = mocker.patch( "gencove.command.upload.main.get_s3_client_refreshable", side_effect=get_s3_client_refreshable, ) if not recording: # Mock get_upload credentials only if using the cassettes, since # we mock the return value. response = get_vcr_response("/api/v2/uploads-post-data/", vcr) mocked_get_upload_details = mocker.patch.object( APIClient, "get_upload_details", return_value=UploadsPostData(**response), ) mocked_upload_file = mocker.patch( "gencove.command.upload.main.upload_file", side_effect=upload_file ) res = runner.invoke( upload, ["cli_test_data", *credentials], ) assert not res.exception assert res.exit_code == 0 assert ( "Uploading cli_test_data/test.fastq.gz to gncv://" in res.output ) assert "All files were successfully uploaded." in res.output mocked_get_credentials.assert_called_once() if not recording: mocked_get_upload_details.assert_called_once() mocked_upload_file.assert_called_once() assert not mocked_upload_file.call_args[1]["no_progress"]
def test_download_not_working_because_archived( archived_sample, credentials, mocker, recording, vcr ): """Test command doesn't download archived files.""" runner = CliRunner() with runner.isolated_filesystem(): if not recording: # Mock only if using the cassettes, since we mock the return value. get_sample_details_response = get_vcr_response( "/api/v2/samples/", vcr, operator.contains ) mocked_sample_details = mocker.patch.object( APIClient, "get_sample_details", return_value=SampleDetails(**get_sample_details_response), ) mocked_qc_metrics = mocker.patch.object( APIClient, "get_sample_qc_metrics" ) mocked_get_metadata = mocker.patch.object(APIClient, "get_metadata") mocked_download_file = mocker.patch( "gencove.command.download.main.download_file", ) res = runner.invoke( download, [ "cli_test_data", "--sample-ids", archived_sample, *credentials, ], ) assert res.exit_code == 1 assert "is archived and cannot be downloaded " in res.output if not recording: mocked_sample_details.assert_called_once() mocked_qc_metrics.assert_not_called() mocked_get_metadata.assert_not_called() mocked_download_file.assert_not_called()
def test_list_projects_slow_response_retry_pipeline(mocker, credentials, recording, vcr): """Test projects slow repsonse retry on the pipeline capabilities.""" runner = CliRunner() if not recording: # Mock list_projects only if using the cassettes, since we mock the # return value. list_projects_response = get_vcr_response("/api/v2/projects/", vcr) mocked_get_projects = mocker.patch.object( APIClient, "list_projects", return_value=Projects(**list_projects_response), ) mocked_get_pipeline_capabilities = mocker.patch.object( APIClient, "get_pipeline_capabilities", side_effect=APIClientTimeout("Could not connect to the api server"), ) res = runner.invoke(list_projects, credentials) assert res.exit_code == 1 if not recording: mocked_get_projects.assert_called_once() assert mocked_get_pipeline_capabilities.call_count == 3
def test_delete_project_samples__sample_not_in_project(credentials, mocker, project_id, recording, vcr): """Test delete project samples with sample not in project.""" runner = CliRunner() if not recording: # Mock delete_project_samples only if using the cassettes, since we # mock the return value. delete_project_samples_response = get_vcr_response( "/api/v2/project-delete-samples/", vcr, operator.contains, just_body=False, ) mocked_delete_project_samples = mocker.patch.object( APIClient, "delete_project_samples", side_effect=APIClientError( message=delete_project_samples_response["body"]["string"], status_code=delete_project_samples_response["status"]["code"], ), ) res = runner.invoke( delete_project_samples, [ project_id, *credentials, "--sample-ids", "11111111-1111-1111-1111-111111111111", ], ) assert res.exit_code == 0 if not recording: mocked_delete_project_samples.assert_called_once() assert "All sample ids must be part of the current project." in res.output
def test_list_uploads(mocker, credentials, recording, vcr): """Test list uploads being outputed to the shell.""" runner = CliRunner() if not recording: sample_sheet_response = get_vcr_response("/api/v2/sample-sheet/", vcr) mocked_get_sample_sheet = mocker.patch.object( APIClient, "get_sample_sheet", return_value=SampleSheet(**sample_sheet_response), ) res = runner.invoke(list_uploads, credentials) assert res.exit_code == 0 if not recording: mocked_get_sample_sheet.assert_called() uploads = sample_sheet_response["results"] uploads = "\n".join([ "\t".join([ upload["client_id"], upload["fastq"]["r1"]["upload"], upload["fastq"]["r1"]["destination_path"], ]) for upload in uploads ]) assert f"{uploads}\n" == res.output
def test_upload_and_run_immediately_with_stdout( credentials, mocker, project_id, recording, vcr ): """Upload and assign right away, then print out the results.""" # pylint: disable=too-many-locals runner = CliRunner() with runner.isolated_filesystem(): os.mkdir("cli_test_data") with open("cli_test_data/test.fastq.gz", "w") as fastq_file: fastq_file.write("AAABBB") mocked_get_credentials = mocker.patch( "gencove.command.upload.main.get_s3_client_refreshable", side_effect=get_s3_client_refreshable, ) if not recording: # Mock get_upload credentials only if using the cassettes, since # we mock the return value. upload_details_response = get_vcr_response( "/api/v2/uploads-post-data/", vcr ) mocked_get_upload_details = mocker.patch.object( APIClient, "get_upload_details", return_value=UploadsPostData(**upload_details_response), ) sample_sheet_response = get_vcr_response( "/api/v2/sample-sheet/", vcr ) mocked_get_sample_sheet = mocker.patch.object( APIClient, "get_sample_sheet", return_value=SampleSheet(**sample_sheet_response), ) project_sample_response = get_vcr_response( "/api/v2/project-samples/", vcr, operator.contains ) mocked_assign_sample = mocker.patch.object( APIClient, "add_samples_to_project", return_value=UploadSamples(**project_sample_response), ) # These mocks needs to be here and without side effect otherwise # a weird behavior on the stdout will happend and the test fails. mocked_upload_file = mocker.patch( "gencove.command.upload.main.upload_file" ) mocker.patch( "gencove.command.upload.main.get_regular_progress_bar", ) res = runner.invoke( upload, [ "cli_test_data", *credentials, "--run-project-id", project_id, "--output", "-", ], ) assert res.exit_code == 0 mocked_get_credentials.assert_called_once() if not recording: mocked_upload_file.assert_called_once() mocked_get_upload_details.assert_called_once() mocked_get_sample_sheet.assert_called() mocked_assign_sample.assert_called_once() # r2 fastq key is not present on the file assert ( project_sample_response["uploads"][0]["fastq"]["r2"] is None ) del project_sample_response["uploads"][0]["fastq"]["r2"] assert ( json.dumps(project_sample_response["uploads"], indent=4) in res.output )
def test_upload_and_run_immediately_without_progressbar( credentials, mocker, project_id, recording, vcr ): """Upload and assign right away.""" # pylint: disable=too-many-locals runner = CliRunner() with runner.isolated_filesystem(): os.mkdir("cli_test_data") with open("cli_test_data/test.fastq.gz", "w") as fastq_file: fastq_file.write("AAABBB") mocked_get_credentials = mocker.patch( "gencove.command.upload.main.get_s3_client_refreshable", side_effect=get_s3_client_refreshable, ) mocked_upload_file = mocker.patch( "gencove.command.upload.main.upload_file", side_effect=upload_file ) mocked_regular_progress_bar = mocker.patch( "gencove.command.upload.main.get_regular_progress_bar", side_effect=get_regular_progress_bar, ) if not recording: # Mock get_upload credentials only if using the cassettes, since # we mock the return value. upload_details_response = get_vcr_response( "/api/v2/uploads-post-data/", vcr ) mocked_get_upload_details = mocker.patch.object( APIClient, "get_upload_details", return_value=UploadsPostData(**upload_details_response), ) sample_sheet_response = get_vcr_response( "/api/v2/sample-sheet/", vcr ) mocked_get_sample_sheet = mocker.patch.object( APIClient, "get_sample_sheet", return_value=SampleSheet(**sample_sheet_response), ) project_sample_response = get_vcr_response( "/api/v2/project-samples/", vcr, operator.contains ) mocked_assign_sample = mocker.patch.object( APIClient, "add_samples_to_project", return_value=UploadSamples(**project_sample_response), ) res = runner.invoke( upload, [ "cli_test_data", *credentials, "--run-project-id", project_id, "--no-progress", ], ) assert res.exit_code == 0 mocked_get_credentials.assert_called_once() mocked_upload_file.assert_called_once() mocked_regular_progress_bar.assert_not_called() if not recording: mocked_get_upload_details.assert_called_once() mocked_get_sample_sheet.assert_called() mocked_assign_sample.assert_called_once()
def test_sample_ids_provided_no_qc_file( credentials, mocker, recording, sample_id_download, vcr ): """Check flow with sample ids and no file present.""" runner = CliRunner() with runner.isolated_filesystem(): mocked_sample_details = mocker.patch.object( APIClient, "get_sample_details", return_value=SampleDetails( **{ "id": sample_id_download, "client_id": "1", "last_status": { "id": str(uuid4()), "status": "succeeded", "created": "2020-07-28T12:46:22.719862Z", }, "archive_last_status": { "id": str(uuid4()), "status": "available", "created": "2020-07-28T12:46:22.719862Z", "transition_cutoff": "2020-08-28T12:46:22.719862Z", }, "files": [], } ), ) if not recording: # Mock only if using the cassettes, since we mock the return value. get_sample_qc_metrics_response = get_vcr_response( "/api/v2/sample-quality-controls/", vcr, operator.contains ) mocked_qc_metrics = mocker.patch.object( APIClient, "get_sample_qc_metrics", return_value=SampleQC(**get_sample_qc_metrics_response), ) get_metadata_response = get_vcr_response( "/api/v2/sample-metadata/", vcr, operator.contains ) mocked_get_metadata = mocker.patch.object( APIClient, "get_metadata", return_value=SampleMetadata(**get_metadata_response), ) mocked_download_file = mocker.patch( "gencove.command.download.main.download_file", side_effect=download_file, ) res = runner.invoke( download, [ "cli_test_data", "--sample-ids", sample_id_download, *credentials, ], ) assert res.exit_code == 0 mocked_download_file.assert_not_called() if not recording: mocked_sample_details.assert_called_once() mocked_qc_metrics.assert_called_once() mocked_get_metadata.assert_called_once()
def test_project_id_provided_skip_existing_qc_and_metadata( credentials, mocker, project_id_download, recording, vcr ): """Check happy flow.""" # pylint: disable=too-many-locals runner = CliRunner() with runner.isolated_filesystem(): if not recording: # Mock only if using the cassettes, since we mock the return value. get_project_samples_response = get_vcr_response( "/api/v2/project-samples/", vcr, operator.contains ) mocked_project_samples = mocker.patch.object( APIClient, "get_project_samples", return_value=ProjectSamples(**get_project_samples_response), ) get_sample_details_response = get_vcr_response( "/api/v2/samples/", vcr, operator.contains ) mocked_sample_details = mocker.patch.object( APIClient, "get_sample_details", return_value=SampleDetails(**get_sample_details_response), ) get_sample_qc_metrics_response = get_vcr_response( "/api/v2/sample-quality-controls/", vcr, operator.contains ) mocked_qc_metrics = mocker.patch.object( APIClient, "get_sample_qc_metrics", return_value=SampleQC(**get_sample_qc_metrics_response), ) get_metadata_response = get_vcr_response( "/api/v2/sample-metadata/", vcr, operator.contains ) mocked_get_metadata = mocker.patch.object( APIClient, "get_metadata", return_value=SampleMetadata(**get_metadata_response), ) mocked_download_file = mocker.patch( "gencove.command.download.main.download_file", side_effect=download_file, ) res = runner.invoke( download, [ "cli_test_data", "--project-id", project_id_download, *credentials, "--no-skip-existing", ], ) assert res.exit_code == 0 if not recording: mocked_project_samples.assert_called_once() mocked_sample_details.assert_called_once() mocked_qc_metrics.assert_called_once() mocked_get_metadata.assert_called_once() mocked_download_file.assert_called_once() # call it the second time mocked_qc_metrics = mocker.patch.object( APIClient, "get_sample_qc_metrics" ) mocked_get_metadata = mocker.patch.object(APIClient, "get_metadata") res = runner.invoke( download, [ "cli_test_data", "--project-id", project_id_download, *credentials, "--skip-existing", ], ) assert res.exit_code == 0 mocked_qc_metrics.assert_not_called() mocked_get_metadata.assert_not_called()
def test_download_stdout_with_flag( credentials, mocker, project_id_download, recording, vcr ): """Test command outputs json to stdout.""" # pylint: disable=too-many-locals runner = CliRunner() if not recording: # Mock only if using the cassettes, since we mock the return value. get_project_samples_response = get_vcr_response( "/api/v2/project-samples/", vcr, operator.contains ) mocked_project_samples = mocker.patch.object( APIClient, "get_project_samples", return_value=ProjectSamples(**get_project_samples_response), ) get_sample_details_response = get_vcr_response( "/api/v2/samples/", vcr, operator.contains ) sample = SampleDetails(**get_sample_details_response) mocked_sample_details = mocker.patch.object( APIClient, "get_sample_details", return_value=sample, ) res = runner.invoke( download, [ "-", "--project-id", project_id_download, *credentials, "--download-urls", ], ) assert res.exit_code == 0 if not recording: mocked_project_samples.assert_called_once() mocked_sample_details.assert_called_once() output_line = io.BytesIO() sys.stdout = output_line for _ in get_project_samples_response["results"]: archive_last_status_created = ( sample.archive_last_status.created.isoformat() ) download_url = "https://example.com/r1.fastq.gz" mocked_result = json.dumps( [ { "gencove_id": MOCK_UUID, "client_id": "mock_client_id", "last_status": { "id": MOCK_UUID, "status": sample.last_status.status, "created": sample.last_status.created.isoformat(), }, "archive_last_status": { "id": MOCK_UUID, "status": sample.archive_last_status.status, "created": archive_last_status_created, "transition_cutoff": None, }, "files": { "fastq-r1": { "id": MOCK_UUID, "download_url": download_url, } }, } ], indent=4, ) echo(mocked_result) assert output_line.getvalue() in res.output.encode()