class TestSimpleSBML(unittest.TestCase): def setUp(self): self.simple = SimpleSBML() self.simple.initialize(cn.TEST_FILE) def testInitialize(self): if IGNORE_TEST: return simple = SimpleSBML() simple.initialize(cn.TEST_FILE) self.assertEqual(len(simple.reactions), cn.NUM_REACTIONS) self.assertEqual(len(simple.molecules), len(simple.moietys)) def testGetMolecule(self): if IGNORE_TEST: return molecule1 = self.simple.molecules[0] name = molecule1.name molecule2 = self.simple.getMolecule(name) self.assertTrue(molecule1.isEqual(molecule2)) self.assertIsNone(self.simple.getMolecule(NO_NAME)) def testAdd(self): if IGNORE_TEST: return def test(): self.assertEqual(len(self.simple.reactions), 2) for reaction in [reaction0, reaction1]: self.assertTrue(reaction in self.simple.reactions) # reaction0 = self.simple.reactions[0] reaction1 = self.simple.reactions[1] self.simple.reactions = [reaction0] self.simple.add(reaction1) test() self.simple.add(reaction1) test() def testRemove(self): num_reactions = len(self.simple.reactions) reaction0 = self.simple.reactions[0] reaction1 = self.simple.reactions[1] self.simple.remove(reaction0) self.assertTrue(reaction0 not in self.simple.reactions) self.assertTrue(reaction1 in self.simple.reactions) self.simple.add(reaction0) self.assertTrue(len(self.simple.reactions), num_reactions) def testGetReaction(self): if IGNORE_TEST: return reaction = self.simple.reactions[0] label = reaction.label reaction1 = self.simple.getReaction(label) self.assertTrue(reaction.isEqual(reaction1))
class TestSOM(unittest.TestCase): def setUp(self): self.simple = SimpleSBML() self.simple.initialize(cn.TEST_FILE3) self.molecules = self.simple.molecules self.soms = [] for mole in self.molecules: self.soms.append(SOM({mole})) def testConstructor(self): if IGNORE_TEST: return self.assertEqual(len(self.soms), len(self.molecules)) self.assertEqual(self.soms[0].molecules, {self.molecules[0]}) def testMakeId(self): if IGNORE_TEST: return som = self.soms[0] self.assertTrue(som.molecules.intersection(self.molecules)) molecule = list(re.findall(NAMEFILTER, som.identifier))[0] self.assertEqual( list(som.molecules)[0], self.simple.getMolecule(molecule)) def testMerge(self): if IGNORE_TEST: return som1 = self.soms[0] som2 = self.soms[1] molecule1 = list(som1.molecules)[0] molecule2 = list(som2.molecules)[0] new_som = som1.merge(som2) self.assertEqual(len(new_som.molecules), NUM_MERGED_SOMS) self.assertTrue(molecule1 in new_som.molecules) self.assertTrue(molecule2 in new_som.molecules)
class TestMESGraph(unittest.TestCase): def setUp(self): # SimpleSBML with type I error self.simple = SimpleSBML() self.simple.initialize(cn.TEST_FILE6) # SimpleSBML with type II error self.simple2 = SimpleSBML() self.simple2.initialize(cn.TEST_FILE7) # SimpleSBML for type III error self.simple3 = SimpleSBML() self.simple3.initialize(cn.TEST_FILE10) # SimpleSBML for type IV error self.simple4 = SimpleSBML() self.simple4.initialize(cn.TEST_FILE11) # simple5 for type V error self.simple5 = SimpleSBML() self.simple5.initialize(cn.TEST_FILE12) # simple6 will test multi-multi model with no errors self.simple6 = SimpleSBML() self.simple6.initialize(cn.TEST_FILE3) self.mesgraph = MESGraph(self.simple) def testConstructor(self): if IGNORE_TEST: return self.assertEqual(len(self.mesgraph.nodes), INITIAL_NODES) self.assertEqual(len(self.mesgraph.edges), INITIAL_EDGES) dfg = self.simple.getMolecule(DFG) # molecules is a list of one-molecule sets molecules = [som.molecules for som in self.mesgraph.nodes] self.assertTrue({self.simple.getMolecule(DFG)} in molecules) self.assertEqual(len(self.mesgraph.type_one_errors), 0) self.assertEqual(len(self.mesgraph.type_two_errors), 0) self.assertEqual(len(self.mesgraph.type_three_errors), 0) self.assertEqual(len(self.mesgraph.type_four_errors), 0) self.assertEqual(len(self.mesgraph.type_five_errors), 0) def testInitializeSOMs(self): if IGNORE_TEST: return for node in self.mesgraph.nodes: self.assertEqual(type(node), SOM) def testMakeId(self): if IGNORE_TEST: return identifier = "" for key, som in enumerate(self.mesgraph.nodes): identifier = identifier + som.identifier if key < len(self.mesgraph.nodes)-1: identifier = identifier + ";" self.assertEqual(identifier, self.mesgraph.identifier) def testGetNode(self): if IGNORE_TEST: return aa = self.simple.getMolecule(AA) aa_node = self.mesgraph.getNode(aa) self.assertEqual(type(aa_node), SOM) self.assertEqual(aa_node.molecules, {aa}) def testMergeNodes(self): if IGNORE_TEST: return m3 = MESGraph(self.simple3) v1_reaction = self.simple3.getReaction(V1) v2_reaction = self.simple3.getReaction(V2) amp_molecule = self.simple3.getMolecule(AMP) adp_molecule = self.simple3.getMolecule(ADP) atp_molecule = self.simple3.getMolecule(ATP) amp_som = m3.getNode(amp_molecule) adp_som = m3.getNode(adp_molecule) atp_som = m3.getNode(atp_molecule) ampatp_som = m3.mergeNodes(amp_som, atp_som, v1_reaction) self.assertTrue(amp_molecule in ampatp_som.molecules) self.assertTrue(atp_molecule in ampatp_som.molecules) self.assertTrue(ampatp_som in m3.nodes) # tests if anohter merge will remove previous nodes ampadpatp_som = m3.mergeNodes(ampatp_som, adp_som, v2_reaction) self.assertFalse(ampatp_som in m3.nodes) self.assertFalse(adp_som in m3.nodes) self.assertTrue(ampadpatp_som in m3.nodes) def testProcessUniUniReaction(self): if IGNORE_TEST: return self.mesgraph.processUniUniReaction( self.simple.reactions[UNIUNI0]) dfg = self.mesgraph.getNode(self.simple.getMolecule(DFG)) e1 = self.mesgraph.getNode(self.simple.getMolecule(E1)) self.assertTrue(self.mesgraph.has_node(dfg)) self.assertTrue(self.mesgraph.has_node(e1)) self.assertEqual(dfg, e1) def testProcessUniMultiReaction(self): if IGNORE_TEST: return unimulti_reaction = self.simple.reactions[UNIMULTI] self.mesgraph.processUniMultiReaction(unimulti_reaction) prods = [self.mesgraph.getNode(product.molecule) for product in unimulti_reaction.products] dfg = self.mesgraph.getNode(self.simple.getMolecule(DFG)) for prod in prods: self.assertTrue(self.mesgraph.has_edge(prod, dfg)) def testProcessMultiUniReaction(self): if IGNORE_TEST: return multiuni_reaction = self.simple.reactions[MULTIUNI] self.mesgraph.processMultiUniReaction(multiuni_reaction) reacts = [self.mesgraph.getNode(reactant.molecule) for reactant in multiuni_reaction.reactants] mel = self.mesgraph.getNode(self.simple.getMolecule(MEL)) for react in reacts: self.assertTrue(self.mesgraph.has_edge(react, mel)) def testAddMultiMultiReaction(self): if IGNORE_TEST: return m3 = MESGraph(self.simple3) v2 = self.simple3.getReaction(V2) m3.addMultiMultiReaction(v2) self.assertTrue(v2 in m3.multimulti_reactions) def testAddTypeThreeError(self): if IGNORE_TEST: return m3 = MESGraph(self.simple3) v1 = self.simple3.getReaction(V1) v2 = self.simple3.getReaction(V2) v3 = self.simple3.getReaction(V3) m3.processUniUniReaction(v1) m3.processUniMultiReaction(v3) amp = m3.getNode(self.simple3.getMolecule(AMP)) atp = m3.getNode(self.simple3.getMolecule(ATP)) self.assertTrue(m3.addTypeThreeError(amp, atp, v2)) self.assertTrue(len(m3.type_three_errors), 1) error = m3.type_three_errors[0] self.assertEqual(error.node1, amp) self.assertEqual(error.node2, atp) self.assertEqual(error.reactions, [v2.label]) def testCheckTypeThreeError(self): if IGNORE_TEST: return m3 = MESGraph(self.simple3) v1 = self.simple3.getReaction(V1) v2 = self.simple3.getReaction(V2) v3 = self.simple3.getReaction(V3) m3.processUniUniReaction(v1) adp = m3.getNode(self.simple3.getMolecule(ADP)) atp = m3.getNode(self.simple3.getMolecule(ATP)) self.assertFalse(m3.checkTypeThreeError(adp, atp, v3)) m3.processUniMultiReaction(v3) self.assertTrue(m3.checkTypeThreeError(adp, atp, v2)) self.assertTrue(m3.checkTypeThreeError(atp, adp, v2)) def testReduceReaction(self): if IGNORE_TEST: return m4 = MESGraph(self.simple4) atpase = m4.simple.getReaction(ATPASE) lower = m4.simple.getReaction(LOWER) self.assertFalse(m4.reduceReaction(atpase)) m4.processUniUniReaction(atpase) reduced_reaction = m4.reduceReaction(lower) self.assertEqual(type(reduced_reaction), Reaction) self.assertEqual(len(reduced_reaction.reactants), 1) self.assertEqual(reduced_reaction.products, []) self.assertEqual(reduced_reaction.reactants[0].molecule.name, FRU16P2) def testProcessMultiMultiReactions(self): if IGNORE_TEST: return # type III error m3 = MESGraph(self.simple3) v1 = self.simple3.getReaction(V1) v2 = self.simple3.getReaction(V2) v3 = self.simple3.getReaction(V3) m3.processUniUniReaction(v1) m3.processUniMultiReaction(v3) self.assertEqual(m3.type_three_errors, []) self.assertTrue(m3.processMultiMultiReaction(v2)) self.assertEqual(len(m3.type_three_errors), 1) # type IV error m4 = MESGraph(self.simple4) atpase = m4.simple.getReaction(ATPASE) lower = m4.simple.getReaction(LOWER) m4.processUniUniReaction(atpase) self.assertEqual(m4.type_four_errors, []) self.assertTrue(m4.processMultiMultiReaction(lower)) self.assertEqual(len(m4.type_four_errors), 1) # no error m6 = MESGraph(self.simple6) r5 = m6.simple.getReaction(R5) r12 = m6.simple.getReaction(R12) m6.processUniUniReaction(r12) ac = m6.getNode(self.simple6.getMolecule(AC)) acp = m6.getNode(self.simple6.getMolecule(ACP)) self.assertFalse(ac==acp) self.assertTrue(m6.processMultiMultiReaction(r5)) ac = m6.getNode(self.simple6.getMolecule(AC)) acp = m6.getNode(self.simple6.getMolecule(ACP)) self.assertTrue(ac==acp) def testAddArc(self): if IGNORE_TEST: return source = [self.mesgraph.getNode(self.simple.getMolecule(FRU)), self.mesgraph.getNode(self.simple.getMolecule(GLY))] destination = [self.mesgraph.getNode(self.simple.getMolecule(E2))] dummy_reaction = self.simple.reactions[INEQUAL2] self.mesgraph.addArc(source[0], destination[0], dummy_reaction) self.mesgraph.addArc(source[1], destination[0], dummy_reaction) arc1 = [source[0], destination[0]] arc2 = [source[1], destination[0]] self.assertTrue(self.mesgraph.has_edge(arc1[0], arc1[1])) self.assertTrue(self.mesgraph.has_edge(arc2[0], arc2[1])) reaction_label1 = self.mesgraph.get_edge_data(arc1[0], arc1[1])[cn.REACTION][0] reaction_label2 = self.mesgraph.get_edge_data(arc2[0], arc1[1])[cn.REACTION][0] self.assertEqual(reaction_label1, dummy_reaction.label) self.assertEqual(reaction_label1, reaction_label2) def testGetSOMPath(self): if IGNORE_TEST: return uniuni_reaction = self.simple.reactions[UNIUNI0] self.mesgraph.processUniUniReaction(uniuni_reaction) dfg = self.simple.getMolecule(DFG) e1 = self.simple.getMolecule(E1) som = self.mesgraph.getNode(dfg) som_path = self.mesgraph.getSOMPath(som, e1, dfg) self.assertEqual(type(som_path[0]), cn.PathComponents) self.assertEqual(som_path[0].reactions, [uniuni_reaction.label]) self.assertEqual(len(som_path), 1) def testPrintSOMPath(self): if IGNORE_TEST: return uniuni_reaction = self.simple.reactions[UNIUNI0] self.mesgraph.processUniUniReaction(uniuni_reaction) self.assertTrue(type(self.mesgraph.printSOMPath(DFG, E1))==str) self.assertFalse(self.mesgraph.printSOMPath(GLY, MEL)) def testCheckTypeOneError(self): if IGNORE_TEST: return uniuni_reaction1 = self.simple.reactions[UNIUNI1] uniuni_reaction2 = self.simple.reactions[UNIUNI2] inequality_reaction1 = self.simple.reactions[INEQUAL1] inequality_reaction2 = self.simple.reactions[INEQUAL2] self.mesgraph.processUniUniReaction(uniuni_reaction1) self.mesgraph.processUniUniReaction(uniuni_reaction2) aa = self.simple.getMolecule(AA) cn = self.simple.getMolecule(CN) mg = self.simple.getMolecule(MG) self.assertTrue(self.mesgraph.checkTypeOneError((aa, cn), inequality_reaction1)) self.assertFalse(self.mesgraph.checkTypeOneError((mg, aa), inequality_reaction2)) self.assertTrue(len(self.mesgraph.type_one_errors)>0) self.assertFalse(len(self.mesgraph.type_two_errors)>0) def testCheckTypeTwoError(self): if IGNORE_TEST: return mesgraph2 = MESGraph(self.simple2) mesgraph2.processUniUniReaction(self.simple2.getReaction(REACTION1)) mesgraph2.processMultiUniReaction(self.simple2.getReaction(REACTION2)) mesgraph2.processMultiUniReaction(self.simple2.getReaction(REACTION3)) self.assertTrue(mesgraph2.checkTypeTwoError()) self.assertFalse(len(mesgraph2.type_one_errors)>0) self.assertTrue(len(mesgraph2.type_two_errors)>0) def testAnalyze(self): if IGNORE_TEST: return mesgraph1 = MESGraph(self.simple) mesgraph1.analyze(self.simple.reactions) self.assertEqual(len(mesgraph1.nodes), FINAL_NODES) self.assertEqual(len(mesgraph1.edges), FINAL_EDGES) self.assertTrue(len(mesgraph1.type_one_errors)>0) self.assertFalse(len(mesgraph1.type_two_errors)>0) # mesgraph2 = MESGraph(self.simple2) mesgraph2.analyze(self.simple2.reactions) self.assertTrue(len(mesgraph2.type_one_errors)>0) self.assertTrue(len(mesgraph2.type_two_errors)>0) # mesgraph3 = MESGraph(self.simple3) mesgraph3.analyze(self.simple3.reactions) self.assertTrue(len(mesgraph3.type_three_errors)>0) # mesgraph4 = MESGraph(self.simple4) mesgraph4.analyze(self.simple4.reactions) self.assertTrue(len(mesgraph4.type_four_errors)>0) # # mesgraph5 = MESGraph(self.simple5) # mesgraph5.analyze(self.simple5.reactions) # dih = mesgraph5.getNode(self.simple5.getMolecule(DIH)) # din = mesgraph5.getNode(self.simple5.getMolecule(DIN)) # self.assertTrue(mesgraph5.has_edge(dih, din)) # self.assertTrue(mesgraph5.has_edge(din, dih)) # self.assertEqual(len(mesgraph5.type_five_errors), 1) # mesgraph6 = MESGraph(self.simple6) mesgraph6.analyze(self.simple6.reactions) total_errors = len(mesgraph6.type_one_errors) + \ len(mesgraph6.type_two_errors) + \ len(mesgraph6.type_three_errors) + \ len(mesgraph6.type_four_errors) +\ len(mesgraph6.type_five_errors) self.assertTrue(total_errors==0)
class TestGAMESReport(unittest.TestCase): def setUp(self): self.simple1 = SimpleSBML() self.simple2 = SimpleSBML() self.simple3 = SimpleSBML() self.simple4 = SimpleSBML() # BIOMD0000000248 - canceling_error self.simple1.initialize(cn.TEST_FILE_GAMESREPORT1) # BIOMD0000000007 - Type I error self.simple2.initialize(cn.TEST_FILE_GAMESREPORT2) # BIOMD0000000018 - Type II error self.simple3.initialize(cn.TEST_FILE_GAMES_PP2) # BIOMD0000000167 - Echelon, Type III error self.simple4.initialize(cn.TEST_FILE_GAMESREPORT3) def testReportCancelingError(self): if IGNORE_TEST: return m = GAMES_PP(self.simple1) m.analyze(error_details=False) gr = GAMESReport(m) report, error_num = gr.reportCancelingError(m.canceling_errors, explain_details=True) extended_report = NULL_STR extended_report = extended_report + "We detected a mass imbalance\n" extended_report = extended_report + ": OxidativePhosphorylation: CTtis -> \n\n" extended_report = extended_report + "from the following reaction isolation set:\n\n" extended_report = extended_report + "1. OxidativePhosphorylation: 6.00 ADP + CTtis -> 6.00 ATP\n" extended_report = extended_report + "2. ATPase: ATP -> ADP\n" extended_report = extended_report + "*ATP and ADP have the same mass according to the above reaction\n" extended_report = extended_report + "\n%s%s\n" % (PARAGRAPH_DIVIDER, PARAGRAPH_DIVIDER) extended_report = extended_report + "\n%s\n" % REPORT_DIVIDER self.assertEqual(extended_report, report) self.assertEqual(error_num, [2]) def testGetMoleculeEqualityPath(self): if IGNORE_TEST: return m = GAMES_PP(self.simple2) m.analyze(error_details=False) gr = GAMESReport(m) som = m.getNode(self.simple2.getMolecule(G2K)) equality_path = gr.getMoleculeEqualityPath(som, G2K, PG2R) self.assertTrue(len(equality_path) == 2) self.assertEqual(type(equality_path[0]), cn.PathComponents) self.assertEqual(equality_path[0].node1, G2K) self.assertEqual(equality_path[0].reactions, [CDC2PHOS]) self.assertEqual(equality_path[1].node2, PG2R) self.assertEqual(equality_path[1].reactions, [RUM1DEGINPG2R]) def testGetMoleculeEqualityPathReport(self): if IGNORE_TEST: return m = GAMES_PP(self.simple2) m.analyze(error_details=False) gr = GAMESReport(m) count, report1 = gr.getMoleculeEqualityPathReport( G2K, PG2R, 0, explain_details=False) self.assertEqual(count, 2) self.assertEqual( report1, "1. Cdc2Phos: G2K -> PG2\n2. Rum1DegInPG2R: PG2R -> PG2\n") count, report2 = gr.getMoleculeEqualityPathReport(G2K, PG2R, 0, explain_details=True) self.assertEqual(count, 2) self.assertEqual( report2, "\nG2K = PG2 by reaction(s):\n1. Cdc2Phos: G2K -> PG2\n\nPG2 = PG2R by reaction(s):\n2. Rum1DegInPG2R: PG2R -> PG2\n" ) def testGetMoleculeInequalityPathReport(self): if IGNORE_TEST: return m = GAMES_PP(self.simple2) m.analyze(error_details=False) gr = GAMESReport(m) count, report1 = gr.getMoleculeInequalityPathReport( G2K, PG2R, ["G2R_Creation"], 0, explain_details=False) self.assertEqual(count, 1) self.assertEqual(report1, "1. G2R_Creation: G2K + R -> G2R\n") count, report2 = gr.getMoleculeInequalityPathReport( G2K, PG2R, ["G2R_Creation"], 0, explain_details=True) self.assertEqual(count, 1) self.assertEqual( report2, "G2K < PG2R by reaction(s):\n1. G2R_Creation: G2K + R -> G2R\n") def testReportTypeOneError(self): if IGNORE_TEST: return m = GAMES_PP(self.simple2) m.analyze(error_details=False) gr = GAMESReport(m) error = [ cn.PathComponents(node1=G2K, node2=G2R, reactions=[G2R_CREATION]) ] report, error_num = gr.reportTypeOneError(error, explain_details=True) self.assertEqual(error_num, [2]) extended_report = NULL_STR extended_report = extended_report + "\nG2K = G2R by reaction(s):\n1. Rum1DegInG2R: G2R -> G2K\n\n" extended_report = extended_report + "However, G2K < G2R by reaction(s):\n2. G2R_Creation: G2K + R -> G2R\n\n" extended_report = extended_report + "\n----------------------------------------------------------------------\n\n" extended_report = extended_report + "\n\n**********************************************************************\n\n" self.assertEqual(report, extended_report) def testReportTypeTwoError(self): if IGNORE_TEST: return m = GAMES_PP(self.simple3) m.analyze(error_details=False) gr = GAMESReport(m) som1 = m.getNode(self.simple3.getMolecule(CH3FH4)) som2 = m.getNode(self.simple3.getMolecule(FH4)) error = [[som1, som2]] report, error_num = gr.reportTypeTwoError(error, explain_details=True) self.assertEqual(error_num, [5]) LOC_START = 241 extended_report = NULL_STR extended_report = extended_report + "{CH3FH4} < {CH2FH4=FFH2=FH2f=FH4} < {CH3FH4}\n\n" extended_report = extended_report + "This indicates a mass conflict between reactions.\n" extended_report = extended_report + "%s%s\n" % (PARAGRAPH_DIVIDER, PARAGRAPH_DIVIDER) self.assertEqual(report[-LOC_START:], extended_report) def testConvertOperationSeriesToReactionOperations(self): if IGNORE_TEST: return m = GAMES_PP(self.simple4) m.analyze(error_details=False) gr = GAMESReport(m) op = pd.Series([1.0, 0.5, 0.0], index=[ STATPHOSPHORYLATION, PSTATDIMERISATION, PSTATDIMERISATIONNUC ]) ro = gr.convertOperationSeriesToReactionOperations(op) self.assertEqual(len(ro), 2) self.assertEqual(ro[0].reaction, STATPHOSPHORYLATION) self.assertEqual(ro[0].operation, 1.0) self.assertEqual(ro[1].reaction, PSTATDIMERISATION) self.assertEqual(ro[1].operation, 0.5) def testGetOperationMatrix(self): if IGNORE_TEST: return m1 = GAMES_PP(self.simple1) m1.analyze(error_details=False) gr1 = GAMESReport(m1) self.assertTrue(gr1.getOperationMatrix() is None) m4 = GAMES_PP(self.simple4) m4.analyze(error_details=False) gr4 = GAMESReport(m4) op_mat = gr4.getOperationMatrix() self.assertEqual(op_mat.loc[STATPHOSPHORYLATION, STATPHOSPHORYLATION], 1.0) self.assertEqual(op_mat.loc[PSTATDIMERISATION, PSTATDIMERISATION], 1.0) self.assertEqual( op_mat.loc[PSTATDIMERISATIONNUC, PSTATDIMERISATIONNUC], 1.0) self.assertEqual(op_mat.loc[PSTATDIMERISATIONNUC, STATPHOSPHORYLATION], 0.0) self.assertEqual(op_mat.loc[STATPHOSPHORYLATION, PSTATDIMERISATIONNUC], -0.5) def testGetResultingSeries(self): if IGNORE_TEST: return m = GAMES_PP(self.simple4) m.analyze(error_details=False) gr = GAMESReport(m) resulting_series = gr.getResultingSeries(STATPHOSPHORYLATION) print(resulting_series) self.assertEqual(resulting_series["{" + SPECIES_TEST + "}"], 1.0) self.assertEqual(resulting_series["{" + PSTAT_SOL + "}"], 0.0) self.assertEqual( resulting_series[m.getNode( m.simple.getMolecule(PSTATDIMER_NUC)).identifier], 0.0) self.assertEqual( resulting_series[m.getNode( m.simple.getMolecule(PSTAT_NUC)).identifier], 0.0) def testGetOperationStoichiometryMatrix(self): if IGNORE_TEST: return m = GAMES_PP(self.simple4) m.analyze(error_details=False) gr = GAMESReport(m) op = pd.Series([1.0, 0.5, 0.0], index=[ STATPHOSPHORYLATION, PSTATDIMERISATION, PSTATDIMERISATIONNUC ]) ro = gr.convertOperationSeriesToReactionOperations(op) osm = gr.getOperationStoichiometryMatrix(ro) self.assertEqual(osm.loc[SPECIES_TEST, STATPHOSPHORYLATION], 1.0) self.assertEqual(osm.loc[SPECIES_TEST, PSTATDIMERISATION], 0.0) self.assertEqual(osm.loc[PSTAT_SOL, STATPHOSPHORYLATION], 1.0) self.assertEqual(osm.loc[PSTAT_SOL, PSTATDIMERISATION], -2.0) def testGeInferredReaction(self): if IGNORE_TEST: return m = GAMES_PP(self.simple4) m.analyze(error_details=False) gr = GAMESReport(m) op = pd.Series([1.0, 0.5, 0.0], index=[ STATPHOSPHORYLATION, PSTATDIMERISATION, PSTATDIMERISATIONNUC ]) ro = gr.convertOperationSeriesToReactionOperations(op) inferred_reaction = gr.getInferredReaction(ro) self.assertEqual(len(inferred_reaction.reactants), 1) self.assertEqual(len(inferred_reaction.products), 2) self.assertEqual(inferred_reaction.reactants[0].molecule.name, STAT_SOL) self.assertTrue(inferred_reaction.products[0].molecule.name in {PSTATDIMER_SOL, SPECIES_TEST}) self.assertTrue(inferred_reaction.products[1].molecule.name in {PSTATDIMER_SOL, SPECIES_TEST}) self.assertEqual(inferred_reaction.reactants[0].stoichiometry, 1.0) self.assertEqual({p.stoichiometry for p in inferred_reaction.products}, {0.5, 1.0}) def testReportReactionsInSOM(self): if IGNORE_TEST: return m = GAMES_PP(self.simple4) m.analyze(error_details=False) gr = GAMESReport(m) som = m.getNode(m.simple.getMolecule(PSTATDIMER_NUC)) report, error_num = gr.reportReactionsInSOM(som, 0) common_part = "1. PstatDimer__import: PstatDimer_sol -> PstatDimer_nuc\n" self.assertEqual(error_num, 1) self.assertTrue(report == common_part) def testReportEchelonError(self): if IGNORE_TEST: return m = GAMES_PP(self.simple4) m.analyze(error_details=False) gr = GAMESReport(m) report, error_num = gr.reportEchelonError(m.echelon_errors, explain_details=True) self.assertEqual(error_num, [3]) extended_report = NULL_STR extended_report = extended_report + "will result in empty reactant with zero mass:\n\n: -> {species_test}\n\n" extended_report = extended_report + "\n----------------------------------------------------------------------\n" extended_report = extended_report + "\n----------------------------------------------------------------------\n\n" extended_report = extended_report + "\n\n**********************************************************************\n\n" self.assertEqual(report[-288:], extended_report) def testReportTypeThreeError(self): if IGNORE_TEST: return m = GAMES_PP(self.simple4) m.analyze(error_details=False) gr = GAMESReport(m) report, error_num = gr.reportTypeThreeError(m.type_three_errors, explain_details=True) self.assertEqual(error_num, [3]) pseudo_inequality_report = NULL_STR pseudo_inequality_report = pseudo_inequality_report + "6. statPhosphorylation: stat_sol -> Pstat_sol + species_test\n" pseudo_inequality_report = pseudo_inequality_report + "(pseudo 6.) statPhosphorylation: {Pstat_nuc=stat_nuc=stat_sol} -> " pseudo_inequality_report1 = pseudo_inequality_report + "{species_test} + {Pstat_sol}" pseudo_inequality_report2 = pseudo_inequality_report + "{Pstat_sol} + {species_test}" inference_report1 = "the masses of {Pstat_sol} and {Pstat_nuc=stat_nuc=stat_sol} are unequal." inference_report2 = "the masses of {Pstat_nuc=stat_nuc=stat_sol} and {Pstat_sol} are unequal." self.assertTrue(report[-460:-305] == pseudo_inequality_report1 or report[-460:-305] == pseudo_inequality_report2) self.assertTrue(report[-293:-221] == inference_report1 or report[-293:-221] == inference_report2)