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()
