class TestAssertionCatalyzingReaction: @pytest.fixture(autouse=True) def setup_items(self): self.reaction = Reaction("r1") self.gene = Gene("g1") self.evidence = Evidence(entity=self.gene, target=self.reaction, assertion="Catalyzing reaction") def test_valid_if_gene_in_reaction(self): self.reaction.add_child(self.gene) assert self.evidence.is_valid() is True def test_invalid_if_gene_not_in_reaction(self): assert self.evidence.is_valid() is False def test_gene_needed(self): evidence = Evidence(entity=self.gene, assertion="Catalyzing reaction") assert evidence.is_valid() is None def test_reaction_needed(self): evidence = Evidence(target=self.reaction, assertion="Catalyzing reaction") assert evidence.is_valid() is None def test_fix_gene_added(self): assert self.gene not in self.reaction.genes status = self.evidence.fix() assert status is True assert self.gene in self.reaction.genes
def test_reaction_is_disabled_with_disabled_gene_only(self): reaction = Reaction() gene = Gene() gene.functional = False reaction.add_child(gene) assert reaction.functional is False
def test_setting_resetting_boundaries(self): gene = Gene() reaction = Reaction(lower_bound=-1000., upper_bound=1000.) reaction.add_child(gene) gene.functional = True condition = GeneSetting(gene, False) assert gene.functional is True assert reaction.upper_bound == 1000. assert reaction.lower_bound == -1000. condition.do() assert gene.functional is False assert reaction.upper_bound == 0. assert reaction.lower_bound == 0. condition.undo() assert gene.functional is True assert reaction.upper_bound == 1000. assert reaction.lower_bound == -1000. # Check that calling undo second time does not change value condition.undo() assert gene.functional is True assert reaction.upper_bound == 1000. assert reaction.lower_bound == -1000.
def test_gene_addition(self): reaction = Reaction("reaction_id") gene = Gene("gene_id") reaction.add_child(gene) assert gene in reaction.genes assert reaction in gene.reactions
def test_reaction_is_disabled_with_gene_in_and_group(self): reaction = Reaction() genegroup = GeneGroup(type="and") reaction.add_child(genegroup) gene = Gene() genegroup.add_child(gene) gene.functional = False assert reaction.functional is False
def test_removal_empty_genegroup(self): reaction = Reaction("r1") gene_group = GeneGroup() reaction.add_child(gene_group) assert gene_group in reaction._children assert reaction in gene_group._parents prune_gene_tree(reaction) assert gene_group not in reaction._children assert reaction not in gene_group._parents
def test_sorting_valid(self): reaction = Reaction() gene = Gene() evidence = Evidence(entity=gene, target=reaction, assertion="Catalyzing reaction") reaction.add_child(gene) assert evidence.is_valid() is True conflicts, failing, errors = sort_evidences([evidence]) assert not conflicts assert not failing assert not errors
def test_gene_and_gene_group(self): gene1 = Gene("gene 1") gene2 = Gene("gene 2") gene3 = Gene("gene 3") genegroup1 = GeneGroup(type="and") genegroup2 = GeneGroup(type="or") reaction = Reaction() reaction.add_child(genegroup1) genegroup1.add_child(gene1) genegroup1.add_child(genegroup2) genegroup2.add_child(gene2) assert reaction.gene_reaction_rule == gene1.id+" and "+gene2.id genegroup2.add_child(gene3) assert reaction.gene_reaction_rule == gene1.id+" and ("+gene2.id+" or "+gene3.id+")"
def test_invalid_if_any_reaction_not_in_same_compartment(self): self.metabolite1.compartment = "c" self.metabolite2.compartment = "c" self.compartment.id = "c" assert self.evidence.is_valid() is True met1 = Metabolite("m1") met2 = Metabolite("m2") react2 = Reaction("r2") react2.add_metabolites({met1: -1, met2: 1}) react2.add_child(self.gene) assert self.evidence.is_valid() is False
def test_removal_of_genegroup_with_one_child(self, type): reaction = Reaction("r1") gene_group = GeneGroup(type=type) gene = Gene() reaction.add_child(gene_group) gene_group.add_child(gene) assert gene_group in reaction._children assert reaction in gene_group._parents assert gene in reaction.genes prune_gene_tree(reaction) assert gene_group not in reaction._children assert reaction not in gene_group._parents assert gene in reaction.genes
def test_removal_of_nested_or_groups(self): reaction = Reaction("r1") gene_group1 = GeneGroup(type="or") gene_group2 = GeneGroup(type="or") gene1 = Gene("g1") gene2 = Gene("g2") gene3 = Gene("g3") gene_group1.add_child(gene1) for x in (gene2, gene3): gene_group2.add_child(x) gene_group1.add_child(gene_group2) reaction.add_child(gene_group1) assert reaction.genes == set([gene1, gene2, gene3]) prune_gene_tree(reaction) assert reaction.genes == set([gene1, gene2, gene3]) assert not gene_group2._children assert not gene_group2._parents
def test_sorting_conflicting(self): reaction = Reaction() gene = Gene() reaction.add_child(gene) evidence1 = Evidence(entity=gene, target=reaction, assertion="Catalyzing reaction") evidence2 = Evidence(entity=gene, target=reaction, assertion="Not catalyzing reaction") assert evidence1.is_valid() is True assert evidence2.is_valid() is False conflicts, failing, errors = sort_evidences([evidence1, evidence2]) assert len(conflicts) == 1 assert set(conflicts[0]) == set([evidence1, evidence2]) assert not failing assert not errors
def test_delete_children(self): reaction = Reaction() reaction2 = Reaction() genegroup = GeneGroup() gene = Gene() reaction.add_child(genegroup) reaction2.add_child(genegroup) genegroup.add_child(gene) assert genegroup in reaction._children assert reaction in genegroup._parents assert genegroup in reaction2._children assert reaction2 in genegroup._parents assert gene in genegroup._children assert genegroup in gene._parents reaction.delete_children() assert genegroup not in reaction._children assert reaction not in genegroup._parents assert gene not in genegroup._children assert genegroup not in gene._parents assert genegroup in reaction2._children assert reaction2 in genegroup._parents
def test_reaction_enabled_true_with_empty_genegroup(self): reaction = Reaction() genegroup = GeneGroup() reaction.add_child(genegroup) assert reaction.functional is True
class TestGeneDisplayWidget: @pytest.fixture(autouse=True) def setup_items(self): self.parent = QWidget() self.widget = GenesDisplayWidget(self.parent) self.reaction = Reaction("test_id") self.model = Model("test model") @pytest.fixture() def patch_menu_exec(self, monkeypatch): monkeypatch.setattr("PyQt5.QtWidgets.QMenu.exec_", Mock()) @pytest.fixture() def patch_gene_selection_cancelled(self, monkeypatch): monkeypatch.setattr( "GEMEditor.model.selection.gene.GeneSelectionDialog.exec_", Mock(return_value=False)) @pytest.fixture() def patch_gene_selection_accepted(self, monkeypatch): gene = Gene("test") monkeypatch.setattr( "GEMEditor.model.selection.gene.GeneSelectionDialog.exec_", Mock(return_value=True)) monkeypatch.setattr( "GEMEditor.model.selection.gene.GeneSelectionDialog.selected_items", Mock(return_value=[gene])) return gene @pytest.fixture() def patch_iterate_tree(self, monkeypatch): mock = Mock() monkeypatch.setattr("GEMEditor.model.display.reaction.iterate_tree", mock) return mock def test_setup(self): assert self.widget.geneTable.rowCount() == 0 assert self.widget.cached_actions == [] assert self.widget.reaction is None assert self.widget.model is None def test_set_item(self): reaction = Reaction() model = Model() self.widget.populate_gene_tree = Mock() self.widget.clear_information = Mock() self.widget.set_item(reaction, model) assert self.widget.model is model assert self.widget.reaction is reaction assert self.widget.populate_gene_tree.called is True assert self.widget.clear_information.called is True def test_clear_information(self): self.widget.cached_actions.append(None) self.widget.geneTable.appendRow(QtGui.QStandardItem("Test")) assert self.widget.cached_actions != [] assert self.widget.geneTable.rowCount() == 1 self.widget.clear_information() assert self.widget.cached_actions == [] assert self.widget.geneTable.rowCount() == 0 def test_content_changed(self): assert self.widget.content_changed is False self.widget.cached_actions.append(None) assert self.widget.content_changed is True def test_save_state(self): self.widget.execute_cache = Mock() self.widget.save_state() assert self.widget.execute_cache.called is True 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 @pytest.mark.usefixtures("patch_menu_exec") def test_context_menu_no_selection(self): reaction = Reaction() model = Model() self.widget.set_item(reaction, model) assert self.widget.geneTable.rowCount() == 0 assert self.widget.get_selected_item()[1] is reaction menu = self.widget.show_gene_contextmenu(QtCore.QPoint()) assert len(menu.actions()) == 2 assert self.widget.add_gene_action in menu.actions() assert self.widget.add_genegroup_action in menu.actions() @pytest.mark.usefixtures("patch_menu_exec") def test_context_menu_gene(self): reaction = Reaction() model = Model() gene = Gene() self.widget.set_item(reaction, model) self.widget.geneTable.appendRow(LinkedItem("test", gene)) assert self.widget.geneTable.rowCount() == 1 index = self.widget.geneTable.item(0, 0).index() self.widget.geneView.setCurrentIndex(index) assert self.widget.get_selected_item()[1] is gene menu = self.widget.show_gene_contextmenu(QtCore.QPoint()) assert self.widget.delete_action in menu.actions() @pytest.mark.usefixtures("patch_menu_exec") def test_context_menu_genegroup(self): reaction = Reaction() model = Model() genegroup = GeneGroup() self.widget.set_item(reaction, model) self.widget.geneTable.appendRow(LinkedItem("test", genegroup)) assert self.widget.geneTable.rowCount() == 1 index = self.widget.geneTable.item(0, 0).index() self.widget.geneView.setCurrentIndex(index) assert self.widget.get_selected_item()[1] is genegroup menu = self.widget.show_gene_contextmenu(QtCore.QPoint()) assert self.widget.delete_genegroup_action in menu.actions() assert self.widget.add_gene_action in menu.actions() assert self.widget.add_genegroup_action in menu.actions() def test_add_gene(self): receiver = MockSlot() self.widget.changed.connect(receiver.slot) self.widget.set_item(self.reaction, self.model) # Check prior state assert len(self.widget.cached_actions) == 0 assert self.widget.geneTable.rowCount() == 0 assert len(self.reaction._children) == 0 # Action new_gene_id = "test id" new_gene = Gene(new_gene_id) self.widget.add_gene(new_gene) # Check emission of the changed signal assert receiver.called is True assert receiver.last_caller is self.widget # Check cached actions assert len(self.widget.cached_actions) == 1 action = self.widget.cached_actions[0] assert action[0] is self.reaction assert action[1] == "addition" assert action[2] is new_gene # Check the table item assert self.widget.geneTable.rowCount() == 1 assert self.widget.geneTable.item(0, 0).text() == new_gene_id assert self.widget.geneTable.item(0, 0).link is new_gene # Check that no children has been added assert len(self.reaction._children) == 0 def test_add_genegroup(self): receiver = MockSlot() self.widget.changed.connect(receiver.slot) self.widget.set_item(self.reaction, self.model) # Check prior state assert len(self.widget.cached_actions) == 0 assert self.widget.geneTable.rowCount() == 0 assert len(self.reaction._children) == 0 # Action self.widget.add_genegroup() # Check emission of the changed signal assert receiver.called is True assert receiver.last_caller is self.widget # Check cached actions assert len(self.widget.cached_actions) == 1 action = self.widget.cached_actions[0] assert action[0] is self.reaction assert action[1] == "addition" assert isinstance(action[2], GeneGroup) # Check the table item assert self.widget.geneTable.rowCount() == 1 assert isinstance(self.widget.geneTable.item(0, 0).link, GeneGroup) # Check that no children has been added assert len(self.reaction._children) == 0 def test_gene_deletion(self): receiver = MockSlot() gene = Gene("Test id") self.widget.changed.connect(receiver.slot) self.reaction.add_child(gene) self.widget.set_item(self.reaction, self.model) # Check prior state assert len(self.widget.cached_actions) == 0 assert self.widget.geneTable.rowCount() == 1 assert gene in self.reaction._children # Action self.widget.geneView.setCurrentIndex( self.widget.geneTable.item(0).index()) self.widget.delete_item() # Check emission of the changed signal assert receiver.called is True assert receiver.last_caller is self.widget # Check cached actions assert len(self.widget.cached_actions) == 1 action = self.widget.cached_actions[0] assert action[0] is self.reaction assert action[1] == "deletion" assert action[2] is gene # Check the table item assert self.widget.geneTable.rowCount() == 0 # Check that child is still present assert gene in self.reaction._children def test_execute_cache(self): action = (None, "addition", None) self.widget.cached_actions.append(action) self.widget.execute_action = Mock() self.widget.clear_information = Mock() # Action self.widget.execute_cache() self.widget.execute_action.assert_called_with(action) assert self.widget.clear_information.called is True def test_execute_action_addition(self): action = "addition" # Add Gene target = Mock() gene = Gene() self.widget.execute_action((target, action, gene)) target.add_child.assert_called_once_with(gene) # Add GeneGroup target = Mock() gene_group = GeneGroup() self.widget.execute_action((target, action, gene_group)) target.add_child.assert_called_once_with(gene_group) def test_execute_action_deletion(self): action = "deletion" # Delete Gene target = Mock() gene = Gene() self.widget.execute_action((target, action, gene)) target.remove_child.assert_called_once_with(gene) # Delete GeneGroup target = Mock() gene_group = GeneGroup() gene_group.delete_children = Mock() self.widget.execute_action((target, action, gene_group)) target.remove_child.assert_called_once_with(gene_group) assert gene_group.delete_children.called is False # Check that children are deleted if genegroup has only one parent target = Mock() gene_group = GeneGroup() gene_group.add_parent(self.reaction) gene_group.delete_children = Mock() self.widget.execute_action((target, action, gene_group)) target.remove_child.assert_called_once_with(gene_group) assert gene_group.delete_children.called is True @pytest.mark.usefixtures("patch_gene_selection_cancelled") def test_add_item_cancelled(self): # Setup self.widget.add_gene = Mock() self.widget.set_item(self.reaction, self.model) #Action self.widget.add_item() # Check that add gene has not been called assert self.widget.add_gene.called is False def test_add_item_accepted(self, patch_gene_selection_accepted): # Setup self.widget.add_gene = Mock() self.widget.set_item(self.reaction, self.model) # Action self.widget.add_item() # Check that add gene was called with the selected gene from # the gene selection dialog self.widget.add_gene.assert_called_once_with( patch_gene_selection_accepted) def test_populate_gene_tree_empty_reaction(self, patch_iterate_tree): # Setup self.widget.set_item(self.reaction, self.model) # Test conditions assert len(self.widget.reaction._children) == 0 # Action self.widget.populate_gene_tree() # Test outcome assert patch_iterate_tree.called is False def test_populate_gene_tree_nonempty_reaction(self, patch_iterate_tree): # Setup self.reaction.add_child(Gene("test")) self.widget.set_item(self.reaction, self.model) # Test condition assert len(self.widget.reaction._children) == 1 # Action self.widget.populate_gene_tree() # Test outcome patch_iterate_tree.assert_called_with( self.widget.geneTable.invisibleRootItem(), self.reaction)
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 TestAssertionLocalization: @pytest.fixture(autouse=True) def setup_items(self): self.gene = Gene("g1") self.compartment = Compartment("c") self.metabolite1 = Metabolite("m1") self.metabolite2 = Metabolite("m2") self.reaction = Reaction("r1") self.reaction.add_metabolites({ self.metabolite1: -1, self.metabolite2: 1 }) self.reaction.add_child(self.gene) self.evidence = Evidence(entity=self.gene, assertion="Localization", target=self.compartment) def test_valid_if_metabolites_in_same_compartment_as_gene(self): self.metabolite1.compartment = "c" self.metabolite2.compartment = "c" self.compartment.id = "c" assert self.evidence.is_valid() is True def test_invalid_if_metabolites_not_in_same_compartment(self): self.metabolite1.compartment = "e" self.metabolite2.compartment = "e" self.compartment.id = "c" assert self.evidence.is_valid() is False def test_invalid_if_any_reaction_not_in_same_compartment(self): self.metabolite1.compartment = "c" self.metabolite2.compartment = "c" self.compartment.id = "c" assert self.evidence.is_valid() is True met1 = Metabolite("m1") met2 = Metabolite("m2") react2 = Reaction("r2") react2.add_metabolites({met1: -1, met2: 1}) react2.add_child(self.gene) assert self.evidence.is_valid() is False def test_error_if_gene_not_added_to_reaction(self): gene = Gene("g1") evidence = Evidence(entity=gene, assertion="Localization") assert evidence.is_valid() is None def test_entity_needed(self): evidence = Evidence(assertion="Localization") assert evidence.is_valid() is None evidence.set_entity(self.gene) assert evidence.is_valid() is None evidence.set_target(self.compartment) assert evidence.is_valid() is not None