def add_application( store: Store, application_tag: str = "dummy_tag", application_type: str = "wgs", description: str = None, is_archived: bool = False, is_accredited: bool = False, is_external: bool = False, min_sequencing_depth: int = 30, **kwargs, ) -> models.Application: """Utility function to add a application to a store""" application = store.application(tag=application_tag) if application: return application if not description: description = "dummy_description" application = store.add_application( tag=application_tag, category=application_type, description=description, is_archived=is_archived, percent_kth=80, percent_reads_guaranteed=75, is_accredited=is_accredited, limitations="A limitation", is_external=is_external, min_sequencing_depth=min_sequencing_depth, **kwargs, ) store.add_commit(application) return application
def add_application( store: Store, application_tag: str = "dummy_tag", application_type: str = "wgs", description: str = None, is_accredited: bool = False, is_external: bool = False, **kwargs, ) -> models.Application: """Utility function to add a application to a store""" application = store.application(tag=application_tag) if application: return application if not description: description = "dummy_description" application = store.add_application( tag=application_tag, category=application_type, description=description, percent_kth=80, is_accredited=is_accredited, limitations="A limitation", is_external=is_external, ) store.add_commit(application) return application
def ensure_application_version( store: Store, application_tag: str = "dummy_tag", application_type: str = "wgs", is_external: bool = False, is_rna: bool = False, description: str = None, sequencing_depth: int = None, is_accredited: bool = False, ) -> models.ApplicationVersion: """Utility function to return existing or create application version for tests""" if is_rna: application_tag = "rna_tag" application_type = "wts" application = store.application(tag=application_tag) if not application: application = StoreHelpers.add_application( store, application_tag, application_type, is_external=is_external, description=description, is_accredited=is_accredited, sequencing_depth=sequencing_depth, ) prices = {"standard": 10, "priority": 20, "express": 30, "research": 5} version = store.application_version(application, 1) if not version: version = store.add_version(application, 1, valid_from=datetime.now(), prices=prices) store.add_commit(version) return version
def ensure_customer( store: Store, customer_id: str = "cust000", name: str = "Production", scout_access: bool = False, customer_group: str = "all_customers", ) -> models.Customer: """Utility function to return existing or create customer for tests""" customer_group_id = customer_group or customer_id + "_group" customer_group = store.customer_group(customer_group_id) if not customer_group: customer_group = store.add_customer_group(customer_group_id, customer_group_id) customer = store.customer(customer_id) if not customer: customer = store.add_customer( internal_id=customer_id, name=name, scout_access=scout_access, customer_group=customer_group, invoice_address="Test street", invoice_reference="ABCDEF", ) store.add_commit(customer) return customer
def test_contact_storing(store: Store, contact_type, helpers): # GIVEN an empty database assert store.Customer.query.first() is None internal_id, name, scout_access = "cust000", "Test customer", True customer_group = store.add_customer_group("dummy_group", "dummy group") contact_email = contact_type + "*****@*****.**" contact_name = contact_type # WHEN adding a new customer and setting the new field new_customer = store.add_customer( internal_id=internal_id, name=name, scout_access=scout_access, customer_group=customer_group, invoice_address="dummy street 1", invoice_reference="dummy nr", ) new_user = store.add_user(new_customer, contact_email, contact_name) contact_field = contact_type + "_contact" setattr(new_customer, contact_field, new_user) store.add_commit(new_customer) # THEN contact should be stored on the customer assert getattr(store.customer(internal_id=internal_id), contact_field) == new_user
def add_family( self, store: Store, family_id: str = "family_test", customer_id: str = "cust000", panels: List = None, family_obj: models.Family = None, ) -> models.Family: """Utility function to add a family to use in tests, If no family object is used a autogenerated family id will be used """ customer = self.ensure_customer(store, customer_id) if family_obj: panels = family_obj.panels if not panels: panels = ["panel_test"] for panel_name in panels: self.ensure_panel(store, panel_id=panel_name, customer_id=customer_id) if not family_obj: family_obj = store.add_family(name=family_id, panels=panels) print("Adding family with name %s (%s)" % (family_obj.name, family_obj.internal_id)) family_obj.customer = customer store.add_commit(family_obj) return family_obj
def test_add_microbial_sample(base_store: Store): # GIVEN an empty database assert base_store.MicrobialSample.query.first() is None name = "microbial_sample" organism_name = "e. coli" internal_id = "lims-id" reference_genome = "ref_gen" priority = "research" application_version = base_store.ApplicationVersion.query.first() base_store.add_organism(organism_name, organism_name, reference_genome) organism = base_store.Organism.query.first() microbial_order_id = "dummy_order_id" # WHEN adding a new microbial sample new_microbial_sample = base_store.add_microbial_sample( microbial_order_id=microbial_order_id, name=name, organism=organism, internal_id=internal_id, reference_genome=reference_genome, application_version=application_version, priority=priority, ) base_store.add_commit(new_microbial_sample) # THEN it should be stored in the database assert base_store.MicrobialSample.query.first() == new_microbial_sample stored_microbial_sample = base_store.MicrobialSample.query.first() assert stored_microbial_sample.name == name assert stored_microbial_sample.internal_id == internal_id assert stored_microbial_sample.reference_genome == reference_genome assert stored_microbial_sample.application_version == application_version assert stored_microbial_sample.priority_human == priority assert stored_microbial_sample.organism == organism
def add_sample( self, store: Store, sample_id: str = "sample_test", gender: str = "female", is_tumour: bool = False, is_rna: bool = False, is_external: bool = False, data_analysis: str = "balsamic", application_tag: str = "dummy_tag", application_type: str = "tgs", customer_name: str = None, reads: int = None, **kwargs, ) -> models.Sample: """Utility function to add a sample to use in tests""" customer_name = customer_name or "cust000" customer = self.ensure_customer(store, customer_name) application_version = self.ensure_application_version( store, application_tag=application_tag, application_type=application_type, is_external=is_external, is_rna=is_rna, ) print(repr(application_version)) application_version_id = application_version.id sample = store.add_sample( name=sample_id, sex=gender, tumour=is_tumour, sequenced_at=datetime.now(), data_analysis=data_analysis, reads=reads, ) sample.application_version_id = application_version_id sample.customer = customer print("Set is external to %s", is_external) sample.is_external = is_external if kwargs.get("delivered_at"): print("Adding delivered") sample.delivered_at = kwargs["delivered_at"] if kwargs.get("received_at"): print("Adding received_at") sample.received_at = kwargs["received_at"] if kwargs.get("prepared_at"): print("Adding prepared") sample.received_at = kwargs["prepared_at"] if kwargs.get("flowcell"): print("Adding flowcell") sample.flowcells.append(kwargs["flowcell"]) store.add_commit(sample) return sample
def test_add_customer_group(store: Store): # GIVEN an empty database assert store.CustomerGroup.query.first() is None internal_id, name = "cust_group", "Test customer group" # WHEN adding a new customer group new_customer_group = store.add_customer_group(internal_id=internal_id, name=name) store.add_commit(new_customer_group) # THEN it should be stored in the database assert store.CustomerGroup.query.first() == new_customer_group
def ensure_bed_version(store: Store, bed_name: str = "dummy_bed") -> models.ApplicationVersion: """Utility function to return existing or create bed version for tests""" bed = store.bed(name=bed_name) if not bed: bed = store.add_bed(name=bed_name) store.add_commit(bed) version = store.latest_bed_version(bed_name) if not version: version = store.add_bed_version(bed, 1, "dummy_filename", shortname=bed_name) store.add_commit(version) return version
def store_samples_with_names_from_order(store: Store, helpers: StoreHelpers, order_data: OrderIn): customer_obj = store.customer(order_data.customer) for sample in order_data.samples: sample_name = sample.name if not store.find_samples(customer=customer_obj, name=sample_name).first(): sample_obj = helpers.add_sample( store=store, name=sample_name, customer_id=customer_obj.internal_id) store.add_commit(sample_obj)
def ensure_organism( store: Store, organism_id: str = "organism_test", name: str = "organism_name", reference_genome: str = "reference_genome_test", ) -> models.Organism: """Utility function to add an organism to use in tests""" organism = StoreHelpers.add_organism( store, internal_id=organism_id, name=name, reference_genome=reference_genome ) store.add_commit(organism) return organism
def add_sample( store: Store, application_tag: str = "dummy_tag", application_type: str = "tgs", control: str = "", customer_id: str = None, gender: str = "female", is_external: bool = False, is_rna: bool = False, is_tumour: bool = False, reads: int = None, name: str = "sample_test", ticket: int = None, **kwargs, ) -> models.Sample: """Utility function to add a sample to use in tests""" customer_id = customer_id or "cust000" customer = StoreHelpers.ensure_customer(store, customer_id=customer_id) application_version = StoreHelpers.ensure_application_version( store=store, application_tag=application_tag, application_type=application_type, is_external=is_external, is_rna=is_rna, ) application_version_id = application_version.id sample = store.add_sample( control=control, name=name, reads=reads, sex=gender, ticket=ticket, tumour=is_tumour, ) sample.application_version_id = application_version_id sample.customer = customer sample.ordered_at = datetime.now() for key, value in kwargs.items(): if key == "flowcell": sample.flowcells.append(kwargs["flowcell"]) elif hasattr(sample, key): setattr(sample, key, value) else: raise AttributeError(f"Unknown sample attribute/feature: {key}, {value}") store.add_commit(sample) return sample
def add_microbial_sample_and_order( self, store: Store, order_id: str = "microbial_order_test", sample_id: str = "microbial_sample_test", customer_id: str = "cust_test", ) -> models.MicrobialSample: """Utility add a order and a sample to use in tests""" self.ensure_application_version(store) self.ensure_customer(store, customer_id) organism = self.ensure_organism(store) order = self.ensure_microbial_order(store) sample = self.add_microbial_sample(store, organism=organism) sample.microbial_order_id = order.id store.add_commit(sample) return sample
def add_relationship( store: Store, sample: models.Sample, family: models.Family, status: str = "unknown", father: models.Sample = None, mother: models.Sample = None, ) -> models.FamilySample: """Utility function to link a sample to a family""" link = store.relate_sample(sample=sample, family=family, status=status, father=father, mother=mother) store.add_commit(link) return link
def ensure_panel( store: Store, panel_id: str = "panel_test", customer_id: str = "cust000" ) -> models.Panel: """Utility function to add a panel to use in tests""" customer = StoreHelpers.ensure_customer(store, customer_id) panel = store.panel(panel_id) if not panel: panel = store.add_panel( customer=customer, name=panel_id, abbrev=panel_id, version=1.0, date=datetime.now(), genes=1, ) store.add_commit(panel) return panel
def test_add_customer(store: Store): # GIVEN an empty database assert store.Customer.query.first() is None internal_id, name, scout_access = "cust000", "Test customer", True customer_group = store.add_customer_group("dummy_group", "dummy group") # WHEN adding a new customer new_customer = store.add_customer( internal_id=internal_id, name=name, scout_access=scout_access, customer_group=customer_group, invoice_address="dummy street 1", invoice_reference="dummy nr", ) store.add_commit(new_customer) # THEN it should be stored in the database assert store.Customer.query.first() == new_customer
def ensure_microbial_order( self, store: Store, order_id: str = "microbial_order_test", name: str = "microbial_name_test", customer_id: str = "cust_test", ) -> models.MicrobialOrder: """Utility function add a microbial order and sample""" customer = self.ensure_customer(store, customer_id) order = store.add_microbial_order( customer=customer, internal_id=order_id, name=name, ordered=datetime.now(), ticket_number=123456, ) store.add_commit(order) return order
def add_flowcell( store: Store, flowcell_id: str = "flowcell_test", archived_at: datetime = None, samples: list = None, ) -> models.Flowcell: """Utility function to set a flowcell to use in tests""" flowcell_obj = store.add_flowcell( name=flowcell_id, sequencer="dummy_sequencer", sequencer_type="hiseqx", date=datetime.now(), ) flowcell_obj.archived_at = archived_at if samples: flowcell_obj.samples = samples store.add_commit(flowcell_obj) return flowcell_obj
def test_add_user(store: Store): # GIVEN a database with a customer in it that we can connect the user to customer_group = store.add_customer_group("dummy_group", "dummy group") customer = store.add_customer( internal_id="custtest", name="Test Customer", scout_access=False, customer_group=customer_group, invoice_address="dummy street 1", invoice_reference="dummy nr", ) store.add_commit(customer) # WHEN adding a new user name, email = "Paul T. Anderson", "*****@*****.**" new_user = store.add_user(customer=customer, email=email, name=name) store.add_commit(new_user) # THEN it should be stored in the database assert store.User.query.first() == new_user
def test_microbial_sample_to_dict(microbial_store: Store, helpers): # GIVEN a store with a Microbial sample sample_obj = helpers.add_microbial_sample(microbial_store) microbial_store.add_commit(sample_obj) assert sample_obj # WHEN running to dict on that sample a_dict = sample_obj.to_dict(links=True) # THEN you should get a dictionary with assert a_dict["id"] assert a_dict["internal_id"] assert a_dict["name"] assert a_dict["application_version_id"] assert a_dict["created_at"] assert a_dict["priority"] assert a_dict["reads"] assert a_dict["comment"] assert a_dict["application"] assert a_dict["application_version"]
def test_add_pool(store: Store): # GIVEN a valid customer and a valid application_version customer_group = store.add_customer_group("dummy_group", "dummy group") new_customer = store.add_customer( internal_id="cust000", name="Test customer", scout_access=True, customer_group=customer_group, invoice_address="skolgatan 15", invoice_reference="abc", ) store.add_commit(new_customer) application = store.add_application( tag="RMLS05R150", category="rml", description="Ready-made", percent_kth=80, sequencing_depth=0, ) store.add_commit(application) app_version = store.add_version( application=application, version=1, valid_from=dt.today(), prices={ "standard": 12, "priority": 222, "express": 123, "research": 12 }, ) store.add_commit(app_version) # WHEN adding a new pool into the database new_pool = store.add_pool( customer=new_customer, name="Test", order="Test", ordered=dt.today(), application_version=app_version, data_analysis="fastq", ) store.add_commit(new_pool) # THEN the new pool should have no_invoice = False pool = store.pools(customer=None).first() assert pool.no_invoice is False
def test_get_family_by_name(invoke_cli, disk_store: Store): # GIVEN A database with a customer in it customer_id = "customer-test" customer_group = disk_store.add_customer_group("dummy_group", "dummy group") customer = disk_store.add_customer( internal_id=customer_id, name="Test Customer", scout_access=False, customer_group=customer_group, invoice_address="Street nr, 12345 Uppsala", invoice_reference="ABCDEF", ) disk_store.add_commit(customer) # WHEN trying to get a non-existing family by name db_uri = disk_store.uri result = invoke_cli( ["--database", db_uri, "get", "family", "-c", customer_id, "-n", "dummy-family-name",] ) # THEN it should not crash assert result.exit_code == 0
def add_analysis( self, store: Store, family: models.Family = None, started_at: datetime = None, completed_at: datetime = None, uploaded_at: datetime = None, upload_started: datetime = None, delivery_reported_at: datetime = None, pipeline: str = "dummy_pipeline", pipeline_version: str = "1.0", uploading: bool = False, config_path: str = None, ) -> models.Analysis: """Utility function to add an analysis for tests""" if not family: family = self.add_family(store) analysis = store.add_analysis(pipeline=pipeline, version=pipeline_version) if started_at: analysis.started_at = started_at if completed_at: analysis.completed_at = completed_at if uploaded_at: analysis.uploaded_at = uploaded_at if delivery_reported_at: analysis.delivery_report_created_at = delivery_reported_at if uploading: analysis.upload_started_at = upload_started or datetime.now() if config_path: analysis.config_path = config_path analysis.limitations = "A limitation" analysis.family = family store.add_commit(analysis) return analysis
def test_add_microbial_sample(base_store: Store, helpers): # GIVEN an empty database assert base_store.Sample.query.first() is None customer_obj = helpers.ensure_customer(base_store) assert customer_obj name = "microbial_sample" organism_name = "e. coli" internal_id = "lims-id" reference_genome = "ref_gen" priority = "research" ticket_number = 123456 application_version = base_store.ApplicationVersion.query.first() base_store.add_organism(organism_name, organism_name, reference_genome) organism = base_store.Organism.query.first() # WHEN adding a new microbial sample new_sample = base_store.add_sample( application_version=application_version, internal_id=internal_id, name=name, organism=organism, priority=priority, reference_genome=reference_genome, sex="unknown", ticket=ticket_number, ) new_sample.customer = customer_obj base_store.add_commit(new_sample) # THEN it should be stored in the database assert base_store.Sample.query.first() == new_sample stored_microbial_sample = base_store.Sample.query.first() assert stored_microbial_sample.name == name assert stored_microbial_sample.internal_id == internal_id assert stored_microbial_sample.reference_genome == reference_genome assert stored_microbial_sample.application_version == application_version assert stored_microbial_sample.priority_human == priority assert stored_microbial_sample.organism == organism
def add_case( store: Store, name: str = "case_test", data_analysis: Pipeline = Pipeline.MIP_DNA, data_delivery: DataDelivery = DataDelivery.SCOUT, action: str = None, internal_id: str = None, customer_id: str = "cust000", panels: List = ["panel_test"], case_obj: models.Family = None, ) -> models.Family: """Utility function to add a case to use in tests, If no case object is used a autogenerated case id will be used """ customer = StoreHelpers.ensure_customer(store, customer_id) if case_obj: panels = case_obj.panels for panel_name in panels: StoreHelpers.ensure_panel(store=store, panel_id=panel_name, customer_id=customer_id) if not case_obj: case_obj: Optional[models.Family] = store.family(internal_id=name) if not case_obj: case_obj = store.add_case( data_analysis=data_analysis, data_delivery=data_delivery, name=name, panels=panels, ) if action: case_obj.action = action if internal_id: case_obj.internal_id = internal_id case_obj.customer = customer store.add_commit(case_obj) return case_obj
def test_add_user(invoke_cli, disk_store: Store): # GIVEN a database with a customer in it that we can connect the user to customer_id = "custtest" customer_group = disk_store.add_customer_group("dummy_group", "dummy group") customer = disk_store.add_customer( internal_id=customer_id, name="Test Customer", scout_access=False, customer_group=customer_group, invoice_address="Street nr, 12345 Uppsala", invoice_reference="ABCDEF", ) disk_store.add_commit(customer) # WHEN adding a new user name, email = "Paul T. Anderson", "*****@*****.**" db_uri = disk_store.uri result = invoke_cli( ["--database", db_uri, "add", "user", "-c", customer_id, email, name]) # THEN it should be stored in the database assert result.exit_code == 0 assert disk_store.User.query.count() == 1
def ensure_applications(base_store: Store, active_applications: list, inactive_applications: list): """Create some requested applications for the tests """ for active_application in active_applications: if not base_store.application(active_application): base_store.add_commit( base_store.add_application( active_application, "mic", "dummy_description", is_archived=False, percent_kth=80, )) for inactive_application in inactive_applications: if not base_store.application(inactive_application): base_store.add_commit( base_store.add_application( inactive_application, category="mic", description="dummy_description", is_archived=True, percent_kth=80, ))
def test_submit_scout_legal_sample_customer( all_orders_to_submit: dict, monkeypatch, order_type: OrderType, orders_api: OrdersAPI, sample_store: Store, ticket_number: int, user_mail: str, user_name: str, ): order_data = OrderIn.parse_obj(obj=all_orders_to_submit[order_type], project=order_type) monkeypatch_process_lims(monkeypatch, order_data) # GIVEN we have an order with a customer that is in the same customer group as customer # that the samples originate from customer_group = sample_store.add_customer_group( "customer999only", "customer 999 only group") sample_store.add_commit(customer_group) sample_customer = sample_store.add_customer( "customer1", "customer 1", scout_access=True, invoice_address="dummy street 1", customer_group=customer_group, invoice_reference="dummy nr", ) order_customer = sample_store.add_customer( "customer2", "customer 2", scout_access=True, invoice_address="dummy street 2", customer_group=customer_group, invoice_reference="dummy nr", ) sample_store.add_commit(sample_customer) sample_store.add_commit(order_customer) existing_sample = sample_store.samples().first() existing_sample.customer = sample_customer sample_store.commit() order_data.customer = order_customer.internal_id for sample in order_data.samples: sample.internal_id = existing_sample.internal_id break # WHEN calling submit # THEN an OrderError should not be raised on illegal customer orders_api.submit(project=order_type, order_in=order_data, user_name=user_name, user_mail=user_mail)
def fixture_base_store(store: Store, apptag_rna: str) -> Store: """Setup and example store.""" customer_group = store.add_customer_group("all_customers", "all customers") store.add_commit(customer_group) customers = [ store.add_customer( "cust000", "Production", scout_access=True, customer_group=customer_group, invoice_address="Test street", invoice_reference="ABCDEF", ), store.add_customer( "cust001", "Customer", scout_access=False, customer_group=customer_group, invoice_address="Test street", invoice_reference="ABCDEF", ), store.add_customer( "cust002", "Karolinska", scout_access=True, customer_group=customer_group, invoice_address="Test street", invoice_reference="ABCDEF", ), store.add_customer( "cust003", "CMMS", scout_access=True, customer_group=customer_group, invoice_address="Test street", invoice_reference="ABCDEF", ), ] store.add_commit(customers) applications = [ store.add_application( tag="WGXCUSC000", category="wgs", description="External WGS", sequencing_depth=0, is_external=True, percent_kth=80, percent_reads_guaranteed=75, target_reads=10, ), store.add_application( tag="EXXCUSR000", category="wes", description="External WES", sequencing_depth=0, is_external=True, percent_kth=80, percent_reads_guaranteed=75, target_reads=10, ), store.add_application( tag="WGSPCFC060", category="wgs", description="WGS, double", sequencing_depth=30, accredited=True, percent_kth=80, percent_reads_guaranteed=75, target_reads=10, ), store.add_application( tag="RMLP05R800", category="rml", description="Ready-made", sequencing_depth=0, percent_kth=80, percent_reads_guaranteed=75, target_reads=10, ), store.add_application( tag="WGSPCFC030", category="wgs", description="WGS trio", is_accredited=True, sequencing_depth=30, target_reads=30, limitations="some", percent_kth=80, percent_reads_guaranteed=75, ), store.add_application( tag="METLIFR020", category="wgs", description="Whole genome metagenomics", sequencing_depth=0, target_reads=400000, percent_kth=80, percent_reads_guaranteed=75, ), store.add_application( tag="METNXTR020", category="wgs", description="Metagenomics", sequencing_depth=0, target_reads=200000, percent_kth=80, percent_reads_guaranteed=75, ), store.add_application( tag="MWRNXTR003", category="mic", description="Microbial whole genome ", sequencing_depth=0, percent_kth=80, percent_reads_guaranteed=75, target_reads=10, ), store.add_application( tag=apptag_rna, category="tgs", description="RNA seq, poly-A based priming", percent_kth=80, percent_reads_guaranteed=75, sequencing_depth=25, accredited=True, target_reads=10, ), store.add_application( tag="VWGDPTR001", category="cov", description="Viral whole genome ", sequencing_depth=0, percent_kth=80, percent_reads_guaranteed=75, target_reads=10, ), ] store.add_commit(applications) prices = {"standard": 10, "priority": 20, "express": 30, "research": 5} versions = [ store.add_version(application, 1, valid_from=dt.datetime.now(), prices=prices) for application in applications ] store.add_commit(versions) beds = [store.add_bed("Bed")] store.add_commit(beds) bed_versions = [store.add_bed_version(bed, 1, "Bed.bed") for bed in beds] store.add_commit(bed_versions) organism = store.add_organism("C. jejuni", "C. jejuni") store.add_commit(organism) yield store