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_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_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_setting_objective_value(self):
widget = ReactionAttributesDisplayWidget()
model = Model()
reaction = Reaction(id="test")
model.add_reactions((reaction, ))
widget.set_item(reaction, model)
new_value = 1.
assert reaction.objective_coefficient != new_value
widget.objectiveCoefficientInput.clear()
QtTest.QTest.keyClicks(widget.objectiveCoefficientInput,
str(new_value))
assert widget.objectiveCoefficientInput.value() == new_value
assert widget.content_changed is True
assert widget.valid_inputs() is True
def test_add_compartments_defined_in_metabolite():
model = Model()
metabolite = Metabolite(id="test", compartment="c")
model.add_metabolites([metabolite])
root = Element("Root")
add_compartments(root, model)
compartment_list = root.find(sbml3_listOfCompartments)
assert compartment_list is not None
compartment = compartment_list.find(sbml3_compartment)
assert compartment is not None
assert compartment.get("id") == "c"
assert compartment.get("name") 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_save_state_new_metabolite(self):
metabolite = Metabolite()
model = Model()
widget = MetaboliteAttributesDisplayWidget()
widget.set_item(metabolite, model)
new_id = "New"
new_name = "Name"
new_charge = 2.
new_formula = "H20"
new_compartment = "c"
widget.iDLineEdit.setText(new_id)
widget.nameLineEdit.setText(new_name)
widget.chargeSpinBox.setValue(new_charge)
widget.formulaLineEdit.setText(new_formula)
widget.compartmentComboBox.addItem(new_compartment)
widget.compartmentComboBox.setCurrentText(new_compartment)
widget.save_state()
assert metabolite.id == new_id
assert metabolite.name == new_name
assert metabolite.charge == new_charge
assert metabolite.formula == new_formula
assert metabolite.compartment == new_compartment
assert metabolite in model.metabolites
assert metabolite in model.QtMetaboliteTable.get_items()
def test_setting_item(self):
metabolite = Metabolite("test_id", "H2O", "Test metabolie", -5, "m")
model = Model()
widget = MetaboliteAttributesDisplayWidget()
# Test prestate
assert widget.iDLineEdit.text() == ""
assert widget.nameLineEdit.text() == ""
assert widget.compartmentComboBox.currentText() == ""
assert widget.chargeSpinBox.value() == 0
assert widget.formulaLineEdit.text() == ""
widget.set_item(metabolite, model)
assert widget.iDLineEdit.text() == metabolite.id
assert widget.nameLineEdit.text() == metabolite.name
assert widget.compartmentComboBox.currentText(
) == metabolite.compartment
assert widget.chargeSpinBox.value() == metabolite.charge
assert widget.formulaLineEdit.text() == metabolite.formula
assert widget.valid_inputs() is True
assert widget.content_changed is False
widget.set_item(None, model)
assert widget.iDLineEdit.text() == ""
assert widget.nameLineEdit.text() == ""
assert widget.compartmentComboBox.currentText() == ""
assert widget.chargeSpinBox.value() == 0.
assert widget.formulaLineEdit.text() == ""
assert widget.valid_inputs() is False
assert widget.content_changed is False
def test_writing_empty_model(self):
root = Element("root")
model = Model()
add_tests_to_xml(root, model)
assert len(root) == 0
def test_run_test_false_outcome2(self, progress):
model_test = ModelTest()
model_test.outcomes = [self.true_outcome1, self.false_outcome1]
results = run_tests((model_test, ), Model(), progress)
status, _ = results[model_test]
assert status is False
def test_setting_item(self):
gene = Gene("test_id", "name", "genome")
model = Model()
widget = GeneAttributesDisplayWidget()
# Test prestate
assert widget.iDLineEdit.text() == ""
assert widget.nameLineEdit.text() == ""
assert widget.genomeLineEdit.text() == ""
widget.set_item(gene, model)
assert widget.iDLineEdit.text() == gene.id
assert widget.nameLineEdit.text() == gene.name
assert widget.genomeLineEdit.text() == gene.genome
assert widget.valid_inputs() is True
assert widget.content_changed is False
widget.set_item(None, model)
assert widget.iDLineEdit.text() == ""
assert widget.nameLineEdit.text() == ""
assert widget.genomeLineEdit.text() == ""
assert widget.valid_inputs() is False
assert widget.content_changed is False
def setup_items(self):
self.first_author = Author(lastname="FirstLastname",
firstname="FirstFirstname",
initials="FirstInitials")
self.second_author = Author(lastname="SecondLastname",
firstname="SecondFirstname",
initials="SecondInitials")
self.authors = [self.first_author, self.second_author]
self.test_pmid = "123456"
self.test_pmc = "PMC12345"
self.test_doi = "10.1016/j.chemosphere.2016.03.102"
self.test_url = "http://google.com"
self.test_year = "1999"
self.test_title = "Test title"
self.test_journal = "Test journal"
self.test_ref_id = "Test_id"
self.reference = Reference(id=self.test_ref_id,
pmid=self.test_pmid,
pmc=self.test_pmc,
doi=self.test_doi,
url=self.test_url,
year=self.test_year,
title=self.test_title,
journal=self.test_journal,
authors=self.authors)
self.model = Model("Test")
self.model.references[self.reference.id] = self.reference
def test_close_model_model_cancel(self, mock_close_model):
main_window = mock_close_model
main_window.model = Model()
assert main_window.close_model() is False
assert main_window.save_table_headers.called is False
assert main_window._set_model_loaded.called is False
assert main_window.set_model.called is False
def test_close_model_model_accept(self, mock_close_model):
main_window = mock_close_model
main_window.model = Model()
assert main_window.close_model() is True
assert main_window.save_table_headers.call_count == 1
main_window._set_model_loaded.assert_called_once_with(False)
main_window.set_model.assert_called_once_with(None, None)
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)
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_description_loaded(self):
test = ModelTest(description="Test description")
model = Model()
self.dialog.set_test(test, model)
assert self.dialog.nameLineEdit.text() == test.description
def test_get_selected_item_none_selected(self):
reaction = Reaction()
model = Model()
self.widget.set_item(reaction, model)
assert self.widget.geneTable.rowCount() == 0
table_item, linked_item = self.widget.get_selected_item()
assert table_item is self.widget.geneTable
assert linked_item is reaction
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 new_model(self):
if self.close_model():
model = Model()
dialog = EditModelDialog(model)
status = dialog.exec_()
if status:
self.set_model(model, None)
self._set_model_loaded(True)
def setup_items(self):
self.model = Model("Test")
self.c1 = Compartment(id="c", name="Cytoplasm")
self.c2 = Compartment(id="e", name="Extracellular")
self.model.gem_compartments[self.c1.id] = self.c1
self.compartment_table = CompartmentTable()
self.compartment_table.populate_table(self.model.gem_compartments.values())
self.wrong_format_abbreviation = "ca"
def test_parse_compartments():
parent_node = ET.fromstring(valid_compartment_list)
model = Model()
parse_compartments(parent_node, model)
assert model.gem_compartments["p"] == Compartment("p", "Periplasm")
assert model.gem_compartments["c"] == Compartment("c", "Cytoplasm")
assert model.gem_compartments["e"] == Compartment("e", "Extracellular")
def test_add_compartment_empty_model():
model = Model()
root = Element("root")
add_compartments(root, model)
compartment_list = root.find(sbml3_listOfCompartments)
assert compartment_list is None
def test_run_test_infeasible_solution(self, mock_optimize_infeasible,
progress):
model_test = ModelTest()
model_test.outcomes = [self.true_outcome1, self.false_outcome1]
results = run_tests((model_test, ), Model(), progress)
status, solution = results[model_test]
assert solution is mock_optimize_infeasible
assert status is False
def setup_items(self):
self.test_id = "test.id"
self.test_name = "test_name"
self.test_genome = "test_genome"
self.gene = Gene(id=self.test_id,
name=self.test_name,
genome=self.test_genome)
self.model = Model("Test_model")
self.model.genes.append(self.gene)
def setup_items(self):
self.parent = QWidget()
self.widget = AnnotationDisplayWidget(self.parent)
self.empty_reaction = Reaction()
self.annotated_reaction = Reaction()
self.annotation = Annotation("chebi", "CHEBI:123454")
self.annotated_reaction.annotation.add(self.annotation)
self.model = Model()
def test_reaction_enormous_bounds(self):
widget = ReactionAttributesDisplayWidget()
model = Model()
reaction = Reaction(id="test", lower_bound=-999999, upper_bound=999999)
widget.set_item(reaction, model)
assert widget.lowerBoundInput.value() == -999999
assert widget.upperBoundInput.value() == 999999
assert widget.lowerBoundInput.minimum() == -999999
assert widget.upperBoundInput.maximum() == 999999
def test_valid_input(self):
reaction = Reaction(id="test")
model = Model()
widget = ReactionAttributesDisplayWidget()
widget.set_item(reaction, model)
assert widget.valid_inputs() is True
widget.idLineEdit.clear()
assert widget.valid_inputs() is False
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 parse_sbml3_model(sbml_node):
if sbml_node is not None:
model_node = sbml_node.find(sbml3_model)
if model_node is not None:
model = Model(id_or_model=model_node.get("id"),
name=model_node.get("name"))
return model_node, model
return None
