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
