def test_add_relationship_bad_father(cli_runner: CliRunner,
base_context: CGConfig,
helpers: StoreHelpers):
"""Test to add a relationship using a non-existing father"""
# GIVEN a database with a sample and an case
disk_store: Store = base_context.status_db
sample = helpers.add_sample(disk_store)
sample_id = sample.internal_id
father_id = "bad_father"
case = helpers.add_case(disk_store)
case_id = case.internal_id
status = "affected"
# WHEN adding a relationship
result = cli_runner.invoke(
add,
[
"relationship",
case_id,
sample_id,
"-s",
status,
"-f",
father_id,
],
obj=base_context,
)
# THEN it should not be added
assert result.exit_code == 1
assert disk_store.FamilySample.query.count() == 0
def test_delete_child_case(cli_runner: CliRunner, base_context: CGConfig, helpers: StoreHelpers):
"""Test that the delete case will not delete a sample linked to another case as mother"""
# GIVEN a database with a mother case and a child case with the mother as mother
base_store: Store = base_context.status_db
case_mother = helpers.add_case(base_store, "case_mother")
sample_mother = helpers.add_sample(base_store, "mother")
sample_child = helpers.add_sample(base_store, "child")
helpers.add_relationship(store=base_store, case=case_mother, sample=sample_mother)
case_child = helpers.add_case(base_store, "case_child")
case_child_id = case_child.internal_id
helpers.add_relationship(
store=base_store, case=case_child, sample=sample_child, mother=sample_mother
)
assert base_store.Family.query.count() == 2
assert base_store.FamilySample.query.count() == 2
assert base_store.Sample.query.count() == 2
# WHEN deleting the child case
result = cli_runner.invoke(delete_case_command, [case_child_id, "--yes"], obj=base_context)
# THEN the child sample is deletable
assert result.exit_code == SUCCESS
assert base_store.Family.query.count() == 1
assert base_store.FamilySample.query.count() == 1
assert base_store.Sample.query.count() == 1
def test_delete_case_with_father_links(
cli_runner: CliRunner, base_context: CGConfig, helpers: StoreHelpers
):
"""Test that the delete case will not delete a sample linked to another case as father"""
# GIVEN a database with a case
base_store: Store = base_context.status_db
case_obj = helpers.add_case(base_store, "first_case_linked_to_sample")
case_id = case_obj.internal_id
sample_father = helpers.add_sample(base_store, "father")
sample_child = helpers.add_sample(base_store, "child")
helpers.add_relationship(store=base_store, case=case_obj, sample=sample_father)
case_obj2 = helpers.add_case(base_store, "second_case_linked_to_sample")
helpers.add_relationship(
store=base_store, case=case_obj2, sample=sample_child, father=sample_father
)
assert base_store.Family.query.count() == 2
assert base_store.FamilySample.query.count() == 2
assert base_store.Sample.query.count() == 2
# WHEN deleting a case
result = cli_runner.invoke(delete_case_command, [case_id, "--yes"], obj=base_context)
# THEN the first case should be gone with its link to the sample but not the other or
# the father sample
assert result.exit_code == SUCCESS
assert base_store.Family.query.count() == 1
assert base_store.FamilySample.query.count() == 1
assert base_store.Sample.query.count() == 2
def test_add_relationship_mother(cli_runner: CliRunner, base_context: CGConfig,
helpers: StoreHelpers):
"""Test to add a relationship with a mother"""
# GIVEN a database with a sample and an case
disk_store: Store = base_context.status_db
sample = helpers.add_sample(disk_store)
sample_id = sample.internal_id
mother = helpers.add_sample(disk_store, name="mother")
mother_id = mother.internal_id
case = helpers.add_case(disk_store)
case_id = case.internal_id
status = "affected"
# WHEN adding a relationship
result = cli_runner.invoke(
add,
[
"relationship",
case_id,
sample_id,
"-s",
status,
"-m",
mother_id,
],
obj=base_context,
)
# THEN it should be added
assert result.exit_code == 0
assert disk_store.FamilySample.query.count() == 1
assert disk_store.FamilySample.query.first(
).mother.internal_id == mother_id
def test_lists_family(cli_runner: CliRunner, base_context: CGConfig, helpers: StoreHelpers):
"""Test to that cases displays case in database"""
# GIVEN a database with a case
base_store: Store = base_context.status_db
case = helpers.add_case(base_store)
# WHEN listing cases
result = cli_runner.invoke(cases, obj=base_context)
# THEN the case should be listed
assert result.exit_code == 0
assert case.internal_id in result.output
def test_delete_case_without_options(
cli_runner: CliRunner, base_context: CGConfig, helpers: StoreHelpers
):
"""Test to delete a case using only the required arguments"""
# GIVEN a database with a case
base_store: Store = base_context.status_db
helpers.add_case(base_store)
assert base_store.Family.query.count() == 1
# WHEN deleting a case
result = cli_runner.invoke(delete_case_command, obj=base_context)
# THEN it should abort
assert result.exit_code != SUCCESS
def test_delete_case_with_dry_run(
cli_runner: CliRunner, base_context: CGConfig, helpers: StoreHelpers, caplog
):
"""Test that the delete case will not delete the case in dry-run mode"""
# GIVEN a database with a case
base_store: Store = base_context.status_db
case_obj = helpers.add_case(base_store)
case_id = case_obj.internal_id
sample = helpers.add_sample(base_store)
helpers.add_relationship(store=base_store, case=case_obj, sample=sample)
assert base_store.Family.query.count() == 1
assert base_store.FamilySample.query.count() == 1
assert base_store.Sample.query.count() == 1
# WHEN deleting a case
caplog.set_level(logging.DEBUG)
result = cli_runner.invoke(
delete_case_command, [case_id, "--yes", "--dry-run"], obj=base_context
)
# THEN it should not have been deleted
assert result.exit_code == SUCCESS
assert base_store.Family.query.count() == 1
assert base_store.FamilySample.query.count() == 1
assert base_store.Sample.query.count() == 1
assert "Link:" in caplog.text
assert "Sample is linked" in caplog.text
assert "Case:" in caplog.text
assert " was NOT deleted due to --dry-run" in caplog.text
def test_lists_sample_in_unreceived_samples(
cli_runner: CliRunner, base_context: CGConfig, helpers: StoreHelpers
):
"""Test to that cases displays case in database"""
# GIVEN a database with a case
base_store: Store = base_context.status_db
case = helpers.add_case(base_store)
sample1 = helpers.add_sample(base_store, "sample1")
helpers.add_relationship(base_store, case=case, sample=sample1)
# WHEN listing cases
result = cli_runner.invoke(cases, ["-o", "count"], obj=base_context)
# THEN the case should be listed
assert result.exit_code == 0
assert case.internal_id in result.output
assert "0/1" in result.output
def test_families_by_subject_id(
data_analysis: Pipeline,
helpers: StoreHelpers,
sample_store: Store,
):
"""Test that we get a case back for a subject id"""
# GIVEN connected case exist
subject_id = "a_subject_id"
store: Store = sample_store
rna_sample: models.Sample = helpers.add_sample(store=store,
subject_id=subject_id)
rna_case: models.Family = helpers.add_case(store=store,
data_analysis=Pipeline.MIP_RNA,
name="rna_case")
helpers.add_relationship(store=store, case=rna_case, sample=rna_sample)
store.add_commit(rna_case)
dna_sample: models.Sample = helpers.add_sample(store=store,
subject_id=subject_id)
dna_case: models.Family = helpers.add_case(store=store,
data_analysis=data_analysis,
name="dna_case")
helpers.add_relationship(store=store, case=dna_case, sample=dna_sample)
store.add_commit(dna_case)
customer: models.Customer = dna_case.customer
# WHEN calling method families_by_subject_id
all_cases: set[models.Family] = sample_store.families_by_subject_id(
customer_id=customer.internal_id, subject_id=subject_id)
dna_cases: set[models.Family] = sample_store.families_by_subject_id(
customer_id=customer.internal_id,
subject_id=subject_id,
data_analyses=[data_analysis])
# THEN we got the case as result and another data_analysis not in result
assert dna_case in all_cases
assert rna_case in all_cases
assert dna_case in dna_cases
assert rna_case not in dna_cases
def test_get_sample_families_with_family(cli_runner: CliRunner,
base_context: CGConfig,
disk_store: Store,
helpers: StoreHelpers):
"""Test that the --families flag does show case info"""
# GIVEN a database with a sample with related samples
case = helpers.add_case(disk_store)
sample = helpers.add_sample(disk_store)
sample_id = sample.internal_id
helpers.add_relationship(disk_store, sample=sample, case=case)
assert disk_store.Sample.query.first().links
# WHEN getting a sample with the --families flag
result = cli_runner.invoke(get, ["sample", sample_id, "--families"],
obj=base_context)
# THEN all related families should be listed in the output
assert result.exit_code == 0
for link in disk_store.Sample.query.first().links:
assert link.family.internal_id in result.output
def fixture_analysis_store(base_store: Store, workflow_case_id: str,
helpers: StoreHelpers) -> Store:
"""Store to be used in tests"""
_store = base_store
case = helpers.add_case(_store,
workflow_case_id,
data_analysis=Pipeline.MIP_DNA)
dna_sample = helpers.add_sample(_store,
"dna_sample",
is_rna=False,
sequenced_at=datetime.now(),
reads=10000000)
helpers.add_relationship(_store, sample=dna_sample, case=case)
case = helpers.add_case(_store, "rna_case", data_analysis=Pipeline.MIP_RNA)
rna_sample = helpers.add_sample(_store,
"rna_sample",
is_rna=True,
sequenced_at=datetime.now(),
reads=10000000)
helpers.add_relationship(_store, sample=rna_sample, case=case)
case = helpers.add_case(_store,
"dna_rna_mix_case",
data_analysis=Pipeline.MIP_DNA)
helpers.add_relationship(_store, sample=rna_sample, case=case)
helpers.add_relationship(_store, sample=dna_sample, case=case)
return _store
def test_get_family_required(cli_runner: CliRunner, base_context: CGConfig,
disk_store: Store, helpers: StoreHelpers):
"""Test to get a case using only the required argument"""
# GIVEN a database with a analysis
family: models.Family = helpers.add_case(disk_store)
internal_id = family.internal_id
assert disk_store.Family.query.count() == 1
# WHEN getting a analysis
result = cli_runner.invoke(get, ["family", internal_id], obj=base_context)
# THEN it should have been gotten
assert result.exit_code == RETURN_SUCCESS
assert internal_id in result.output
def test_delete_case_without_links(
cli_runner: CliRunner, base_context: CGConfig, helpers: StoreHelpers
):
"""Test that the delete case can delete a case without links"""
# GIVEN a database with a case
base_store: Store = base_context.status_db
case_obj = helpers.add_case(base_store)
case_id = case_obj.internal_id
assert not case_obj.links
# WHEN deleting a case
result = cli_runner.invoke(delete_case_command, [case_id, "--yes"], obj=base_context)
# THEN it should have been deleted
assert result.exit_code == SUCCESS
assert base_store.Family.query.count() == 0
def test_upload_started_long_time_ago_raises_exception(
cli_runner: CliRunner,
base_context: CGConfig,
helpers: StoreHelpers,
):
"""Test that an upload for a missing case does fail hard"""
# GIVEN an analysis that is already uploading since a week ago
disk_store: Store = base_context.status_db
case = helpers.add_case(disk_store)
case_id = case.internal_id
today = datetime.now()
upload_started = today - timedelta(hours=100)
helpers.add_analysis(disk_store,
case=case,
uploading=True,
upload_started=upload_started)
# WHEN trying to upload an analysis that was started a long time ago
result = cli_runner.invoke(upload, ["-f", case_id], obj=base_context)
# THEN an exception should have be thrown
assert result.exit_code != 0
assert result.exception
def test_upload_force_restart(cli_runner: CliRunner, base_context: CGConfig,
helpers: StoreHelpers):
"""Test that a case that is already uploading can be force restarted"""
# GIVEN an analysis that is already uploading
disk_store: Store = base_context.status_db
case: models.Family = helpers.add_case(disk_store)
case_id: str = case.internal_id
helpers.add_analysis(disk_store, case=case, uploading=True)
# WHEN trying to upload it again with the force restart flag
result = cli_runner.invoke(upload, ["-f", case_id, "-r"], obj=base_context)
# THEN it tries to restart the upload
assert "already started" not in result.output
def test_compress_fastq_cli_case_id(populated_compress_context: CGConfig,
cli_runner: CliRunner,
helpers: StoreHelpers, caplog):
"""Test to run the compress command with a specified case id"""
caplog.set_level(logging.DEBUG)
status_db: Store = populated_compress_context.status_db
# GIVEN a context with a case that can be compressed
case_id = "chonkywombat"
valid_compressable_case = helpers.add_case(
store=status_db,
name=case_id,
internal_id=case_id,
data_analysis=Pipeline.MIP_DNA,
action=None,
)
valid_compressable_case.created_at = dt.datetime.now() - dt.timedelta(
days=1000)
sample1 = helpers.add_sample(store=status_db, internal_id="ACCR9000")
sample2 = helpers.add_sample(store=status_db, internal_id="ACCR9001")
helpers.add_relationship(
store=status_db,
sample=sample1,
case=valid_compressable_case,
)
helpers.add_relationship(
store=status_db,
sample=sample2,
case=valid_compressable_case,
)
status_db.commit()
# WHEN running the compress command
res = cli_runner.invoke(fastq_cmd, ["--case-id", case_id],
obj=populated_compress_context)
# THEN assert the program exits since no cases where found
assert res.exit_code == 0
# THEN assert it was communicated that no families where found
assert f"Individuals in 1 (completed) cases where compressed" in caplog.text
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 fluffy_context(
cg_context: CGConfig,
helpers: StoreHelpers,
real_housekeeper_api: HousekeeperAPI,
fluffy_samplesheet_bundle_data,
fluffy_fastq_hk_bundle_data,
fluffy_case_id_existing,
fluffy_sample_lims_id,
) -> CGConfig:
cg_context.housekeeper_api_ = real_housekeeper_api
fluffy_analysis_api = FluffyAnalysisAPI(config=cg_context)
helpers.ensure_hk_version(fluffy_analysis_api.housekeeper_api,
bundle_data=fluffy_samplesheet_bundle_data)
helpers.ensure_hk_version(fluffy_analysis_api.housekeeper_api,
fluffy_fastq_hk_bundle_data)
example_fluffy_case = helpers.add_case(
fluffy_analysis_api.status_db,
internal_id=fluffy_case_id_existing,
name=fluffy_case_id_existing,
data_analysis=Pipeline.FLUFFY,
)
example_fluffy_sample = helpers.add_sample(
fluffy_analysis_api.status_db,
internal_id=fluffy_sample_lims_id,
is_tumour=False,
application_type="tgs",
reads=100,
sequenced_at=dt.datetime.now(),
)
helpers.add_flowcell(fluffy_analysis_api.status_db,
flowcell_id="flowcell",
samples=[example_fluffy_sample])
helpers.add_relationship(fluffy_analysis_api.status_db,
case=example_fluffy_case,
sample=example_fluffy_sample)
cg_context.meta_apis["analysis_api"] = fluffy_analysis_api
return cg_context
def clean_context(
cg_context: CGConfig,
helpers: StoreHelpers,
project_dir: Path,
timestamp_yesterday: datetime.datetime,
timestamp_today: datetime.datetime,
) -> CGConfig:
analysis_api = BalsamicAnalysisAPI(cg_context)
store = analysis_api.status_db
# Create textbook case for cleaning
case_to_clean = helpers.add_case(
store=store,
internal_id="balsamic_case_clean",
name="balsamic_case_clean",
data_analysis=Pipeline.BALSAMIC,
)
sample_case_to_clean = helpers.add_sample(
store,
internal_id="balsamic_sample_clean",
is_tumour=True,
application_type="wgs",
)
helpers.add_relationship(store,
case=case_to_clean,
sample=sample_case_to_clean)
helpers.add_analysis(
store,
case=case_to_clean,
pipeline=Pipeline.BALSAMIC,
started_at=timestamp_yesterday,
uploaded_at=timestamp_yesterday,
cleaned_at=None,
)
Path(analysis_api.get_case_path("balsamic_case_clean")).mkdir(
exist_ok=True, parents=True)
# Create textbook case not for cleaning
case_to_not_clean = helpers.add_case(
store=store,
internal_id="balsamic_case_not_clean",
name="balsamic_case_not_clean",
data_analysis=Pipeline.BALSAMIC,
)
case_to_not_clean.action = "running"
store.commit()
sample_case_to_not_clean = helpers.add_sample(
store,
internal_id="balsamic_sample_not_clean",
is_tumour=True,
application_type="wgs",
)
helpers.add_relationship(store,
case=case_to_not_clean,
sample=sample_case_to_not_clean)
helpers.add_analysis(
store,
case=case_to_not_clean,
pipeline="balsamic",
started_at=timestamp_yesterday,
uploaded_at=timestamp_yesterday,
cleaned_at=None,
)
Path(analysis_api.get_case_path("balsamic_case_not_clean")).mkdir(
exist_ok=True, parents=True)
cg_context.meta_apis["analysis_api"] = analysis_api
cg_context.data_delivery.base_path = f"{project_dir}/rsync"
return cg_context
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
