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 TestReaction:
@pytest.fixture()
def setup_item(self):
self.test_id = "test_id"
self.test_name = "test_name"
self.test_upper_bound = 1000.
self.test_lower_bound = -1000.
self.reaction = Reaction(id=self.test_id,
name=self.test_name,
lower_bound=self.test_lower_bound,
upper_bound=self.test_upper_bound)
@pytest.mark.usefixtures("setup_item")
def test_setup_item(self):
assert self.reaction.id == self.test_id
assert self.reaction.name == self.test_name
assert self.reaction.upper_bound == self.test_upper_bound
assert self.reaction.lower_bound == self.test_lower_bound
assert self.reaction._model is None
def test_empty_reaction_setup(self):
reaction = Reaction()
assert reaction.id == ""
assert reaction.name == ""
assert reaction.subsystem == ""
assert reaction.lower_bound == 0.
assert reaction.upper_bound == 1000.
assert reaction.comment == ""
assert reaction.annotation == set()
assert reaction.model is None
assert len(reaction._children) == 0
def test_none_reaction_setup(self):
reaction = Reaction(id=None,
name=None,
subsystem=None,
lower_bound=None,
upper_bound=None,
comment=None)
assert reaction.id == ""
assert reaction.name == ""
assert reaction.subsystem == ""
assert reaction.lower_bound == 0.
assert reaction.upper_bound == 1000.
assert reaction.comment == ""
assert len(reaction._children) == 0
@pytest.mark.usefixtures("setup_item")
@pytest.mark.parametrize("lower_bound,upper_bound,objective", [(0., 1000., 0.),
(-1000., 1000., 1.),
(-1000., 0., 20.),
(0., 0., 0.)])
def test_get_setting(self, lower_bound, upper_bound, objective):
self.reaction.upper_bound = upper_bound
self.reaction.lower_bound = lower_bound
setting = self.reaction.get_setting()
assert setting.reaction is self.reaction
assert setting.upper_bound == upper_bound
assert setting.lower_bound == lower_bound
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_gene_addition(self, ex_empty_reaction):
test_gene = Gene(id="test", name="test")
# Check addition
ex_empty_reaction.add_child(test_gene)
assert test_gene in ex_empty_reaction._children
assert ex_empty_reaction in test_gene._parents
# Check removal
ex_empty_reaction.remove_child(test_gene)
assert test_gene not in ex_empty_reaction._children
assert ex_empty_reaction not in test_gene._parents
def test_reaction_genegroup_addition(self):
reaction = ex_empty_reaction()
genegroup = ex_empty_geneGroup()
# Check addition and references
reaction.add_child(genegroup)
assert genegroup in reaction._children
assert reaction in genegroup._parents
# Check removal
reaction.remove_child(genegroup)
assert genegroup not in reaction._children
assert genegroup._parents == []
@pytest.mark.parametrize("parent", [Gene(), GeneGroup(), Reaction()])
def test_add_parent(self, parent):
reaction = Reaction()
with pytest.raises(NotImplementedError):
reaction.add_parent(parent)
@pytest.mark.parametrize("parent", [Gene(), GeneGroup(), Reaction()])
def test_remove_parent(self, parent):
reaction = Reaction()
with pytest.raises(NotImplementedError):
reaction.remove_parent(parent)
@pytest.mark.usefixtures("setup_item")
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_reaction_enabled_without_genes(self):
reaction = Reaction()
assert reaction.functional is True
def test_reaction_enabled_true_with_empty_genegroup(self):
reaction = Reaction()
genegroup = GeneGroup()
reaction.add_child(genegroup)
assert reaction.functional is True
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_reaction_is_disabled_with_gene_in_or_group(self):
reaction = Reaction()
genegroup = GeneGroup(type="or")
reaction.add_child(genegroup)
gene = Gene()
genegroup.add_child(gene)
gene.functional = False
assert reaction.functional is False
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
