def test_add_sample_required(cli_runner: CliRunner, base_context: CGConfig,
helpers: StoreHelpers):
# GIVEN a database with a customer and an application
disk_store: Store = base_context.status_db
sex = "male"
application_tag = "dummy_tag"
helpers.ensure_application(store=disk_store, tag=application_tag)
helpers.ensure_application_version(store=disk_store,
application_tag=application_tag)
customer: models.Customer = helpers.ensure_customer(store=disk_store)
customer_id = customer.internal_id
name = "sample_name"
# WHEN adding a sample
result = cli_runner.invoke(
add,
[
"sample",
"--sex",
sex,
"--application",
application_tag,
customer_id,
name,
],
obj=base_context,
)
# THEN it should be added
assert result.exit_code == 0
assert disk_store.Sample.query.count() == 1
assert disk_store.Sample.query.first().name == name
assert disk_store.Sample.query.first().sex == sex
def fixture_dna_mip_context(
cg_context: CGConfig,
helpers: StoreHelpers,
mip_case_ids: dict,
real_housekeeper_api: HousekeeperAPI,
tb_api,
) -> CGConfig:
_store = cg_context.status_db
cg_context.housekeeper_api_ = real_housekeeper_api
cg_context.trailblazer_api_ = tb_api
mip_analysis_api = MipDNAAnalysisAPI(config=cg_context)
# Add apptag to db
helpers.ensure_application_version(store=_store,
application_tag="WGSA",
application_type="wgs")
# Add sample, cases and relationships to db
for case_id in mip_case_ids:
if not _store.family(case_id):
case_obj = helpers.add_case(
store=_store,
data_analysis=Pipeline.MIP_DNA,
internal_id=case_id,
name=mip_case_ids[case_id]["name"],
)
sample = helpers.add_sample(
store=_store,
customer_id="cust000",
application_tag="WGSA",
application_type="wgs",
gender="unknown",
)
helpers.add_relationship(store=_store,
sample=sample,
case=case_obj,
status="affected")
cg_context.meta_apis["analysis_api"] = mip_analysis_api
return cg_context
def test_add_sample_downsampled(
cli_runner,
base_context: CGConfig,
disk_store: Store,
application_tag: str,
helpers: StoreHelpers,
):
# GIVEN a database with a customer and an application
helpers.ensure_application(store=disk_store, tag=application_tag)
helpers.ensure_application_version(store=disk_store,
application_tag=application_tag)
customer: models.Customer = helpers.ensure_customer(store=disk_store)
customer_id = customer.internal_id
sex = "male"
name = "sample_name"
downsampled_to = "123"
# WHEN adding a sample
result = cli_runner.invoke(
add,
[
"sample",
"--sex",
sex,
"--application",
application_tag,
"--downsampled",
downsampled_to,
customer_id,
name,
],
obj=base_context,
)
# THEN it should be added
assert result.exit_code == 0
assert disk_store.Sample.query.count() == 1
assert str(
disk_store.Sample.query.first().downsampled_to) == downsampled_to
def fixture_balsamic_context(
cg_context: CGConfig,
helpers: StoreHelpers,
balsamic_lims: MockLimsAPI,
balsamic_housekeeper: HousekeeperAPI,
trailblazer_api: MockTB,
hermes_api: HermesApi,
cg_dir,
) -> CGConfig:
"""context to use in cli"""
cg_context.housekeeper_api_ = balsamic_housekeeper
cg_context.lims_api_ = balsamic_lims
cg_context.trailblazer_api_ = trailblazer_api
cg_context.meta_apis["analysis_api"] = BalsamicAnalysisAPI(
config=cg_context)
status_db: Store = cg_context.status_db
# Create tgs application version
helpers.ensure_application_version(store=status_db,
application_tag="TGSA",
application_type="tgs")
# Create wes application version
helpers.ensure_application_version(store=status_db,
application_tag="WESA",
application_type="wes")
# Create textbook case for WGS PAIRED with enough reads
case_wgs_paired_enough_reads = helpers.add_case(
store=status_db,
internal_id="balsamic_case_wgs_paired_enough_reads",
name="balsamic_case_wgs_paired_enough_reads",
data_analysis=Pipeline.BALSAMIC,
)
sample_case_wgs_paired_tumor_enough_reads = helpers.add_sample(
status_db,
internal_id="sample_case_wgs_paired_tumor_enough_reads",
is_tumour=True,
application_type="wgs",
reads=10,
sequenced_at=dt.datetime.now(),
)
sample_case_wgs_paired_normal_enough_reads = helpers.add_sample(
status_db,
internal_id="sample_case_wgs_paired_normal_enough_reads",
is_tumour=False,
application_type="wgs",
reads=10,
sequenced_at=dt.datetime.now(),
)
helpers.add_relationship(
status_db,
case=case_wgs_paired_enough_reads,
sample=sample_case_wgs_paired_tumor_enough_reads,
)
helpers.add_relationship(
status_db,
case=case_wgs_paired_enough_reads,
sample=sample_case_wgs_paired_normal_enough_reads,
)
# Create textbook case for WGS PAIRED
case_wgs_paired = helpers.add_case(
store=status_db,
internal_id="balsamic_case_wgs_paired",
name="balsamic_case_wgs_paired",
data_analysis=Pipeline.BALSAMIC,
)
sample_case_wgs_paired_tumor = helpers.add_sample(
status_db,
internal_id="sample_case_wgs_paired_tumor",
is_tumour=True,
application_type="wgs",
reads=10,
sequenced_at=dt.datetime.now(),
)
sample_case_wgs_paired_normal = helpers.add_sample(
status_db,
internal_id="sample_case_wgs_paired_normal",
is_tumour=False,
application_type="wgs",
reads=10,
sequenced_at=dt.datetime.now(),
)
helpers.add_relationship(status_db,
case=case_wgs_paired,
sample=sample_case_wgs_paired_tumor)
helpers.add_relationship(status_db,
case=case_wgs_paired,
sample=sample_case_wgs_paired_normal)
# Create textbook case for TGS PAIRED without enough reads
case_tgs_paired = helpers.add_case(
status_db,
internal_id="balsamic_case_tgs_paired",
name="balsamic_case_tgs_paired",
data_analysis=Pipeline.BALSAMIC,
)
sample_case_tgs_paired_tumor = helpers.add_sample(
status_db,
internal_id="sample_case_tgs_paired_tumor",
is_tumour=True,
application_tag="TGSA",
application_type="tgs",
reads=10,
sequenced_at=dt.datetime.now(),
)
sample_case_tgs_paired_normal = helpers.add_sample(
status_db,
internal_id="sample_case_tgs_paired_normal",
is_tumour=False,
application_tag="TGSA",
application_type="tgs",
reads=0,
sequenced_at=dt.datetime.now(),
)
helpers.add_relationship(status_db,
case=case_tgs_paired,
sample=sample_case_tgs_paired_tumor)
helpers.add_relationship(status_db,
case=case_tgs_paired,
sample=sample_case_tgs_paired_normal)
# Create textbook case for WGS TUMOR ONLY
case_wgs_single = helpers.add_case(
status_db,
internal_id="balsamic_case_wgs_single",
name="balsamic_case_wgs_single",
data_analysis=Pipeline.BALSAMIC,
)
sample_case_wgs_single_tumor = helpers.add_sample(
status_db,
internal_id="sample_case_wgs_single_tumor",
is_tumour=True,
application_type="wgs",
reads=100,
sequenced_at=dt.datetime.now(),
)
helpers.add_relationship(status_db,
case=case_wgs_single,
sample=sample_case_wgs_single_tumor)
# Create textbook case for TGS TUMOR ONLY
case_tgs_single = helpers.add_case(
status_db,
internal_id="balsamic_case_tgs_single",
name="balsamic_case_tgs_single",
data_analysis=Pipeline.BALSAMIC,
)
sample_case_tgs_single_tumor = helpers.add_sample(
status_db,
internal_id="sample_case_tgs_single_tumor",
is_tumour=True,
application_tag="TGSA",
application_type="tgs",
sequenced_at=dt.datetime.now(),
)
helpers.add_relationship(status_db,
case=case_tgs_single,
sample=sample_case_tgs_single_tumor)
# Create ERROR case for TGS NORMAL ONLY
case_tgs_single_error = helpers.add_case(
status_db,
internal_id="balsamic_case_tgs_single_error",
name="balsamic_case_tgs_single_error",
data_analysis=Pipeline.BALSAMIC,
)
sample_case_tgs_single_normal_error = helpers.add_sample(
status_db,
internal_id="sample_case_tgs_single_normal_error",
is_tumour=False,
application_tag="TGSA",
application_type="tgs",
sequenced_at=dt.datetime.now(),
)
helpers.add_relationship(
status_db,
case=case_tgs_single_error,
sample=sample_case_tgs_single_normal_error,
)
# Create ERROR case for TGS TWO TUMOR ONE NORMAL
case_tgs_paired_error = helpers.add_case(
status_db,
internal_id="balsamic_case_tgs_paired_error",
name="balsamic_case_tgs_paired_error",
data_analysis=Pipeline.BALSAMIC,
)
sample_case_tgs_paired_tumor_error = helpers.add_sample(
status_db,
internal_id="sample_case_tgs_paired_tumor_error",
is_tumour=True,
application_tag="TGSA",
application_type="tgs",
sequenced_at=dt.datetime.now(),
)
sample_case_tgs_paired_tumor2_error = helpers.add_sample(
status_db,
internal_id="sample_case_tgs_paired_tumor2_error",
is_tumour=True,
application_tag="TGSA",
application_type="tgs",
sequenced_at=dt.datetime.now(),
)
sample_case_tgs_paired_normal_error = helpers.add_sample(
status_db,
internal_id="sample_case_tgs_paired_normal_error",
is_tumour=False,
application_tag="TGSA",
application_type="tgs",
sequenced_at=dt.datetime.now(),
)
helpers.add_relationship(
status_db,
case=case_tgs_paired_error,
sample=sample_case_tgs_paired_tumor_error,
)
helpers.add_relationship(
status_db,
case=case_tgs_paired_error,
sample=sample_case_tgs_paired_tumor2_error,
)
helpers.add_relationship(
status_db,
case=case_tgs_paired_error,
sample=sample_case_tgs_paired_normal_error,
)
# Create ERROR case for MIXED application type
case_mixed_paired_error = helpers.add_case(
status_db,
internal_id="balsamic_case_mixed_paired_error",
name="balsamic_case_mixed_paired_error",
data_analysis=Pipeline.BALSAMIC,
)
mixed_sample_case_wgs_paired_tumor_error = helpers.add_sample(
status_db,
internal_id="mixed_sample_case_wgs_paired_tumor_error",
is_tumour=True,
application_type="wgs",
sequenced_at=dt.datetime.now(),
)
mixed_sample_case_tgs_paired_normal_error = helpers.add_sample(
status_db,
internal_id="mixed_sample_case_tgs_paired_normal_error",
is_tumour=False,
application_tag="TGSA",
application_type="tgs",
sequenced_at=dt.datetime.now(),
)
helpers.add_relationship(
status_db,
case=case_mixed_paired_error,
sample=mixed_sample_case_wgs_paired_tumor_error,
)
helpers.add_relationship(
status_db,
case=case_mixed_paired_error,
sample=mixed_sample_case_tgs_paired_normal_error,
)
# Create ERROR case for MIXED application type NOT BALSAMIC APPLICATION
case_mixed_wgs_mic_paired_error = helpers.add_case(
status_db,
internal_id="balsamic_case_mixed_wgs_mic_paired_error",
name="balsamic_case_mixed_wgs_mic_paired_error",
data_analysis=Pipeline.BALSAMIC,
)
mixed_sample_case_wgs_mic_paired_tumor_error = helpers.add_sample(
status_db,
internal_id="mixed_sample_case_wgs_mic_paired_tumor_error",
is_tumour=True,
application_type="wgs",
sequenced_at=dt.datetime.now(),
)
mixed_sample_case_wgs_mic_paired_normal_error = helpers.add_sample(
status_db,
internal_id="mixed_sample_case_wgs_mic_paired_normal_error",
is_tumour=False,
application_tag="MICA",
application_type="mic",
sequenced_at=dt.datetime.now(),
)
helpers.add_relationship(
status_db,
case=case_mixed_wgs_mic_paired_error,
sample=mixed_sample_case_wgs_mic_paired_tumor_error,
)
helpers.add_relationship(
status_db,
case=case_mixed_wgs_mic_paired_error,
sample=mixed_sample_case_wgs_mic_paired_normal_error,
)
# Create ERROR case for MIXED TARGET BED
case_mixed_bed_paired_error = helpers.add_case(
status_db,
internal_id="balsamic_case_mixed_bed_paired_error",
name="balsamic_case_mixed_bed_paired_error",
data_analysis=Pipeline.BALSAMIC,
)
mixed_sample_case_mixed_bed_paired_tumor_error = helpers.add_sample(
status_db,
internal_id="mixed_sample_case_mixed_bed_paired_tumor_error",
is_tumour=True,
application_tag="TGSA",
application_type="tgs",
sequenced_at=dt.datetime.now(),
)
mixed_sample_case_mixed_bed_paired_normal_error = helpers.add_sample(
status_db,
internal_id="mixed_sample_case_mixed_bed_paired_normal_error",
is_tumour=False,
application_tag="TGSA",
application_type="tgs",
sequenced_at=dt.datetime.now(),
)
helpers.add_relationship(
status_db,
case=case_mixed_bed_paired_error,
sample=mixed_sample_case_mixed_bed_paired_tumor_error,
)
helpers.add_relationship(
status_db,
case=case_mixed_bed_paired_error,
sample=mixed_sample_case_mixed_bed_paired_normal_error,
)
# Create ERROR case for WGS TUMOR ONLY MIP CLI_OPTION_ANALYSIS ONLY
mip_case_wgs_single = helpers.add_case(
status_db,
internal_id="mip_case_wgs_single",
name="mip_case_wgs_single",
data_analysis=Pipeline.MIP_DNA,
)
mip_sample_case_wgs_single_tumor = helpers.add_sample(
status_db,
internal_id="mip_sample_case_wgs_single_tumor",
is_tumour=True,
application_type="wgs",
sequenced_at=dt.datetime.now(),
)
helpers.add_relationship(
status_db,
case=mip_case_wgs_single,
sample=mip_sample_case_wgs_single_tumor,
)
# Create ERROR case for WGS ONE TUMOR TWO NORMAL
case_wgs_paired_two_normal_error = helpers.add_case(
status_db,
internal_id="balsamic_case_wgs_paired_two_normal_error",
name="balsamic_case_wgs_paired_two_normal_error",
data_analysis=Pipeline.BALSAMIC,
)
sample_case_wgs_paired_two_normal_tumor_error = helpers.add_sample(
status_db,
internal_id="sample_case_wgs_paired_two_normal_tumor_error",
is_tumour=True,
application_tag="WGSA",
application_type="wgs",
sequenced_at=dt.datetime.now(),
)
sample_case_wgs_paired_two_normal_normal1_error = helpers.add_sample(
status_db,
internal_id="sample_case_wgs_paired_two_normal_normal1_error",
is_tumour=False,
application_tag="WGSA",
application_type="wgs",
sequenced_at=dt.datetime.now(),
)
sample_case_wgs_paired_two_normal_normal2_error = helpers.add_sample(
status_db,
internal_id="sample_case_wgs_paired_two_normal_normal2_error",
is_tumour=False,
application_tag="WGSA",
application_type="wgs",
sequenced_at=dt.datetime.now(),
)
helpers.add_relationship(
status_db,
case=case_wgs_paired_two_normal_error,
sample=sample_case_wgs_paired_two_normal_tumor_error,
)
helpers.add_relationship(
status_db,
case=case_wgs_paired_two_normal_error,
sample=sample_case_wgs_paired_two_normal_normal1_error,
)
helpers.add_relationship(
status_db,
case=case_wgs_paired_two_normal_error,
sample=sample_case_wgs_paired_two_normal_normal2_error,
)
# Create WES case with 1 tumor sample
case_wes_tumor = helpers.add_case(
status_db,
internal_id="balsamic_case_wes_tumor",
name="balsamic_case_wes_tumor",
data_analysis=Pipeline.BALSAMIC,
)
sample_case_wes_tumor = helpers.add_sample(
status_db,
internal_id="sample_case_wes_tumor",
is_tumour=True,
application_tag="WESA",
application_type="wes",
sequenced_at=dt.datetime.now(),
)
helpers.add_relationship(status_db,
case=case_wes_tumor,
sample=sample_case_wes_tumor)
# Create ERROR case for WES when no panel is found
case_wes_panel_error = helpers.add_case(
status_db,
internal_id="balsamic_case_wes_panel_error",
name="balsamic_case_wes_panel_error",
data_analysis=Pipeline.BALSAMIC,
)
sample_case_wes_panel_error = helpers.add_sample(
status_db,
internal_id="sample_case_wes_panel_error",
is_tumour=True,
application_tag="WESA",
application_type="wes",
sequenced_at=dt.datetime.now(),
)
helpers.add_relationship(status_db,
case=case_wes_panel_error,
sample=sample_case_wes_panel_error)
# Create ERROR case with NO SAMPLES
helpers.add_case(status_db,
internal_id="no_sample_case",
name="no_sample_case")
# Create BED1 version 1
bed1_name = "BalsamicBed1"
bed1_filename = "balsamic_bed_1.bed"
Path(cg_dir, bed1_filename).touch(exist_ok=True)
bed1 = status_db.add_bed(name=bed1_name)
status_db.add_commit(bed1)
version1 = status_db.add_bed_version(bed=bed1,
version=1,
filename=bed1_filename,
shortname=bed1_name)
status_db.add_commit(version1)
# Create BED2 version 1
bed2_name = "BalsamicBed2"
bed2_filename = "balsamic_bed_2.bed"
Path(cg_dir, bed2_filename).touch(exist_ok=True)
bed2 = status_db.add_bed(name=bed2_name)
status_db.add_commit(bed2)
version2 = status_db.add_bed_version(bed=bed2,
version=1,
filename=bed2_filename,
shortname=bed2_name)
status_db.add_commit(version2)
return cg_context
