class TestModelTestsTab:
@pytest.fixture()
def patched_remove_tests(self, monkeypatch):
mock = Mock()
monkeypatch.setattr(
"GEMEditor.model.classes.cobra.Model.gem_remove_tests", mock)
return mock
@pytest.fixture(autouse=True)
def setup_items(self):
self.tab = ModelTestsTab()
self.model = Model()
self.model.setup_tables()
self.test_description = "Test_name"
self.test_case = ModelTest(description=self.test_description)
self.reaction1 = Reaction(id="r1")
self.setting = ReactionSetting(reaction=self.reaction1,
upper_bound=1000.,
lower_bound=0.,
objective_coefficient=0.)
self.reaction2 = Reaction(id="r2")
self.outcome = Outcome(reaction=self.reaction2,
value=0.,
operator="greater than")
self.test_case.add_outcome(self.outcome)
self.test_case.add_setting(self.setting)
self.tab.set_model(self.model)
def test_setup_items(self):
assert self.model.QtTestsTable is not None
assert self.model.QtTestsTable.rowCount() == 0
assert self.tab.model is self.model
@pytest.mark.parametrize("user_response", [True, False])
def test_user_asked_upon_deletion(self, user_response,
patched_remove_tests):
tab = ModelTestsTab()
tab.set_model(Model())
tab.confirmDeletion = Mock(return_value=user_response)
tab.dataView.delete_selected_rows = Mock()
assert tab.confirmDeletion.called is False
assert patched_remove_tests.called is False
tab.deleteItemSlot()
assert tab.confirmDeletion.called is True
assert patched_remove_tests.called is user_response
def test_updating(self):
model = Model()
met1 = Metabolite(id="met1", formula="H2O", name="Water", charge=0., compartment="c")
react1 = Reaction(id="react1", name="test2", subsystem="test2", lower_bound=0., upper_bound=1000.)
react1.add_metabolites({met1: -1})
model.add_metabolites([met1])
model.add_reactions([react1])
model.setup_tables()
assert model.QtReactionTable.rowCount() == 1
assert model.QtMetaboliteTable.rowCount() == 1
# Check that content is right
for i, element in enumerate(model.QtMetaboliteTable.header):
assert str(getattr(met1, element.lower())) == model.QtMetaboliteTable.item(0, i).text()
# Check that metabolite id is in table
assert met1.id in model.QtReactionTable.item(0, 2).text()
# Change metabolite
met1.id = "new_id"
met1.name = "new_name"
met1.formula = "H2O2"
met1.name = "None"
met1.charge = 1.
met1.compartment = "e"
# Tables are out of sync
for i, element in enumerate(model.QtMetaboliteTable.header):
assert str(getattr(met1, element.lower())) != model.QtMetaboliteTable.item(0, i).text()
# Check reaction table out of sync
assert react1.id not in model.QtReactionTable.item(0, 2).text()
model.gem_update_metabolites([met1])
# Metabolite table updated
for i, element in enumerate(model.QtMetaboliteTable.header):
assert str(getattr(met1, element.lower())) == model.QtMetaboliteTable.item(0, i).text()
# Reaction table updated
assert met1.id in model.QtReactionTable.item(0, 2).text()
class TestEditModelSettings:
@pytest.fixture(autouse=True)
def setup_items(self):
self.test_id = "Test_id"
self.test_name = "Test_name"
self.model = Model(self.test_id, self.test_name)
self.parent = QWidget()
self.comp1_name = "Cytoplasm"
self.comp1_id = "c"
self.new_comp_id = "n"
self.new_comp_name = "Nucleus"
self.new_comp = Compartment(self.new_comp_id, self.new_comp_name)
self.comp1 = Compartment(self.comp1_id, self.comp1_name)
self.model.gem_compartments[self.comp1_id] = self.comp1
self.metabolite = Metabolite("test", compartment=self.comp1_id)
self.model.add_metabolites([self.metabolite])
self.model.setup_tables()
self.dialog = EditModelDialog(model=self.model)
@pytest.fixture()
def patch_progress(self, monkeypatch):
monkeypatch.setattr("PyQt5.QtWidgets.QProgressDialog", Mock())
monkeypatch.setattr("PyQt5.QtWidgets.QApplication.processEvents", Mock())
def test_setup(self):
assert self.model.name == self.test_name
assert self.model.id == self.test_id
assert self.comp1_id in self.model.gem_compartments
assert self.model.gem_compartments[self.comp1_id] == self.comp1
assert self.dialog.buttonBox.button(QDialogButtonBox.Save).isEnabled() is False
assert self.dialog.input_name.text() == self.test_name
assert self.dialog.input_id.text() == self.test_id
assert self.dialog.compartmentTable.rowCount() == 1
assert self.metabolite in self.model.metabolites
def test_change_in_id_enables_button(self):
model = Model()
model.gem_compartments["c"] = Compartment("c", "Cytoplasm")
dialog = EditModelDialog(model=model)
save_button = dialog.buttonBox.button(QDialogButtonBox.Save)
# Change id
assert save_button.isEnabled() is False
QtTest.QTest.keyClick(dialog.input_id, "M")
assert save_button.isEnabled() is True
# Undo change
QtTest.QTest.keyClick(dialog.input_id, QtCore.Qt.Key_Backspace)
assert save_button.isEnabled() is False
def test_change_in_name_enables_button(self):
model = Model()
model.gem_compartments["c"] = Compartment("c", "Cytoplasm")
dialog = EditModelDialog(model=model)
save_button = dialog.buttonBox.button(QDialogButtonBox.Save)
# Change id
assert save_button.isEnabled() is False
QtTest.QTest.keyClicks(dialog.input_name, "M")
assert save_button.isEnabled() is True
# Undo change
QtTest.QTest.keyClick(dialog.input_name, QtCore.Qt.Key_Backspace)
assert save_button.isEnabled() is False
def test_add_compartment(self):
row_count = self.dialog.compartmentTable.rowCount()
self.dialog._add_new_compartment_to_table(self.new_comp)
assert self.dialog.compartmentTable.rowCount() == row_count + 1
assert self.dialog.buttonBox.button(QDialogButtonBox.Save).isEnabled() is True
assert self.dialog.input_changed() is True
def test_compartment_deletion(self):
assert self.dialog.compartmentTable.rowCount() == 1
self.dialog.compartmentTableView.selectRow(0)
QtTest.QTest.mouseClick(self.dialog.button_del_compartment, QtCore.Qt.LeftButton)
assert self.dialog.compartmentTable.rowCount() == 0
def test_change_compartment_name(self):
assert self.dialog.buttonBox.button(QDialogButtonBox.Save).isEnabled() is False
self.dialog.compartmentTable.item(0, 1).setText(self.new_comp_name)
assert self.dialog.buttonBox.button(QDialogButtonBox.Save).isEnabled() is True
def test_save_changes_id(self):
QtTest.QTest.keyClicks(self.dialog.input_id, self.test_id)
self.dialog.save_changes()
assert self.model.id == self.test_id + self.test_id
def test_save_changes_name(self):
QtTest.QTest.keyClicks(self.dialog.input_name, self.test_name)
self.dialog.save_changes()
assert self.model.name == self.test_name + self.test_name
def test_save_changes_compartment_addition(self):
self.dialog._add_new_compartment_to_table(self.new_comp)
assert self.dialog.compartmentTable.rowCount() == 2
self.dialog.save_changes()
assert self.model.gem_compartments == {self.comp1_id: self.comp1,
self.new_comp_id: self.new_comp}
assert self.metabolite in self.model.metabolites
def test_save_changes_compartment_deletion(self):
self.dialog.compartmentTable.setRowCount(0)
assert self.metabolite in self.model.metabolites
self.dialog.save_changes()
assert self.model.gem_compartments == {}
assert self.metabolite not in self.model.metabolites
def test_save_changed_compartment_name(self):
self.dialog.compartmentTable.item(0, 1).setText(self.new_comp_name)
assert self.dialog.buttonBox.button(QDialogButtonBox.Save).isEnabled() is True
self.dialog.save_changes()
assert self.model.gem_compartments[self.comp1_id].name == self.new_comp_name
def test_save_changed_compartment_id(self):
new_id = "z"
self.dialog.compartmentTable.item(0, 0).setText(new_id)
self.dialog.save_changes()
assert "z" in self.model.gem_compartments
assert self.metabolite.compartment == new_id
assert self.model.gem_compartments[new_id] is self.comp1
assert self.comp1.name == self.comp1_name
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)
