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)
