def testThree(self): objOrig = netflowData() staticFactory = TicDatFactory(**netflowSchema()) goodTable = lambda t : lambda _t : staticFactory.good_tic_dat_table(_t, t) tables = set(staticFactory.primary_key_fields) ticDat = staticFactory.freeze_me(staticFactory.TicDat(**{t:getattr(objOrig,t) for t in tables})) self.assertTrue(staticFactory.good_tic_dat_object(ticDat)) for t in tables : self._assertSame(getattr(objOrig, t), getattr(ticDat,t), goodTable(t)) objOrig.commodities.append(12.3) objOrig.arcs[(1, 2)] = [12] self._assertSame(objOrig.nodes, ticDat.nodes, goodTable("nodes")) self._assertSame(objOrig.cost, ticDat.cost, goodTable("cost")) self.assertTrue(firesException(lambda : self._assertSame( objOrig.commodities, ticDat.commodities, goodTable("commodities")) )) self.assertTrue(firesException(lambda : self._assertSame( objOrig.arcs, ticDat.arcs, goodTable("arcs")) )) ticDat = staticFactory.freeze_me(staticFactory.TicDat(**{t:getattr(objOrig,t) for t in tables})) for t in tables : self._assertSame(getattr(objOrig, t), getattr(ticDat,t), goodTable(t)) self.assertTrue(ticDat.arcs[1, 2]["capacity"] == 12) self.assertTrue(12.3 in ticDat.commodities) objOrig.cost[5]=5 self.assertTrue("cost cannot be treated as a ticDat table : Inconsistent key lengths" in firesException(lambda : staticFactory.freeze_me(staticFactory.TicDat (**{t:getattr(objOrig,t) for t in tables})))) objOrig = netflowData() def editMeBadly(t) : def rtn() : t.cost["hack"] = 12 return rtn def editMeWell(t) : def rtn() : t.cost["hack", "my", "balls"] = 12.12 return rtn self.assertTrue(all(firesException(editMeWell(t)) and firesException(editMeBadly(t)) for t in (ticDat, staticFactory.freeze_me(staticFactory.TicDat())))) def attributeMe(t) : def rtn() : t.boger="bogerwoger" return rtn self.assertTrue(firesException(attributeMe(ticDat)) and firesException(attributeMe( staticFactory.freeze_me(staticFactory.TicDat())))) mutable = staticFactory.TicDat(**{t:getattr(objOrig,t) for t in tables}) for t in tables : self._assertSame(getattr(objOrig, t), getattr(mutable,t), goodTable(t)) self.assertTrue(firesException(editMeBadly(mutable))) self.assertFalse(firesException(editMeWell(mutable)) or firesException(attributeMe(mutable))) self.assertTrue(firesException(lambda : self._assertSame( objOrig.cost, mutable.cost, goodTable("cost")) ))
def testFour(self): objOrig = sillyMeData() staticFactory = TicDatFactory(**sillyMeSchema()) goodTable = lambda t : lambda _t : staticFactory.good_tic_dat_table(_t, t) tables = set(staticFactory.primary_key_fields) ticDat = staticFactory.freeze_me(staticFactory.TicDat(**objOrig)) self.assertTrue(staticFactory.good_tic_dat_object(ticDat)) for t in tables : self._assertSame(objOrig[t], getattr(ticDat,t), goodTable(t)) pickedData = staticFactory.TicDat(**staticFactory.as_dict(ticDat)) self.assertTrue(staticFactory._same_data(ticDat, pickedData)) mutTicDat = staticFactory.TicDat() for k,v in ticDat.a.items() : mutTicDat.a[k] = v.values() for k,v in ticDat.b.items() : mutTicDat.b[k] = v.values()[0] for r in ticDat.c: mutTicDat.c.append(r) for t in tables : self._assertSame(getattr(mutTicDat, t), getattr(ticDat,t), goodTable(t)) self.assertTrue("theboger" not in mutTicDat.a) mutTicDat.a["theboger"]["aData2"] =22 self.assertTrue("theboger" in mutTicDat.a and mutTicDat.a["theboger"].values() == (0, 22, 0)) newSchema = sillyMeSchema() newSchema["a"][1] += ("aData4",) newFactory = TicDatFactory(**newSchema) def makeNewTicDat() : return newFactory.TicDat(a=ticDat.a, b=ticDat.b, c=ticDat.c) newTicDat = makeNewTicDat() self.assertFalse(staticFactory.good_tic_dat_object(newTicDat)) self.assertTrue(newFactory.good_tic_dat_object(ticDat)) self.assertTrue(newFactory._same_data(makeNewTicDat(), newTicDat)) newTicDat.a[ticDat.a.keys()[0]]["aData4"]=12 self.assertFalse(newFactory._same_data(makeNewTicDat(), newTicDat))
def testTwo(self): objOrig = dietData() staticFactory = TicDatFactory(**dietSchema()) tables = set(staticFactory.primary_key_fields) ticDat = staticFactory.freeze_me(staticFactory.TicDat(**{t:getattr(objOrig,t) for t in tables})) self.assertTrue(staticFactory.good_tic_dat_object(ticDat)) for t in tables : self._assertSame(getattr(objOrig, t), getattr(ticDat,t), lambda _t : staticFactory.good_tic_dat_table(_t, t))
def testOne(self): def _cleanIt(x) : x.foods['macaroni'] = {"cost": 2.09} x.foods['milk'] = {"cost":0.89} return x dataObj = dietData() tdf = TicDatFactory(**dietSchema()) self.assertTrue(tdf.good_tic_dat_object(dataObj)) dataObj2 = tdf.copy_tic_dat(dataObj) dataObj3 = tdf.copy_tic_dat(dataObj, freeze_it=True) dataObj4 = tdf.TicDat(**tdf.as_dict(dataObj3)) self.assertTrue(all (tdf._same_data(dataObj, x) and dataObj is not x for x in (dataObj2, dataObj3, dataObj4))) dataObj = _cleanIt(dataObj) self.assertTrue(tdf.good_tic_dat_object(dataObj)) self.assertTrue(all (tdf._same_data(dataObj, x) and dataObj is not x for x in (dataObj2, dataObj3))) def hackit(x) : x.foods["macaroni"] = 100 self.assertTrue(self.firesException(lambda :hackit(dataObj3))) hackit(dataObj2) self.assertTrue(not tdf._same_data(dataObj, dataObj2) and tdf._same_data(dataObj, dataObj3)) msg = [] dataObj.foods[("milk", "cookies")] = {"cost": float("inf")} dataObj.boger = object() self.assertFalse(tdf.good_tic_dat_object(dataObj) or tdf.good_tic_dat_object(dataObj, bad_message_handler =msg.append)) self.assertTrue({"foods : Inconsistent key lengths"} == set(msg)) self.assertTrue(all(tdf.good_tic_dat_table(getattr(dataObj, t), t) for t in ("categories", "nutritionQuantities"))) dataObj = dietData() dataObj.categories["boger"] = {"cost":1} dataObj.categories["boger"] = {"cost":1} self.assertFalse(tdf.good_tic_dat_object(dataObj) or tdf.good_tic_dat_object(dataObj, bad_message_handler=msg.append)) self.assertTrue({'foods : Inconsistent key lengths', 'categories : Inconsistent data field name keys.'} == set(msg)) ex = firesException(lambda : tdf.freeze_me(tdf.TicDat(**{t:getattr(dataObj,t) for t in tdf.primary_key_fields}))).message self.assertTrue("categories cannot be treated as a ticDat table : Inconsistent data field name keys" in ex)