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_addition_emits_changed(self):
parent = QWidget()
widget = ReactionSettingDisplayWidget(parent)
test = ModelTest()
reaction = Reaction()
setting = ReactionSetting(reaction, 1000., -1000., 5.)
model = Model()
test.add_setting(setting)
widget.set_item(test, model)
detector = Mock()
widget.changed.connect(detector.test)
widget.dataTable.update_row_from_item(
ReactionSetting(Reaction(), 200., -200, 0.))
assert detector.test.called is True
assert widget.content_changed is True
def item_from_row(self, row_idx):
""" Return the setting object as represented in a table row """
# Make sure the lower boundary is smaller than the upper
bounds = (self.item(row_idx, 1).data(2), self.item(row_idx, 2).data(2))
return ReactionSetting(reaction=self.item(row_idx, 0).link,
lower_bound=min(bounds),
upper_bound=max(bounds),
objective_coefficient=self.item(row_idx,
3).data(2))
def _get_original_settings(model):
""" Get all settings needed to prepare for test run
In the preparation for running test cases care should
be taken that:
1) All objective coefficients should be set to 0
2) All boundary reactions are producing only
Both the active boundary reactions and the objective
coefficients need to be specified in the settings of
the test cases.
Parameters
----------
model: GEMEditor.model.classes.Model,
Model context for the reactions
Returns
-------
original_settings: list,
List of settings that need to be executed in order
to prepare the model for running tests, and should
be reversed afterwards
"""
original_settings = []
for x in model.reactions:
# Set all boundary reaction to producing only
if all(v < 0. for v in x.metabolites.values()):
original_settings.append(ReactionSetting(x, x.upper_bound, 0., 0.))
elif all(v > 0. for v in x.metabolites.values()):
original_settings.append(ReactionSetting(x, 0., x.lower_bound, 0.))
# Set all objective coefficients to zero
elif x.objective_coefficient != 0.:
original_settings.append(ReactionSetting(x, x.upper_bound, x.lower_bound, 0.))
return original_settings
def test_content_changed(self):
parent = QWidget()
widget = ReactionSettingDisplayWidget(parent)
test = ModelTest()
reaction = Reaction()
setting = ReactionSetting(reaction, 1000., -1000., 5.)
model = Model()
test.add_setting(setting)
widget.set_item(test, model)
assert widget.content_changed is False
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")
def test_set_parameters(self):
old_lb = -1000.
old_ub = 1000.
old_obj_value = 1.
with patch(
'GEMEditor.model.classes.cobra.Reaction.objective_coefficient',
new_callable=PropertyMock) as objective_coefficient:
objective_coefficient.return_value = old_obj_value
reaction = Reaction("test_id",
lower_bound=old_lb,
upper_bound=old_ub)
new_lb = -500.
new_ub = 500.
new_obj_value = 0.
setting = ReactionSetting(reaction,
upper_bound=new_ub,
lower_bound=new_lb,
objective_coefficient=new_obj_value)
assert reaction.upper_bound == old_ub
assert reaction.lower_bound == old_lb
assert reaction.objective_coefficient == old_obj_value
setting.do()
assert reaction.upper_bound == new_ub
assert reaction.lower_bound == new_lb
assert objective_coefficient.call_args == call(new_obj_value)
objective_coefficient.return_value = new_obj_value
setting.undo()
assert reaction.upper_bound == old_ub
assert reaction.lower_bound == old_lb
assert objective_coefficient.call_args == call(old_obj_value)
objective_coefficient.return_value = old_obj_value
# Check that calling undo a second time does not change the value
prior_call_count = objective_coefficient.call_count
setting.undo()
assert reaction.upper_bound == old_ub
assert reaction.lower_bound == old_lb
assert objective_coefficient.call_count == prior_call_count
def test_modification_emits_changed(self):
parent = QWidget()
widget = ReactionSettingDisplayWidget(parent)
test = ModelTest()
reaction = Reaction()
setting = ReactionSetting(reaction, 1000., -1000., 5.)
model = Model()
test.add_setting(setting)
widget.set_item(test, model)
detector = Mock()
widget.changed.connect(detector.test)
widget.dataTable.item(0, 1).setData(500, 2)
assert detector.test.called is True
assert widget.content_changed is 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_setting_item(self):
parent = QWidget()
widget = ReactionSettingDisplayWidget(parent)
test = ModelTest()
reaction = Reaction()
setting = ReactionSetting(reaction, 1000., -1000., 5.)
model = Model()
test.add_setting(setting)
widget.dataTable.populate_table = Mock()
widget.set_item(test, model)
widget.dataTable.populate_table.assert_called_once_with(
test.reaction_settings)
assert widget.model is model
assert widget.model_test is test
def test_deletion_emits_changed(self):
parent = QWidget()
widget = ReactionSettingDisplayWidget(parent)
test = ModelTest()
reaction = Reaction()
setting = ReactionSetting(reaction, 1000., -1000., 5.)
model = Model()
test.add_setting(setting)
widget.set_item(test, model)
detector = Mock()
widget.changed.connect(detector.test)
widget.tableView.selectRow(0)
QtTest.QTest.mouseClick(widget.button_del_item, QtCore.Qt.LeftButton)
assert widget.dataTable.rowCount() == 0
assert detector.test.called is True
assert widget.content_changed is True
def setup_items(self):
self.tab = ModelTestsTab()
self.model = Model()
self.model.setup_tables()
self.test_description = "Test_name"
self.test_case = ModelTest(description=self.test_description)
self.reaction1 = Reaction(id="r1")
self.setting = ReactionSetting(reaction=self.reaction1,
upper_bound=1000.,
lower_bound=0.,
objective_coefficient=0.)
self.reaction2 = Reaction(id="r2")
self.outcome = Outcome(reaction=self.reaction2,
value=0.,
operator="greater than")
self.test_case.add_outcome(self.outcome)
self.test_case.add_setting(self.setting)
self.tab.set_model(self.model)
def test_saving_items(self):
parent = QWidget()
widget = ReactionSettingDisplayWidget(parent)
test = ModelTest()
reaction = Reaction()
setting = ReactionSetting(reaction, 1000., -1000., 5.)
model = Model()
test.add_setting(setting)
widget.set_item(test, model)
new_test = ModelTest()
widget.model_test = new_test
assert len(new_test.reaction_settings) == 0
widget.save_state()
assert len(new_test.reaction_settings) == 1
new_setting = list(new_test.reaction_settings)[0]
assert new_setting == setting
assert new_setting is not setting
def parse_test_from_xml(model_node, model, progress=None):
list_of_tests_node = model_node.find(ge_listOfTests)
if list_of_tests_node is None:
return
elif progress is None:
pass
elif not progress.wasCanceled():
progress.setLabelText("Reading test cases...")
progress.setRange(0, len(list_of_tests_node))
else:
return
for i, test_node in enumerate(list_of_tests_node.iterfind(ge_testCase)):
if progress is None:
pass
elif not progress.wasCanceled():
progress.setValue(i)
QApplication.processEvents()
else:
return
new_test = ModelTest(description=test_node.get("description"),
comment=test_node.get("comment"))
settings_list_node = test_node.find(ge_listOfSettings)
outcomes_list_node = test_node.find(ge_listOfOutcomes)
reference_list_node = test_node.find(ge_listOfReferenceLinks)
# Add settings
if settings_list_node is not None:
for setting_node in settings_list_node.iterfind(
ge_reactionSetting):
reaction = model.reactions.get_by_id(
clip(setting_node.get("reactionId"), "R_"))
new_setting = ReactionSetting(
reaction=reaction,
upper_bound=float(setting_node.get("upperBound")),
lower_bound=float(setting_node.get("lowerBound")),
objective_coefficient=float(
setting_node.get("objectiveCoefficient")))
new_test.add_setting(new_setting)
for gene_setting_node in settings_list_node.iterfind(
ge_geneSetting):
gene = model.genes.get_by_id(
clip(gene_setting_node.get("geneId"), "G_"))
new_setting = GeneSetting(gene)
if gene_setting_node.get("active") == "True":
new_setting.activity = True
elif gene_setting_node.get("active") == "False":
new_setting.activity = False
else:
raise ValueError(
"Unexpected value for activity in gene setting.")
new_test.add_setting(new_setting)
# Add outcomes
if outcomes_list_node is not None:
for outcome_node in outcomes_list_node.iterfind(ge_outcome):
reaction = model.reactions.get_by_id(
clip(outcome_node.get("reactionId"), "R_"))
new_outcome = Outcome(reaction=reaction,
value=float(outcome_node.get("value")),
operator=outcome_node.get("operator"))
new_test.add_outcome(new_outcome)
# Add references
if reference_list_node is not None:
for refLink_node in reference_list_node.iterfind(ge_referenceLink):
new_test.add_reference(
model.references[refLink_node.get("id")])
model.tests.append(new_test)
def setup_items(self):
self.test = ModelTest()
self.outcome1 = Outcome()
self.reaction_setting = ReactionSetting()
self.gene_setting = GeneSetting()
self.reference1 = Reference()
def get_setting(self):
return ReactionSetting(
reaction=self,
upper_bound=self.upper_bound,
lower_bound=self.lower_bound,
objective_coefficient=self.objective_coefficient)