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_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_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_reaction_is_disabled_with_disabled_gene_only(self):
reaction = Reaction()
gene = Gene()
gene.functional = False
reaction.add_child(gene)
assert reaction.functional is False
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 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_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 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)
def setup_items(self):
self.parent = QWidget()
self.widget = AnnotationDisplayWidget(self.parent)
self.empty_reaction = Reaction()
self.annotated_reaction = Reaction()
self.annotation = Annotation("chebi", "CHEBI:123454")
self.annotated_reaction.annotation.add(self.annotation)
self.model = Model()
def setup_items(self):
self.parent = QWidget()
self.widget = StoichiometryDisplayWidget(self.parent)
self.test_met_id = "test_id"
self.test_react_id = "test_id2"
self.test_stoich = -1.5
self.metabolite = Metabolite(id=self.test_met_id)
self.reaction = Reaction(id=self.test_react_id)
self.reaction.add_metabolites({self.metabolite: self.test_stoich})
self.model = Model("test")
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
class TestReactionTable:
@pytest.fixture(autouse=True)
def setup_items(self):
self.table = ReactionTable()
self.test_id = "test_id"
self.test_name = "test_name"
self.test_subsystem = "test_subsystemm"
self.test_ub = 1500.5
self.test_lb = 500.5
self.test_obj_coeff = 0.
self.test_item = Reaction(id=self.test_id,
name=self.test_name,
subsystem=self.test_subsystem,
upper_bound=self.test_ub,
lower_bound=self.test_lb)
def test_setup(self):
# Test header settings
for i, text in enumerate(self.table.header):
assert self.table.horizontalHeaderItem(i).text() == text
assert self.table.rowCount() == 0
def test_row_from_item(self):
return_values = self.table.row_from_item(self.test_item)
assert return_values[0].text() == self.test_id
assert return_values[1].text() == self.test_name
# Fromula not set
assert return_values[2].text() == self.test_item.build_reaction_string(
)
assert return_values[3].text() == self.test_subsystem
assert return_values[4].text() == str(self.test_lb)
assert return_values[5].text() == str(self.test_ub)
assert float(return_values[6].text()) == self.test_obj_coeff
def test_update_row_(self):
assert self.table.rowCount() == 0
self.table.update_row_from_item(self.test_item)
assert self.table.rowCount() == 1
assert self.table.item(0, 0).text() == self.test_id
assert self.table.item(0, 1).text() == self.test_name
assert self.table.item(
0, 2).text() == self.test_item.build_reaction_string()
assert self.table.item(0, 3).text() == self.test_subsystem
assert self.table.item(0, 4).text() == str(self.test_lb)
assert self.table.item(0, 5).text() == str(self.test_ub)
assert float(self.table.item(0, 6).text()) == self.test_obj_coeff
def test_item_from_row(self):
self.table.update_row_from_item(self.test_item)
assert self.table.rowCount() == 1
assert self.table.item_from_row(0) is self.test_item
def test_no_update_if_boundary(self):
""" Check that formula is not updated when metabolite is
part of a boundary reaction """
react = Reaction("rea")
met1 = Metabolite("met1")
react.add_metabolites({met1: -1})
result = update_formula_from_neighborhood(met1)
assert result is False
assert not met1.formula
def setup_items(self):
self.table = ReactionTable()
self.test_id = "test_id"
self.test_name = "test_name"
self.test_subsystem = "test_subsystemm"
self.test_ub = 1500.5
self.test_lb = 500.5
self.test_obj_coeff = 0.
self.test_item = Reaction(id=self.test_id,
name=self.test_name,
subsystem=self.test_subsystem,
upper_bound=self.test_ub,
lower_bound=self.test_lb)
class TestOutcomes:
@pytest.fixture(autouse=True)
def setup_items(self):
self.outcome = Outcome()
self.solution = Mock()
def test_setup(self):
assert self.outcome.reaction is None
assert self.outcome.value is None
assert self.outcome.operator is None
def test_check_solution(self):
reaction_id = "test_id"
reaction = Reaction(reaction_id)
fluxes = {reaction_id: 5.}
new_outcome = Outcome(reaction, value=0., operator="greater than")
assert new_outcome.check(fluxes) is True
fluxes = {reaction_id: 0.}
assert new_outcome.check(fluxes) is False
new_outcome.operator = "less than"
assert new_outcome.check(fluxes) is False
new_outcome.value = 10.
assert new_outcome.check(fluxes) is True
new_outcome.operator = ""
assert new_outcome.check(fluxes) is False
def test_empty_outcome_is_not_valid(self):
assert self.outcome.is_valid() is False
def test_no_operator_set_is_invalid(self):
self.outcome.reaction = Reaction()
self.outcome.value = 0.
assert self.outcome.operator is None
assert self.outcome.is_valid() is False
@pytest.mark.parametrize("parameters",
[(Reaction(), 0., "greater than", True),
(None, 0., "greater than", False),
(Reaction(), None, "greater than", False),
(Reaction(), 0., None, False),
(None, None, None, False)])
def test_outcome_is_valid(self, parameters):
outcome = Outcome(reaction=parameters[0],
value=parameters[1],
operator=parameters[2])
assert outcome.is_valid() is parameters[3]
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_no_update_if_mutliple_metabolites_wo_formula(self):
""" Check that formula is not updated if multiple metabolites
have no formula set """
react = Reaction("rea")
met1 = Metabolite("met1", formula="C7H8O2")
met2 = Metabolite("met2")
met3 = Metabolite("met3")
react.add_metabolites({met1: 1, met3: 1, met2: -1})
result = update_formula_from_neighborhood(met3)
assert result is False
assert not met3.formula
def test_successful_update(self):
""" Check that metabolite formula is successfully updated
from a reaction where all other metabolite formulae are set """
react = Reaction("rea")
met1 = Metabolite("met1", formula="C7H8O2")
met2 = Metabolite("met2", formula="C8H8O4")
met3 = Metabolite("met3")
react.add_metabolites({met1: 1, met3: 1, met2: -1})
result = update_formula_from_neighborhood(met3)
assert result is True
assert met3.formula == "CO2"
def setup_items(self):
self.table = ModelTestTable()
self.reaction1 = Reaction("test")
self.reaction2 = Reaction("test2")
self.outcome = Outcome(reaction=self.reaction1,
value=0.,
operator="greater than")
self.setting = ReactionSetting(reaction=self.reaction2,
upper_bound=1000.,
lower_bound=0.,
objective_coefficient=0.)
self.model_test = ModelTest(description="test case")
self.model_test.add_outcome(self.outcome)
self.model_test.add_setting(self.setting)
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_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_balancing_status2(self):
charge = 0
formula = "H2O"
met1 = Metabolite("test1", charge=charge, formula=formula)
met2 = Metabolite("test2", charge=charge, formula=formula)
stoichiometry = 1
reaction = Reaction("test")
reaction.add_metabolites({met1: stoichiometry, met2: -stoichiometry})
self.widget.set_item(reaction, self.model)
assert self.widget.statusLabel.toolTip(
) == self.widget.msg_standard.format(status="balanced",
charge="OK",
elements="OK")
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 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_copy_evidence(self):
entity = Reaction()
target = Gene()
eco = "ECO:000000"
assertion = "Presence"
comment = "test comment"
reference = Reference()
evidence = Evidence(entity=entity,
eco=eco,
assertion=assertion,
comment=comment,
target=target)
evidence.add_reference(reference)
# Create copy
copy = evidence.copy()
# Check the correctness of the copy
assert evidence.entity is copy.entity
assert evidence.target is copy.target
assert evidence.eco == copy.eco
assert evidence.assertion == copy.assertion
assert evidence.comment == copy.comment
assert evidence.references == copy.references
assert evidence.references is not copy.references
# Check that the copy is not linked
assert copy not in entity.evidences
assert copy not in reference.linked_items
assert copy not in target.evidences
def addItemSlot(self):
new_reaction = Reaction()
dialog = EditReactionDialog(new_reaction, self.model, parent=self)
status = dialog.exec_()
if status:
self.model.add_reaction(new_reaction)
self.dataTable.update_row_from_item(new_reaction)
def test_evidence_init(self):
entity = Reaction()
target = Gene("id2")
eco = "ECO:000000"
assertion = "Presence"
comment = "test comment"
reference = Reference()
evidence = Evidence(entity=entity,
eco=eco,
assertion=assertion,
comment=comment,
target=target)
evidence.add_reference(reference)
# Check proper linking
assert evidence.entity is entity
assert evidence in entity.evidences
assert evidence.target is target
assert evidence in target.evidences
# Check attributes
assert evidence.assertion == assertion
assert evidence.eco == eco
assert evidence.comment == comment
# Check id is set
assert type(evidence.internal_id) is str
assert evidence.internal_id != ""
# Check the references
assert reference in evidence.references
assert evidence in reference.linked_items
def setup_items(self):
self.table = OutcomesTable()
self.reaction1 = Reaction(id="test_reaction1")
self.outcome1_value = 1.5
self.outcome1_operator = "greater than"
self.outcome1 = Outcome(reaction=self.reaction1,
value=self.outcome1_value,
operator=self.outcome1_operator)
self.reaction2 = Reaction(id="test_reaction2")
self.outcome2_value = 100.5
self.outcome2_operator = "less than"
self.outcome2 = Outcome(reaction=self.reaction2,
value=self.outcome2_value,
operator=self.outcome2_operator)
