def test_deletion(self, user_response):
tab = ReferenceTab()
model = Model()
reference1 = Reference("r1")
reference2 = Reference("r2")
reference3 = Reference("r3")
model.add_reference(reference1)
model.add_reference(reference2)
model.add_reference(reference3)
model.setup_reference_table()
assert len(model.references) == model.QtReferenceTable.rowCount() == 3
tab.set_model(model)
tab.confirmDeletion = Mock(return_value=user_response)
item = tab.dataTable.item(1, 0)
selected_reference = item.link
source_index = tab.dataTable.indexFromItem(item)
view_index = tab.proxyModel.mapFromSource(source_index)
tab.dataView.selectRow(view_index.row())
assert tab.confirmDeletion.called is False
tab.deleteItemSlot()
assert tab.confirmDeletion.called is True
assert (selected_reference.id in model.references) is not user_response
if user_response:
assert len(
model.references) == model.QtReferenceTable.rowCount() == 2
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"
def test_edit_item_dialog_reject(self):
tab = ReferenceTab()
model = Model()
reference = Reference()
model.add_reference(reference)
model.setup_reference_table()
model.QtReferenceTable.update_row_from_item = Mock()
tab.set_model(model)
tab.dataView.selectRow(0)
assert model.QtReferenceTable.update_row_from_item.called is False
tab.editItemSlot()
assert model.QtReferenceTable.update_row_from_item.called is False
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_add_item_dialog_accept(self):
tab = ReferenceTab()
model = Model()
model.add_reference = Mock()
model.QtReferenceTable.update_row_from_item = Mock()
tab.set_model(model)
assert model.add_reference.called is False
assert model.QtReferenceTable.update_row_from_item.called is False
tab.addItemSlot()
assert model.add_reference.called is True
assert model.QtReferenceTable.update_row_from_item.called is True
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"
