def test_deletion(self, user_response):
tab = ReactionTab()
model = Model()
reaction1 = Reaction("r1")
reaction2 = Reaction("r2")
reaction3 = Reaction("r3")
model.add_reactions([reaction1, reaction2, reaction3])
model.setup_reaction_table()
assert len(model.reactions) == model.QtReactionTable.rowCount() == 3
tab.set_model(model)
tab.confirmDeletion = Mock(return_value=user_response)
item = tab.dataTable.item(1, 0)
selected_reaction = 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_reaction in model.reactions) is not user_response
assert tab.dataTable.findItems(
selected_reaction.id) is not user_response
if user_response:
assert len(
model.reactions) == model.QtReactionTable.rowCount() == 2
def test_setting_reaction(self):
widget = ReactionAttributesDisplayWidget()
reaction = Reaction(id="id",
name="name",
subsystem="subsystem",
lower_bound=-1000.,
upper_bound=1000.)
model = Model()
model.add_reactions((reaction, ))
reaction.objective_coefficient = 1.
assert widget.idLineEdit.text() == ""
assert widget.nameLineEdit.text() == ""
assert widget.subsystemLineEdit.text() == ""
assert widget.lowerBoundInput.value() == 0.
assert widget.upperBoundInput.value() == 0.
assert widget.objectiveCoefficientInput.value() == 0.
assert widget.content_changed is False
assert widget.valid_inputs() is False
widget.set_item(reaction, model)
assert widget.idLineEdit.text() == reaction.id
assert widget.nameLineEdit.text() == reaction.name
assert widget.subsystemLineEdit.text() == reaction.subsystem
assert widget.lowerBoundInput.value() == reaction.lower_bound
assert widget.upperBoundInput.value() == reaction.upper_bound
assert widget.objectiveCoefficientInput.value(
) == reaction.objective_coefficient
assert widget.content_changed is False
assert widget.valid_inputs() is True
def test_saving_changes(self):
widget = ReactionAttributesDisplayWidget()
reaction = Reaction("r1")
model = Model("id")
model.add_reactions((reaction, ))
widget.set_item(reaction, model)
new_id = "New id"
new_name = "New name"
new_subsytem = "New Subsystem"
new_upper_bound = 200.5
new_lower_bound = -300.5
new_obj_coefficient = 20.4
widget.idLineEdit.setText(new_id)
widget.nameLineEdit.setText(new_name)
widget.subsystemLineEdit.setText(new_subsytem)
widget.upperBoundInput.setValue(new_upper_bound)
widget.lowerBoundInput.setValue(new_lower_bound)
widget.objectiveCoefficientInput.setValue(new_obj_coefficient)
# Action
widget.save_state()
# Check that inputs are saved
assert reaction.id == new_id
assert reaction.name == new_name
assert reaction.subsystem == new_subsytem
assert reaction.lower_bound == new_lower_bound
assert reaction.upper_bound == new_upper_bound
assert reaction.objective_coefficient == new_obj_coefficient
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_modify_item_reject(self):
tab = ReactionTab()
model = Model()
model.QtReactionTable.update_row_from_link = Mock()
reaction = Reaction(id="old_id")
model.add_reactions([reaction])
model.setup_reaction_table()
tab.set_model(model)
tab.dataView.selectRow(0)
assert model.QtReactionTable.update_row_from_link.called is False
tab.editItemSlot()
assert model.QtReactionTable.update_row_from_link.called is False
def test_no_map_by_stoichiometry_if_any_metabolite_not_mapped(
self, database, progress):
model = Model()
met1 = Metabolite("m1")
met2 = Metabolite("m2")
model.add_metabolites((met1, met2))
model.database_mapping.update({met1: 1})
reaction = Reaction("r1")
reaction.add_metabolites({met1: -1, met2: -1})
model.add_reactions([reaction])
update_reaction_database_mapping(database, model, progress)
assert reaction not in model.database_mapping
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_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_map_reaction_by_stoichiometry(self, database, progress):
model = Model()
met1 = Metabolite("m1")
met2 = Metabolite("m2")
met3 = Metabolite("m3")
met4 = Metabolite("m4")
model.add_metabolites((met1, met2, met3, met4))
model.database_mapping.update({met1: 1, met2: 2, met3: 3, met4: 4})
reaction = Reaction("r1")
reaction.add_metabolites({met1: -1, met2: -1, met3: 1, met4: 1})
model.add_reactions([reaction])
update_reaction_database_mapping(database, model, progress)
assert model.database_mapping[reaction] == 1
def test_map_reaction_by_annotation(self, database, progress):
model = Model()
met1 = Metabolite("m1")
met2 = Metabolite("m2")
model.add_metabolites([met1, met2])
reaction = Reaction("r1")
reaction.add_metabolites({met1: -1, met2: 1})
reaction.annotation.add(
Annotation(identifier="MNXR14892", collection="metanetx.reaction"))
model.add_reactions([reaction])
update_reaction_database_mapping(database, model, progress)
assert model.database_mapping[reaction] == 1
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()
def test_reaction_subsystem_setting(self):
model = Model()
# Test subsystem setting while reaction not in model
new_subsystem1 = "New subsystem"
self.reaction.subsystem = new_subsystem1
assert self.reaction.subsystem == new_subsystem1
# Test that the subsystem is updated on the model
model.add_reactions([self.reaction])
assert model is self.reaction._model
assert len(model.subsystems) == 1
assert new_subsystem1 in model.subsystems
assert self.reaction in model.subsystems[new_subsystem1]
# Test that changing the subsystem is reflected in model.subsystems
new_subsystem2 = "Different Stubsystem"
self.reaction.subsystem = new_subsystem2
assert len(model.subsystems) == 1
assert new_subsystem2 in model.subsystems
assert self.reaction in model.subsystems[new_subsystem2]
def test_update_iteratively(self):
""" Check that metabolite are successfully
updated one after another """
react = Reaction("rea")
met1 = Metabolite("met1", formula="C7H8O2")
met2 = Metabolite("met2")
met3 = Metabolite("met3") # Update to CO2 in second iteration
react.add_metabolites({met1: 1, met3: 1, met2: -1})
react1 = Reaction("rea2") # Transfer C8H8O4
met4 = Metabolite("met4", formula="C8H8O4")
react1.add_metabolites({met2: -1, met4: 1})
# Setup model
model = Model("id")
model.add_metabolites([met1, met2, met3, met4])
model.add_reactions([react, react1])
return_value = update_formulae_iteratively(model)
assert met2.formula == met4.formula
assert met3.formula == "CO2"
assert set(return_value) == set([met2, met3])
class TestGetOriginalSettings:
@pytest.fixture(autouse=True)
def setup_items(self):
self.model = Model("id")
self.m1 = Metabolite("m1")
self.m2 = Metabolite("m2")
self.r1 = Reaction(id="r1")
self.model.add_reactions((self.r1, ))
def test_boundary_forward(self):
self.r1.add_metabolites({self.m1: -1})
# Original settings
self.r1.upper_bound = 200.
self.r1.lower_bound = -200
self.r1.objective_coefficient = 1
# Get the setting of a boundary reaction
setting = _get_original_settings(self.model)[0]
# Check that original values are stored
assert setting.reaction is self.r1
assert setting.upper_bound == 200
# Check that reaction is producing only
assert setting.lower_bound == 0.
assert setting.objective_coefficient == 0.
def test_boundary_reverse(self):
self.r1.add_metabolites({self.m1: 1})
# Original settings
self.r1.upper_bound = 200.
self.r1.lower_bound = -200
self.r1.objective_coefficient = 1
# Get the setting of a boundary reaction
setting = _get_original_settings(self.model)[0]
# Check that original values are stored
assert setting.reaction is self.r1
assert setting.lower_bound == -200
# Check that reaction is producing only
assert setting.upper_bound == 0.
assert setting.objective_coefficient == 0.
def test_inactive_reaction(self):
self.r1.add_metabolites({self.m1: -1, self.m2: 1})
self.r1.lower_bound = 0.
self.r1.upper_bound = 0.
self.r1.objective_coefficient = 1.
# Get the setting of a boundary reaction
setting = _get_original_settings(self.model)[0]
# Check that objective setting is deactivated
assert setting.reaction is self.r1
assert setting.lower_bound == 0.
assert setting.upper_bound == 0.
assert setting.objective_coefficient == 0.
@pytest.mark.parametrize("params, expectations",
[((-200, 200, 1.), (-200, 200, 0.)),
((0, 200, 1.), (0., 200, 0.)),
((-200, 0, 1.), (-200, 0, 0.)),
((-200, -50, 1.), (-200, -50, 0.)),
((100, 200, 1.), (100, 200, 0.))])
def test_setting_for_optimized_reactions(self, params, expectations):
self.r1.add_metabolites({self.m1: -1, self.m2: 1})
self.r1.lower_bound = params[0]
self.r1.upper_bound = params[1]
self.r1.objective_coefficient = params[2]
setting = _get_original_settings(self.model)[0]
# Check that the settings are expected
assert setting.lower_bound == expectations[0]
assert setting.upper_bound == expectations[1]
assert setting.objective_coefficient == expectations[2]
@pytest.mark.parametrize("params", [(-200, 200, 0.), (0, 200, 0.),
(-200, 0, 0.), (-200, -50, 0.),
(100, 200, 0.)])
def test_no_setting_for_nonoptimized_reactions(self, params):
self.r1.add_metabolites({self.m1: -1, self.m2: 1})
self.r1.lower_bound = params[0]
self.r1.upper_bound = params[1]
self.r1.objective_coefficient = params[2]
assert not _get_original_settings(self.model)
class TestRunTest:
@pytest.fixture(autouse=True)
def setup_test(self):
self.model = Model("id")
self.metabolite1 = Metabolite("m1")
self.metabolite2 = Metabolite("m2")
self.reaction1 = Reaction("r1", lower_bound=-1000., upper_bound=1000.)
self.model.add_reactions((self.reaction1, ))
self.reaction1.objective_coefficient = 0.
self.r1_init_setting = self.reaction1.get_setting()
self.reaction1.add_metabolites({
self.metabolite1: -1,
self.metabolite2: 1
})
self.reaction1.flux_value = 50.
self.setting1 = ReactionSetting(reaction=self.reaction1,
upper_bound=0.,
lower_bound=0.,
objective_coefficient=1.)
self.reaction2 = Reaction("r2", lower_bound=0., upper_bound=50.)
self.model.add_reactions((self.reaction2, ))
self.reaction2.objective_coefficient = 1.
self.setting2 = ReactionSetting(reaction=self.reaction2,
upper_bound=1000.,
lower_bound=-1000.,
objective_coefficient=0.)
self.r2_init_setting = self.reaction2.get_setting()
self.reaction2.add_metabolites({self.metabolite1: -1})
self.true_outcome1 = Outcome(reaction=self.reaction1,
value=15.,
operator="less than")
self.false_outcome1 = Outcome(reaction=self.reaction1,
value=15.,
operator="greater than")
@pytest.fixture()
def mock_optimize(self, monkeypatch, solution):
monkeypatch.setattr("GEMEditor.model.classes.cobra.Model.optimize",
Mock(return_value=solution))
@pytest.fixture()
def mock_optimize_infeasible(self, monkeypatch, infeasible_solution):
monkeypatch.setattr("GEMEditor.model.classes.cobra.Model.optimize",
Mock(return_value=infeasible_solution))
return infeasible_solution
@pytest.fixture()
def mock_get_original_settings(self, monkeypatch):
return_value = [Mock(), Mock()]
monkeypatch.setattr(
"GEMEditor.analysis.model_test._get_original_settings",
Mock(return_value=return_value))
return return_value
@pytest.fixture()
def progress(self):
return Mock(wasCanceled=Mock(return_value=False))
def test_outcomes(self, solution):
assert self.true_outcome1.check(solution.x_dict) is True
assert self.false_outcome1.check(solution.x_dict) is False
@pytest.mark.usefixtures("mock_optimize")
def test_mock(self):
result = Model().optimize()
assert isinstance(result.x_dict, dict)
@pytest.mark.usefixtures("mock_optimize")
def test_run_test_true_outcome(self, progress):
model_test = ModelTest()
model_test.outcomes = [self.true_outcome1]
results = run_tests((model_test, ), Model(), progress)
status, _ = results[model_test]
assert status is True
@pytest.mark.usefixtures("mock_optimize")
def test_run_test_false_outcome(self, progress):
model_test = ModelTest()
model_test.outcomes = [self.false_outcome1]
results = run_tests((model_test, ), Model(), progress)
status, _ = results[model_test]
assert status is False
@pytest.mark.usefixtures("mock_optimize")
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_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
@pytest.mark.usefixtures("mock_optimize")
def test_value_restored(self, progress):
model_test = ModelTest()
self.setting2.do = Mock()
model_test.reaction_settings = [self.setting1, self.setting2]
assert self.setting2.do.called is False
assert self.reaction1 is self.setting1.reaction
results = run_tests((model_test, ), Model(), progress)
status, _ = results[model_test]
assert self.setting2.do.called is True
assert self.reaction1.upper_bound == self.r1_init_setting.upper_bound
assert self.reaction1.lower_bound == self.r1_init_setting.lower_bound
assert self.reaction1.objective_coefficient == self.r1_init_setting.objective_coefficient
@pytest.mark.usefixtures("mock_optimize")
def test_restore_initial_get_original_called(self,
mock_get_original_settings,
progress):
original_settings = mock_get_original_settings
assert GEMEditor.analysis.model_test._get_original_settings.called is False
model_test = ModelTest()
model_test.outcomes = [self.true_outcome1]
results = run_tests((model_test, ), Model(), progress)
status, _ = results[model_test]
assert GEMEditor.analysis.model_test._get_original_settings.called is True
for x in original_settings:
assert x.do.called is True
class TestTestCases:
@pytest.fixture(autouse=True)
def setup_items(self):
self.model = Model()
self.testcase = ModelTest(description="test_description")
self.reaction1 = Reaction(id="r1")
self.testsetting1 = ReactionSetting(self.reaction1,
upper_bound=1000.,
lower_bound=0.,
objective_coefficient=0.)
self.testcase.add_setting(self.testsetting1)
self.reaction3 = Reaction(id="r3")
self.outcome = Outcome(self.reaction3, value=100., operator="greater")
self.testcase.add_outcome(self.outcome)
self.reference = Reference(id="test_refid")
self.testcase.add_reference(self.reference)
self.model.add_reactions([self.reaction1, self.reaction3])
self.model.references[self.reference.id] = self.reference
self.model.tests.append(self.testcase)
self.model.setup_tests_table()
self.root = Element("root", nsmap={None: ge_ns})
add_tests_to_xml(self.root, self.model)
def test_setup_items(self):
assert len(self.root) == 1
def test_testcase_addition2(self):
test_list_node = self.root.find(ge_listOfTests)
assert test_list_node is not None
assert len(test_list_node) == 1
test_node = test_list_node.find(ge_testCase)
assert test_node is not None
assert test_node.get("description") == "test_description"
assert len(test_node) == 3
test_settings_list_node = test_node.find(ge_listOfSettings)
assert test_settings_list_node is not None
assert len(test_settings_list_node) == 1
setting_node = test_settings_list_node.find(ge_reactionSetting)
assert setting_node is not None
assert setting_node.get("reactionId") == "R_r1"
assert setting_node.get("upperBound") == "1000"
assert setting_node.get("lowerBound") == "0"
assert setting_node.get("objectiveCoefficient") == "0"
test_outcomes_list_node = test_node.find(ge_listOfOutcomes)
assert test_outcomes_list_node is not None
assert len(test_outcomes_list_node) == 1
outcome_node = test_outcomes_list_node.find(ge_outcome)
assert outcome_node is not None
assert outcome_node.get("reactionId") == "R_r3"
assert outcome_node.get("value") == "100"
assert outcome_node.get("operator") == "greater"
test_references_list_node = test_node.find(ge_listOfReferenceLinks)
assert test_references_list_node is not None
assert len(test_references_list_node) == 1
reference_node = test_references_list_node.find(ge_referenceLink)
assert reference_node is not None
assert reference_node.get("id") == "test_refid"
def test_writing_empty_model(self):
root = Element("root")
model = Model()
add_tests_to_xml(root, model)
assert len(root) == 0
def test_read_write_consistency(self):
self.model.tests.clear()
assert self.model.tests == []
parse_test_from_xml(self.root, self.model)
# Check that a test has been added to the model
assert len(self.model.tests) == 1
test = self.model.tests[0]
assert test.description == "test_description"
# Check that a setting has been added
assert len(test.reaction_settings) == 1
setting = test.reaction_settings[0]
assert setting.upper_bound == 1000.
assert setting.lower_bound == 0.
assert setting.objective_coefficient == 0.
assert setting.reaction.id == "r1"
# Check that the outcome has been added
assert len(test.outcomes) == 1
outcome = test.outcomes[0]
assert outcome.reaction.id == "r3"
assert outcome.value == 100.
assert outcome.operator == "greater"
# Check that the reference has been added
assert len(test.references) == 1
assert self.reference in test.references
class TestModelDisplayWidget:
@pytest.fixture(autouse=True)
def setup_items(self):
self.parent = QWidget()
self.widget = ModelDisplayWidget(self.parent)
self.test_id = "Test_model"
self.test_name = "Test name"
self.model = Model(self.test_id, name=self.test_name)
self.comp1_abbrev = "c"
self.comp1_name = "Cytoplasm"
self.comp1 = Compartment(self.comp1_abbrev, self.comp1_name)
self.model.gem_compartments[self.comp1_abbrev] = self.comp1
self.gene = Gene(id="test_id", name="test_name")
self.metabolite = Metabolite(id="test_id", compartment="c")
self.reaction = Reaction(id="test_id")
self.model.add_metabolites([self.metabolite])
self.model.add_reactions([self.reaction])
self.model.genes.append(self.gene)
def test_setup(self):
assert len(self.model.metabolites) == 1
assert len(self.model.reactions) == 1
assert len(self.model.genes) == 1
assert self.model.id == self.test_id
assert self.model.name == self.test_name
assert self.model.gem_compartments[self.comp1_abbrev] == self.comp1
def test_model_addition(self):
path = "Test_path"
self.widget.set_model(self.model, path=path)
assert self.widget.label_model_id.text() == self.test_id
assert self.widget.label_model_name.text() == self.test_name
assert self.widget.label_number_genes.text() == str(
len(self.model.genes))
assert self.widget.label_number_reactions.text() == str(
len(self.model.reactions))
assert self.widget.label_number_metabolites.text() == str(
len(self.model.metabolites))
assert self.widget.label_model_path.text() == path
def test_clear_information(self):
path = "Test_path"
self.widget.set_model(self.model, path=path)
self.widget.clear_information()
assert self.widget.label_model_name.text() == ""
assert self.widget.label_model_id.text() == ""
assert self.widget.label_number_reactions.text() == ""
assert self.widget.label_number_metabolites.text() == ""
assert self.widget.label_number_genes.text() == ""
assert self.widget.label_model_path.text() == path
def test_setting_empty_model(self):
path = "Test_path"
self.widget.set_model(self.model, path=path)
self.widget.set_model(None)
assert self.widget.label_model_name.text() == ""
assert self.widget.label_model_id.text() == ""
assert self.widget.label_number_reactions.text() == ""
assert self.widget.label_number_metabolites.text() == ""
assert self.widget.label_number_genes.text() == ""
assert self.widget.label_model_path.text() == ""
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"