def test_evidence_init(self): entity = Reaction() target = Gene("id2") eco = "ECO:000000" assertion = "Presence" comment = "test comment" reference = Reference() evidence = Evidence(entity=entity, eco=eco, assertion=assertion, comment=comment, target=target) evidence.add_reference(reference) # Check proper linking assert evidence.entity is entity assert evidence in entity.evidences assert evidence.target is target assert evidence in target.evidences # Check attributes assert evidence.assertion == assertion assert evidence.eco == eco assert evidence.comment == comment # Check id is set assert type(evidence.internal_id) is str assert evidence.internal_id != "" # Check the references assert reference in evidence.references assert evidence in reference.linked_items
def test_copy_evidence(self): entity = Reaction() target = Gene() eco = "ECO:000000" assertion = "Presence" comment = "test comment" reference = Reference() evidence = Evidence(entity=entity, eco=eco, assertion=assertion, comment=comment, target=target) evidence.add_reference(reference) # Create copy copy = evidence.copy() # Check the correctness of the copy assert evidence.entity is copy.entity assert evidence.target is copy.target assert evidence.eco == copy.eco assert evidence.assertion == copy.assertion assert evidence.comment == copy.comment assert evidence.references == copy.references assert evidence.references is not copy.references # Check that the copy is not linked assert copy not in entity.evidences assert copy not in reference.linked_items assert copy not in target.evidences
def save_state(self): genes_added = 0 for gene_id in self.plainTextEdit.toPlainText().split("\n"): try: gene = self.model.genes.get_by_id(gene_id.strip()) except KeyError: if self.comboBox_missing.currentText() == "Add": gene = Gene(gene_id.strip()) self.model.add_gene(gene) self.model.QtGeneTable.update_row_from_item(gene) genes_added += 1 else: continue # Generate an evidence item for each gene evidence = Evidence(entity=gene, eco=self.evidence.eco, assertion=self.evidence.assertion, comment=self.evidence.comment, target=self.evidence.target) # Add reference for reference in self.evidence.references: evidence.add_reference(reference) # Add evidence to model self.model.all_evidences[evidence.internal_id] = evidence if genes_added: QMessageBox(self).information( self, "Genes added", "{} new genes added!".format(str(genes_added)))
def complete_evidence(self): evidence = Evidence(entity=self.entity, assertion=self.assertion, target=self.target, eco=self.eco, comment=self.comment) evidence.add_reference(self.reference) return evidence
def test_saving_changes(self): reaction = Reaction() reference = Reference() model = Model() evidence = Evidence(entity=reaction) evidence.add_reference(reference) widget = EvidenceDisplayWidget() model.all_evidences[evidence.internal_id] = evidence assert evidence in reaction.evidences assert evidence.internal_id in model.all_evidences assert reference in evidence.references # Set reaction and model to widget widget.set_item(reaction, model) assert widget.dataTable.rowCount() == 1 # Remove evidence copy from data table widget.dataTable.setRowCount(0) # Setup new evidence item new_evidence = Evidence() new_evidence.assertion = "Catalyzed by" new_evidence.entity = reaction reference = Reference() new_evidence.add_reference(reference, reciprocal=False) # Test the setup i.e. that items are only linked in a one way (evidence -> item) fashion assert new_evidence not in reaction.evidences assert new_evidence not in reference.linked_items # Add new reference to widget table widget.dataTable.update_row_from_item(new_evidence) assert widget.dataTable.rowCount() == 1 assert widget.dataTable.item(0).link is new_evidence # Action - Save evidences widget.save_state() # Check that old instance is detached from all links assert evidence not in reaction.evidences assert len(evidence.references) == 0 # Old evidence still kept alive by this test old_id = evidence.internal_id assert old_id in model.all_evidences evidence = None gc.collect() assert old_id not in model.all_evidences # Check that new evidence is linked properly assert new_evidence in reaction.evidences assert new_evidence.internal_id in model.all_evidences
def parse_evidences_from_xml(model_node, model, progress=None): list_of_evidences_node = model_node.find(ge_listOfEvidences) if list_of_evidences_node is None: return elif progress is None: pass elif not progress.wasCanceled(): progress.setLabelText("Reading evidences...") progress.setRange(0, len(list_of_evidences_node)) else: return for i, evidence_node in enumerate( list_of_evidences_node.iterfind(ge_evidence)): if progress is None: pass elif not progress.wasCanceled(): progress.setValue(i) QApplication.processEvents() else: return new_evidence = Evidence(internal_id=evidence_node.get("id"), assertion=evidence_node.get("assertion"), comment=evidence_node.get("comment"), eco=evidence_node.get("eco")) entity_id = evidence_node.get("entity_id") entity_type = evidence_node.get("entity_type") entity = get_item_from_model(entity_type, entity_id, model) new_evidence.set_entity(entity) # Add target item if present target_id = evidence_node.get("target_id") target_type = evidence_node.get("target_type") if target_id and target_type: target = get_item_from_model(target_type, target_id, model) new_evidence.set_target(target) # Add all references if present reference_list_node = evidence_node.find(ge_listOfReferenceLinks) if reference_list_node is not None: for refLink_node in reference_list_node.iterfind(ge_referenceLink): new_evidence.add_reference( model.references[refLink_node.get("id")]) model.all_evidences[new_evidence.internal_id] = new_evidence
def test_equality(self): entity = Reaction() target = Gene() eco = "ECO:000000" assertion = "Presence" comment = "test comment" reference = Reference() evidence = Evidence(entity=entity, eco=eco, assertion=assertion, comment=comment, target=target) evidence.add_reference(reference) assert evidence.copy() == evidence
def test_override_entity(self): entity = Reaction() eco = "ECO:000000" assertion = "Presence" comment = "test comment" reference = Reference() evidence = Evidence(entity=entity, eco=eco, assertion=assertion, comment=comment) evidence.add_reference(reference) new_reaction = Reaction() evidence.set_entity(new_reaction) # Check disconnection of old reaction assert evidence.entity is new_reaction assert evidence not in entity.evidences
def test_inequality(self, attribute, new_value): entity = Reaction() target = Gene() eco = "ECO:000000" assertion = "Presence" comment = "test comment" reference = Reference() evidence = Evidence(entity=entity, eco=eco, assertion=assertion, comment=comment, target=target) evidence.add_reference(reference) new_copy = evidence.copy() setattr(new_copy, attribute, new_value) assert new_copy != evidence assert not new_copy == evidence
def test_inequality_reference(self): entity = Reaction() target = Gene() eco = "ECO:000000" assertion = "Presence" comment = "test comment" reference = Reference() evidence = Evidence(entity=entity, eco=eco, assertion=assertion, comment=comment, target=target) evidence.add_reference(reference) new_copy = evidence.copy() new_copy.remove_all_references() assert new_copy != evidence assert not new_copy == evidence
def test_delete_links(self): entity = Reaction() target = Gene() eco = "ECO:000000" assertion = "Presence" comment = "test comment" reference = Reference() evidence = Evidence(entity=entity, eco=eco, assertion=assertion, comment=comment, target=target) evidence.add_reference(reference) evidence.delete_links() assert evidence.entity is None assert len(evidence.references) == 0 assert evidence not in entity.evidences assert evidence not in target.evidences
def test_override_target(self): entity = Reaction() target = Gene() eco = "ECO:000000" assertion = "Presence" comment = "test comment" reference = Reference() evidence = Evidence(entity=entity, eco=eco, assertion=assertion, comment=comment, target=target) evidence.add_reference(reference) new_gene = Gene() evidence.set_target(new_gene) # Check disconnection of old reaction assert evidence.target is new_gene assert evidence not in target.evidences
def test_setup_links(self): entity = Reaction() target = Gene() eco = "ECO:000000" assertion = "Presence" comment = "test comment" reference = Reference() evidence = Evidence() evidence.entity = entity evidence.target = target evidence.eco = eco evidence.assertion = assertion evidence.comment = comment evidence.add_reference(reference, reciprocal=False) assert evidence not in entity.evidences assert evidence not in reference.linked_items assert evidence not in target.evidences evidence.setup_links() assert evidence in entity.evidences assert evidence in reference.linked_items assert evidence in target.evidences
class TestModelDeleteItems: @pytest.fixture(autouse=True) def setup_complete_model(self): self.model = Model("model") # Setup reaction1 self.metabolite = Metabolite("m1") self.reaction = Reaction("r1") self.gene = Gene("g1") self.reaction.add_child(self.gene) self.model.add_genes((self.gene,)) self.reaction.add_metabolites({self.metabolite: -1}) self.model.add_reactions((self.reaction,)) # Setup reaction2 self.metabolite2 = Metabolite("m2") self.reaction2 = Reaction("r2") self.gene2 = Gene("g2") self.genegroup = GeneGroup() self.genegroup.add_child(self.gene2) self.reaction2.add_child(self.genegroup) self.model.add_genes((self.gene2,)) self.reaction2.add_metabolites({self.metabolite2: 1}) self.model.add_reactions((self.reaction2,)) # Setup evidences self.evidence = Evidence(assertion="Catalyzes") self.evidence.set_entity(self.gene) self.evidence.set_target(self.reaction) self.reference = Reference() self.model.add_reference(self.reference) self.evidence.add_reference(self.reference) self.model.add_evidence(self.evidence) # Setup test case self.testcase = ModelTest() reaction_setting = ReactionSetting(self.reaction, 1000., -1000., 0.) gene_setting = GeneSetting(gene=self.gene2, activity=False) outcome = Outcome(self.reaction2, 0., "greater") self.testcase.add_outcome(outcome) self.testcase.add_setting(gene_setting) self.testcase.add_setting(reaction_setting) self.model.add_test(self.testcase) self.reference2 = Reference() self.model.add_reference(self.reference2) self.testcase.add_reference(self.reference2) self.model.setup_tables() def test_setup(self): # Test genes gene_in_model(self.gene, self.model) gene_in_model(self.gene2, self.model) # Test reactions reaction_in_model(self.reaction, self.model) reaction_in_model(self.reaction2, self.model) # Test metabolites metabolite_in_model(self.metabolite, self.model) metabolite_in_model(self.metabolite2, self.model) # Test evidences evidence_in_model(self.evidence, self.model) # Test model test case_in_model(self.testcase, self.model) # Test references reference_in_model(self.reference, self.model) reference_in_model(self.reference2, self.model) # Test connections # Reference <-> Evidence reference_in_item(self.reference, self.evidence) # Reference2 <-> Testcase reference_in_item(self.reference2, self.testcase) # Gene1 <-> Reaction1 gene_in_reaction(self.gene, self.reaction) gene_in_reaction(self.gene2, self.reaction2) # Metabolite1 <-> Reaction1 metabolite_in_reaction(self.metabolite, self.reaction) metabolite_in_reaction(self.metabolite2, self.reaction2) # Evidence <-> Gene1/Reaction item_in_evidence(self.gene, self.evidence) item_in_evidence(self.reaction, self.evidence) def test_deletion_metabolite(self): # Action self.model.gem_remove_metabolites((self.metabolite,)) # Test gene gene_in_model(self.gene, self.model) gene_in_model(self.gene2, self.model) # Test reactions reaction_in_model(self.reaction, self.model) reaction_in_model(self.reaction2, self.model) # Test metabolites metabolite_in_model(self.metabolite, self.model, valid=False) metabolite_in_model(self.metabolite2, self.model) # Test evidences evidence_in_model(self.evidence, self.model) # Test model test case_in_model(self.testcase, self.model) # Test references reference_in_model(self.reference, self.model) reference_in_model(self.reference2, self.model) # Test connections # Reference <-> Evidence reference_in_item(self.reference, self.evidence) # Reference2 <-> Testcase reference_in_item(self.reference2, self.testcase) # Gene1 <-> Reaction1 gene_in_reaction(self.gene, self.reaction) gene_in_reaction(self.gene2, self.reaction2) # Metabolite1 <-> Reaction1 metabolite_in_reaction(self.metabolite, self.reaction, valid=False) metabolite_in_reaction(self.metabolite2, self.reaction2) # Evidence <-> Gene1/Reaction item_in_evidence(self.gene, self.evidence) item_in_evidence(self.reaction, self.evidence) def test_deletion_metabolite2(self): # Action self.model.gem_remove_metabolites((self.metabolite2,)) # Test genes gene_in_model(self.gene, self.model) gene_in_model(self.gene2, self.model) # Test reactions reaction_in_model(self.reaction, self.model) reaction_in_model(self.reaction2, self.model) # Test metabolites metabolite_in_model(self.metabolite, self.model) metabolite_in_model(self.metabolite2, self.model, valid=False) # Test evidences evidence_in_model(self.evidence, self.model) # Test model test case_in_model(self.testcase, self.model) # Test references reference_in_model(self.reference, self.model) reference_in_model(self.reference2, self.model) # Test connections # Reference <-> Evidence reference_in_item(self.reference, self.evidence) # Reference2 <-> Testcase reference_in_item(self.reference2, self.testcase) # Gene1 <-> Reaction1 gene_in_reaction(self.gene, self.reaction) gene_in_reaction(self.gene2, self.reaction2) # Metabolite1 <-> Reaction1 metabolite_in_reaction(self.metabolite, self.reaction) metabolite_in_reaction(self.metabolite2, self.reaction2, valid=False) # Evidence <-> Gene1/Reaction item_in_evidence(self.gene, self.evidence) item_in_evidence(self.reaction, self.evidence) def test_delete_reaction1(self): #### # Delete reaction # Check: # - gene present but removed from reaction1 # - metabolite present but removed from reaction1 # - reaction deleted # - evidence deleted # - testcase deleted # - reference present but removed from evidence # - reference2 present but removed from testcase #### # Action self.model.gem_remove_reactions((self.reaction,)) # Test genes gene_in_model(self.gene, self.model) gene_in_model(self.gene2, self.model) # Test reactions reaction_in_model(self.reaction, self.model, valid=False) reaction_in_model(self.reaction2, self.model) # Test metabolites metabolite_in_model(self.metabolite, self.model) metabolite_in_model(self.metabolite2, self.model) # Test model test case_in_model(self.testcase, self.model, valid=False) # Test references reference_in_model(self.reference, self.model) reference_in_model(self.reference2, self.model) # Test connections # Reference <-> Evidence reference_in_item(self.reference, self.evidence, valid=False) reference_in_item(self.reference2, self.testcase, valid=False) # Gene1 <-> Reaction1 gene_in_reaction(self.gene, self.reaction, valid=False) gene_in_reaction(self.gene2, self.reaction2) # Metabolite1 <-> Reaction1 # Check metabolite is still in reaction, but reaction not in metabolite assert self.metabolite in self.reaction.metabolites assert self.reaction not in self.metabolite.reactions metabolite_in_reaction(self.metabolite2, self.reaction2) # Evidence <-> Gene1/Reaction item_in_evidence(self.gene, self.evidence, valid=False) item_in_evidence(self.reaction, self.evidence, valid=False) # Check evidence is removed when reference deleted del self.evidence gc.collect() assert len(self.model.all_evidences) == 0 def test_deletion_reaction2(self): # Check: # - reaction2 removed # - test case removed # - reference removed from testcase # - gene2 removed from reaction # Action self.model.gem_remove_reactions((self.reaction2,)) # Test genes gene_in_model(self.gene, self.model) gene_in_model(self.gene2, self.model) # Test reactions reaction_in_model(self.reaction, self.model) reaction_in_model(self.reaction2, self.model, valid=False) # Test metabolites metabolite_in_model(self.metabolite, self.model) metabolite_in_model(self.metabolite2, self.model) # Test evidences evidence_in_model(self.evidence, self.model) # Test model test case_in_model(self.testcase, self.model, valid=False) # Test references reference_in_model(self.reference, self.model) reference_in_model(self.reference2, self.model) # Test connections # Reference <-> Evidence reference_in_item(self.reference, self.evidence) # Reference2 <-> Testcase reference_in_item(self.reference2, self.testcase, valid=False) # Gene1 <-> Reaction1 gene_in_reaction(self.gene, self.reaction) gene_in_reaction(self.gene2, self.reaction2, valid=False) # Metabolite1 <-> Reaction1 metabolite_in_reaction(self.metabolite, self.reaction) # Check metabolite still in reaction, but reaction not in metabolite assert self.metabolite2 in self.reaction2.metabolites assert self.reaction2 not in self.metabolite2.reactions # Evidence <-> Gene1/Reaction item_in_evidence(self.gene, self.evidence) item_in_evidence(self.reaction, self.evidence) def test_delete_gene1(self): # Test gene deletion # Check: # - Gene removed from model # - Evidence removed from model # Action self.model.gem_remove_genes((self.gene,)) # Test genes gene_in_model(self.gene, self.model, valid=False) gene_in_model(self.gene2, self.model) # Test reactions reaction_in_model(self.reaction, self.model) reaction_in_model(self.reaction2, self.model) # Test metabolites metabolite_in_model(self.metabolite, self.model) metabolite_in_model(self.metabolite2, self.model) # Test model test case_in_model(self.testcase, self.model) # Test references reference_in_model(self.reference, self.model) reference_in_model(self.reference2, self.model) # Test connections # Reference <-> Evidence reference_in_item(self.reference, self.evidence, valid=False) # Reference2 <-> Testcase reference_in_item(self.reference2, self.testcase) # Gene1 <-> Reaction1 gene_in_reaction(self.gene, self.reaction, valid=False) gene_in_reaction(self.gene2, self.reaction2) # Metabolite1 <-> Reaction1 metabolite_in_reaction(self.metabolite, self.reaction) metabolite_in_reaction(self.metabolite2, self.reaction2) # Evidence <-> Gene1/Reaction item_in_evidence(self.gene, self.evidence, valid=False) item_in_evidence(self.reaction, self.evidence, valid=False) # Check evidence is removed when reference deleted del self.evidence gc.collect() assert len(self.model.all_evidences) == 0 def test_delete_gene2(self): # Test removal of gene2 # Check: # - Gene2 removed from model # - Gene2 removed from reaction2 # - Testcase deleted from model # - Reference2 removed from testcase # Action self.model.gem_remove_genes((self.gene2,)) # Test genes gene_in_model(self.gene, self.model) gene_in_model(self.gene2, self.model, valid=False) # Test reactions reaction_in_model(self.reaction, self.model) reaction_in_model(self.reaction2, self.model) # Test metabolites metabolite_in_model(self.metabolite, self.model) metabolite_in_model(self.metabolite2, self.model) # Test evidences evidence_in_model(self.evidence, self.model) # Test model test case_in_model(self.testcase, self.model, valid=False) # Test references reference_in_model(self.reference, self.model) reference_in_model(self.reference2, self.model) # Test connections # Reference <-> Evidence reference_in_item(self.reference, self.evidence) # Reference2 <-> Testcase reference_in_item(self.reference2, self.testcase, valid=False) # Gene1 <-> Reaction1 gene_in_reaction(self.gene, self.reaction) gene_in_reaction(self.gene2, self.reaction2, valid=False) # Metabolite1 <-> Reaction1 metabolite_in_reaction(self.metabolite, self.reaction) metabolite_in_reaction(self.metabolite2, self.reaction2) # Evidence <-> Gene1/Reaction item_in_evidence(self.gene, self.evidence) item_in_evidence(self.reaction, self.evidence) def test_delete_testcase(self): # Action self.model.gem_remove_tests((self.testcase,)) # Test genes gene_in_model(self.gene, self.model) gene_in_model(self.gene2, self.model) # Test reactions reaction_in_model(self.reaction, self.model) reaction_in_model(self.reaction2, self.model) # Test metabolites metabolite_in_model(self.metabolite, self.model) metabolite_in_model(self.metabolite2, self.model) # Test evidences evidence_in_model(self.evidence, self.model) # Test model test case_in_model(self.testcase, self.model, valid=False) # Test references reference_in_model(self.reference, self.model) reference_in_model(self.reference2, self.model) # Test connections # Reference <-> Evidence reference_in_item(self.reference, self.evidence) # Reference2 <-> Testcase reference_in_item(self.reference2, self.testcase, valid=False) # Gene1 <-> Reaction1 gene_in_reaction(self.gene, self.reaction) gene_in_reaction(self.gene2, self.reaction2) # Metabolite1 <-> Reaction1 metabolite_in_reaction(self.metabolite, self.reaction) metabolite_in_reaction(self.metabolite2, self.reaction2) # Evidence <-> Gene1/Reaction item_in_evidence(self.gene, self.evidence) item_in_evidence(self.reaction, self.evidence) def test_delete_referenec(self): # Action self.model.gem_remove_references((self.reference,)) # Test genes gene_in_model(self.gene, self.model) gene_in_model(self.gene2, self.model) # Test reactions reaction_in_model(self.reaction, self.model) reaction_in_model(self.reaction2, self.model) # Test metabolites metabolite_in_model(self.metabolite, self.model) metabolite_in_model(self.metabolite2, self.model) # Test evidences evidence_in_model(self.evidence, self.model) # Test model test case_in_model(self.testcase, self.model) # Test references reference_in_model(self.reference, self.model, valid=False) reference_in_model(self.reference2, self.model) # Test connections # Reference <-> Evidence reference_in_item(self.reference, self.evidence, valid=False) # Reference2 <-> Testcase reference_in_item(self.reference2, self.testcase) # Gene1 <-> Reaction1 gene_in_reaction(self.gene, self.reaction) gene_in_reaction(self.gene2, self.reaction2) # Metabolite1 <-> Reaction1 metabolite_in_reaction(self.metabolite, self.reaction) metabolite_in_reaction(self.metabolite2, self.reaction2) # Evidence <-> Gene1/Reaction item_in_evidence(self.gene, self.evidence) item_in_evidence(self.reaction, self.evidence) def test_delete_reference2(self): # Action self.model.gem_remove_references((self.reference2,)) # Test genes gene_in_model(self.gene, self.model) gene_in_model(self.gene2, self.model) # Test reactions reaction_in_model(self.reaction, self.model) reaction_in_model(self.reaction2, self.model) # Test metabolites metabolite_in_model(self.metabolite, self.model) metabolite_in_model(self.metabolite2, self.model) # Test evidences evidence_in_model(self.evidence, self.model) # Test model test case_in_model(self.testcase, self.model) # Test references reference_in_model(self.reference, self.model) reference_in_model(self.reference2, self.model, valid=False) # Test connections # Reference <-> Evidence reference_in_item(self.reference, self.evidence) # Reference2 <-> Testcase reference_in_item(self.reference2, self.testcase, valid=False) # Gene1 <-> Reaction1 gene_in_reaction(self.gene, self.reaction) gene_in_reaction(self.gene2, self.reaction2) # Metabolite1 <-> Reaction1 metabolite_in_reaction(self.metabolite, self.reaction) metabolite_in_reaction(self.metabolite2, self.reaction2) # Evidence <-> Gene1/Reaction item_in_evidence(self.gene, self.evidence) item_in_evidence(self.reaction, self.evidence)
class TestEvidence: @pytest.fixture(autouse=True) def setup_evidence(self): self.reaction = Reaction("r_id") self.gene = Gene("g_id") self.target = Gene("g_id2") self.model = Model("test id") self.reference = Reference() self.model.add_gene(self.gene) self.model.add_gene(self.target) self.model.add_reactions([self.reaction]) self.model.add_reference(self.reference) # Set type self.assertion = "Catalyzed by" self.eco = "ECO:0000000" self.comment = "test" self.evidence = Evidence(entity=self.reaction, eco=self.eco, assertion=self.assertion, comment=self.comment, target=self.target) self.evidence.add_reference(self.reference) self.model.all_evidences[self.evidence.internal_id] = self.evidence self.root = Element("root", nsmap={None: ge_ns}) def test_setup(self): assert self.evidence.entity is self.reaction assert self.evidence.target is self.target assert len(self.evidence.references) == 1 assert list(self.evidence.references)[0] is self.reference assert self.evidence.assertion == self.assertion assert self.evidence.eco == self.eco assert self.evidence.comment == self.comment def test_add_evidence(self): add_evidences_to_xml(self.root, self.model) list_of_evidences = self.root.find(ge_listOfEvidences) assert list_of_evidences is not None assert len(list_of_evidences) == 1 evidence_node = list_of_evidences.find(ge_evidence) assert evidence_node is not None assert evidence_node.get("entity_id") == self.reaction.id assert evidence_node.get("entity_type") == "Reaction" assert evidence_node.get("id") == self.evidence.internal_id assert evidence_node.get("comment") == self.comment assert evidence_node.get("target_id") == self.target.id assert evidence_node.get("target_type") == "Gene" assert evidence_node.get("assertion") == self.assertion assert evidence_node.get("eco") == self.eco evidence_references_node = evidence_node.find(ge_listOfReferenceLinks) assert evidence_references_node is not None assert len(evidence_references_node) == 1 reference_link_node = evidence_references_node.find(ge_referenceLink) assert reference_link_node is not None assert reference_link_node.get("id") == self.reference.id def test_no_references_added_if_empty(self): self.evidence.remove_all_references() add_evidences_to_xml(self.root, self.model) list_of_evidences = self.root.find(ge_listOfEvidences) assert list_of_evidences is not None evidence_node = list_of_evidences.find(ge_evidence) assert evidence_node is not None # Check that reference not is not found assert evidence_node.find(ge_listOfReferenceLinks) is None def test_write_parse_consistency(self): add_evidences_to_xml(self.root, self.model) model = Model("New model") model.add_gene(self.gene) model.add_gene(self.target) model.add_reactions([self.reaction]) model.add_reference(self.reference) assert len(model.all_evidences) == 0 parse_evidences_from_xml(self.root, model) assert len(model.all_evidences) == 1 evidence = model.all_evidences[self.evidence.internal_id] assert evidence == self.evidence def test_get_item_from_model(self): model = Model("test id") reaction = Reaction("r_id") metabolite = Metabolite("m_id") gene = Gene("g_id") # ToDo: Add gene group model.add_reactions([reaction]) model.add_metabolites([metabolite]), model.add_gene(gene) # ToDo: Add gene group assert get_item_from_model("Model", model.id, model) is model assert get_item_from_model("Reaction", reaction.id, model) is reaction assert get_item_from_model("Metabolite", metabolite.id, model) is metabolite assert get_item_from_model("Gene", gene.id, model) is gene # Test expected errors # GeneGroup not implemented with pytest.raises(NotImplementedError): get_item_from_model("GeneGroup", "test_id", model) # ID not in model with pytest.raises(KeyError): get_item_from_model("Reaction", "Not in model", model) with pytest.raises(KeyError): get_item_from_model("Metabolite", "Not in model", model) with pytest.raises(KeyError): get_item_from_model("Gene", "Not in model", model) def test_minimal_example(self): """ Test that a minimal evidence example is parsed correctly """ xml_tree = ET.fromstring(minimal_evidence) model = Model() reaction = Reaction("Test") model.add_reaction(reaction) assert len(model.all_evidences) == 0 assert len(reaction.evidences) == 0 parse_evidences_from_xml(xml_tree, model) assert len(model.all_evidences) == 1 assert len(reaction.evidences) == 1 evidence = list(reaction.evidences)[0] assert evidence.entity is reaction assert evidence.assertion == "Presence" def test_full_example(self): """ Test that a minimal evidence example is parsed correctly """ xml_tree = ET.fromstring(full_evidence) model = Model() reaction = Reaction("Test") target_item = Gene("target_id") reference = Reference("ref_id") model.add_reaction(reaction) model.add_gene(target_item) model.add_reference(reference) assert len(model.all_evidences) == 0 assert len(reaction.evidences) == 0 parse_evidences_from_xml(xml_tree, model) assert len(model.all_evidences) == 1 assert len(reaction.evidences) == 1 evidence = list(reaction.evidences)[0] assert evidence.entity is reaction assert evidence.target is target_item assert evidence.assertion == "Catalyzed by" assert evidence.eco == "ECO:0000000" assert len(evidence.references) == 1 assert list(evidence.references)[0] is reference assert evidence.comment == "test comment"