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"