def testSortedTables(self):
test1 = TicDatFactory(table3=[["PK3", "FK1", "FK2"], ["Val D"]],
table2=[["PK2"], ["Val A", "Val B"]],
table1=[["PK1"], ["Val C"]])
test1.add_foreign_key("table3", "table1", ["FK1", "PK1"])
test1.add_foreign_key("table3", "table2", ["FK2", "PK2"])
self.assertTrue(tlingo._sorted_tables(test1)[-1] == 'table3')
def testSix(self):
tdf = TicDatFactory(plants = [["name"], ["stuff", "otherstuff"]],
lines = [["name"], ["plant", "weird stuff"]],
line_descriptor = [["name"], ["booger"]],
products = [["name"],["gover"]],
production = [["line", "product"], ["min", "max"]],
pureTestingTable = [[], ["line", "plant", "product", "something"]],
extraProduction = [["line", "product"], ["extramin", "extramax"]],
weirdProduction = [["line1", "line2", "product"], ["weirdmin", "weirdmax"]])
tdf.add_foreign_key("production", "lines", ("line", "name"))
tdf.add_foreign_key("production", "products", ("product", "name"))
tdf.add_foreign_key("lines", "plants", ("plant", "name"))
tdf.add_foreign_key("line_descriptor", "lines", ("name", "name"))
for f in set(tdf.data_fields["pureTestingTable"]).difference({"something"}):
tdf.add_foreign_key("pureTestingTable", "%ss"%f, (f,"name"))
tdf.add_foreign_key("extraProduction", "production", (("line", "line"), ("product","product")))
tdf.add_foreign_key("weirdProduction", "production", (("line1", "line"), ("product","product")))
tdf.add_foreign_key("weirdProduction", "extraProduction", (("line2","line"), ("product","product")))
goodDat = tdf.TicDat()
goodDat.plants["Cleveland"] = ["this", "that"]
goodDat.plants["Newark"]["otherstuff"] =1
goodDat.products["widgets"] = goodDat.products["gadgets"] = "shizzle"
for i,p in enumerate(goodDat.plants):
goodDat.lines[i]["plant"] = p
for i,(pl, pd) in enumerate(itertools.product(goodDat.lines, goodDat.products)):
goodDat.production[pl, pd] = {"min":1, "max":10+i}
badDat1 = tdf.copy_tic_dat(goodDat)
badDat1.production["notaline", "widgets"] = [0,1]
badDat2 = tdf.copy_tic_dat(badDat1)
fk, fkm = _ForeignKey, _ForeignKeyMapping
self.assertTrue(tdf.find_foreign_key_failures(badDat1) == tdf.find_foreign_key_failures(badDat2) ==
{fk('production', 'lines', fkm('line', 'name'), 'many-to-one'):
(('notaline',), (('notaline', 'widgets'),))})
badDat1.lines["notaline"]["plant"] = badDat2.lines["notaline"]["plant"] = "notnewark"
self.assertTrue(tdf.find_foreign_key_failures(badDat1) == tdf.find_foreign_key_failures(badDat2) ==
{fk('lines', 'plants', fkm('plant', 'name'), 'many-to-one'):
(('notnewark',), ('notaline',))})
tdf.remove_foreign_keys_failures(badDat1, propagate=False)
tdf.remove_foreign_keys_failures(badDat2, propagate=True)
self.assertTrue(tdf._same_data(badDat2, goodDat) and not tdf.find_foreign_key_failures(badDat2))
self.assertTrue(tdf.find_foreign_key_failures(badDat1) ==
{fk('production', 'lines', fkm('line', 'name'), 'many-to-one'):
(('notaline',), (('notaline', 'widgets'),))})
tdf.remove_foreign_keys_failures(badDat1, propagate=False)
self.assertTrue(tdf._same_data(badDat1, goodDat) and not tdf.find_foreign_key_failures(badDat1))
_ = len(goodDat.lines)
for i,p in enumerate(goodDat.plants.keys() + goodDat.plants.keys()):
goodDat.lines[i+_]["plant"] = p
for l in goodDat.lines:
if i%2:
goodDat.line_descriptor[l] = i+10
for i,(l,pl,pdct) in enumerate(sorted(itertools.product(goodDat.lines, goodDat.plants, goodDat.products))):
goodDat.pureTestingTable.append((l,pl,pdct,i))
self.assertFalse(tdf.find_foreign_key_failures(goodDat))
badDat = tdf.copy_tic_dat(goodDat)
badDat.pureTestingTable.append(("j", "u", "nk", "ay"))
l = len(goodDat.pureTestingTable)
self.assertTrue(tdf.find_foreign_key_failures(badDat) ==
{fk('pureTestingTable', 'plants', fkm('plant', 'name'), 'many-to-one'): (('u',),(l,)),
fk('pureTestingTable', 'products', fkm('product', 'name'), 'many-to-one'): (('nk',), (l,)),
fk('pureTestingTable', 'lines', fkm('line', 'name'), 'many-to-one'): (('j',), (l,))})
obfudat = tdf.obfusimplify(goodDat, freeze_it=True)
self.assertTrue(all(len(getattr(obfudat.copy, t)) == len(getattr(goodDat, t))
for t in tdf.all_tables))
for n in goodDat.plants.keys() + goodDat.lines.keys() + goodDat.products.keys() :
self.assertTrue(n in {_[1] for _ in obfudat.renamings.values()})
self.assertFalse(n in obfudat.renamings)
self.assertTrue(obfudat.copy.plants['P2']['otherstuff'] == 1)
self.assertFalse(tdf._same_data(obfudat.copy, goodDat))
for k,r in obfudat.copy.line_descriptor.items():
i = r.values()[0] - 10
self.assertTrue(i%2 and (goodDat.line_descriptor[i].values()[0] == i+10))
obfudat2 = tdf.obfusimplify(goodDat, {"plants": "P", "lines" : "L", "products" :"PR"})
self.assertTrue(tdf._same_data(obfudat.copy, obfudat2.copy))
obfudat3 = tdf.obfusimplify(goodDat, skip_tables=["plants", "lines", "products"])
self.assertTrue(tdf._same_data(obfudat3.copy, goodDat))
obfudat4 = tdf.obfusimplify(goodDat, skip_tables=["lines", "products"])
self.assertFalse(tdf._same_data(obfudat4.copy, goodDat))
self.assertFalse(tdf._same_data(obfudat4.copy, obfudat.copy))
def testFive(self):
tdf = TicDatFactory(**netflowSchema())
addNetflowForeignKeys(tdf)
dat = tdf.freeze_me(tdf.TicDat(**{t : getattr(netflowData(), t) for t in tdf.all_tables}))
obfudat = tdf.obfusimplify(dat, freeze_it=1)
self.assertFalse(tdf._same_data(dat, obfudat.copy))
for (s,d),r in obfudat.copy.arcs.items():
self.assertFalse((s,d) in dat.arcs)
self.assertTrue(dat.arcs[obfudat.renamings[s][1], obfudat.renamings[d][1]]["capacity"] == r["capacity"])
obfudat = tdf.obfusimplify(dat, freeze_it=1, skip_tables=["commodities", "nodes"])
self.assertTrue(tdf._same_data(obfudat.copy, dat))
tdf = TicDatFactory(**netflowSchema())
addNetflowForeignKeys(tdf)
mone, one2one = "many-to-one", "one-to-one"
fk, fkm = _ForeignKey, _ForeignKeyMapping
self.assertTrue(set(tdf.foreign_keys) == {fk("arcs", 'nodes', fkm('source',u'name'), mone),
fk("arcs", 'nodes', fkm('destination',u'name'), mone),
fk("cost", 'nodes', fkm('source',u'name'), mone),
fk("cost", 'nodes', fkm('destination',u'name'), mone),
fk("cost", 'commodities', fkm('commodity',u'name'), mone),
fk("inflow", 'commodities', fkm('commodity',u'name'), mone),
fk("inflow", 'nodes', fkm('node',u'name'), mone)})
tdf.clear_foreign_keys("cost")
self.assertTrue(set(tdf.foreign_keys) == {fk("arcs", 'nodes', fkm('source',u'name'), mone),
fk("arcs", 'nodes', fkm('destination',u'name'), mone),
fk("inflow", 'commodities', fkm('commodity',u'name'), mone),
fk("inflow", 'nodes', fkm('node',u'name'), mone)})
tdf = TicDatFactory(**dietSchema())
self.assertFalse(tdf.foreign_keys)
addDietForeignKeys(tdf)
self.assertTrue(set(tdf.foreign_keys) == {fk("nutritionQuantities", 'categories', fkm('category',u'name'), mone),
fk("nutritionQuantities", 'foods', fkm('food',u'name'), mone)})
tdf.TicDat()
self.assertTrue(self.firesException(lambda : tdf.clear_foreign_keys("nutritionQuantities")))
self.assertTrue(tdf.foreign_keys)
tdf = TicDatFactory(**dietSchema())
addDietForeignKeys(tdf)
tdf.clear_foreign_keys("nutritionQuantities")
self.assertFalse(tdf.foreign_keys)
tdf = TicDatFactory(parentTable = [["pk"],["pd1", "pd2", "pd3"]],
goodChild = [["gk"], ["gd1", "gd2"]],
badChild = [["bk1", "bk2"], ["bd"]],
appendageChild = [["ak"], ["ad1", "ad2"]],
appendageBadChild = [["bk1", "bk2"], []])
tdf.add_foreign_key("goodChild", "parentTable", fkm("gd1" , "pk"))
tdf.add_foreign_key("badChild", "parentTable", ["bk2" , "pk"])
self.assertTrue("many-to-many" in self.firesException(lambda :
tdf.add_foreign_key("badChild", "parentTable", ["bd", "pd2"])))
tdf.add_foreign_key("appendageChild", "parentTable", ["ak", "pk"])
tdf.add_foreign_key("appendageBadChild", "badChild", (("bk2", "bk2"), ("bk1","bk1")))
fks = tdf.foreign_keys
_getfk = lambda t : next(_ for _ in fks if _.native_table == t)
self.assertTrue(_getfk("goodChild").cardinality == "many-to-one")
self.assertTrue(_getfk("badChild").cardinality == "many-to-one")
self.assertTrue(_getfk("appendageChild").cardinality == "one-to-one")
self.assertTrue(_getfk("appendageBadChild").cardinality == "one-to-one")
tdf.clear_foreign_keys("appendageBadChild")
self.assertTrue(tdf.foreign_keys and "appendageBadChild" not in tdf.foreign_keys)
tdf.clear_foreign_keys()
self.assertFalse(tdf.foreign_keys)
def testDiet_runlingoRequired(self):
self.assertTrue(tlingo._can_run_lingo_run_tests)
diet_schema = {
"categories": (("Name", ), ["Min Nutrition", "Max Nutrition"]),
"foods": [["Name"], ("Cost", )],
"nutrition_quantities": (["Food", "Category"], ["Quantity"])
}
# Using foods as the table name to test the lingo_prepend functionality
in_tdf = TicDatFactory(**diet_schema)
in_tdf.lingo_prepend = "inp_"
solution_variables = TicDatFactory(foods=[["Food"], ["Quantity"]],
total_cost=[["Value"], []])
solution_variables.lingo_prepend = "out_" # avoid table name collisions
makeDat = lambda: in_tdf.TicDat(categories={
'calories': [1800, 2200],
'protein': [91, float("inf")],
'fat': [0, 65],
'sodium': [0, 1779]
},
foods={
'hamburger': 2.49,
'chicken': 2.89,
'hot dog': 1.50,
'fries': 1.89,
'macaroni': 2.09,
'pizza': 1.99,
'salad': 2.49,
'milk': 0.89,
'ice cream': 1.59
},
nutrition_quantities=
[('hamburger', 'calories', 410),
('hamburger', 'protein', 24),
('hamburger', 'fat', 26),
('hamburger', 'sodium', 730),
('chicken', 'calories', 420),
('chicken', 'protein', 32),
('chicken', 'fat', 10),
('chicken', 'sodium', 1190),
('hot dog', 'calories', 560),
('hot dog', 'protein', 20),
('hot dog', 'fat', 32),
('hot dog', 'sodium', 1800),
('fries', 'calories', 380),
('fries', 'protein', 4),
('fries', 'fat', 19),
('fries', 'sodium', 270),
('macaroni', 'calories', 320),
('macaroni', 'protein', 12),
('macaroni', 'fat', 10),
('macaroni', 'sodium', 930),
('pizza', 'calories', 320),
('pizza', 'protein', 15),
('pizza', 'fat', 12),
('pizza', 'sodium', 820),
('salad', 'calories', 320),
('salad', 'protein', 31),
('salad', 'fat', 12),
('salad', 'sodium', 1230),
('milk', 'calories', 100),
('milk', 'protein', 8),
('milk', 'fat', 2.5),
('milk', 'sodium', 125),
('ice cream', 'calories', 330),
('ice cream', 'protein', 8),
('ice cream', 'fat', 10),
('ice cream', 'sodium', 180)])
in_tdf.add_foreign_key("nutrition_quantities", "foods",
['Food', 'Name'])
in_tdf.add_foreign_key("nutrition_quantities", "categories",
['Category', 'Name'])
lingo_soln = tlingo.lingo_run(get_testing_file_path("sample_diet.lng"),
in_tdf, makeDat(), solution_variables)
self.assertTrue(
nearlySame(lingo_soln.foods["hamburger"]["Quantity"],
0.6045,
epsilon=0.0001))
self.assertIsNotNone(lingo_soln.total_cost["11.82886"])
# lingo_run should not complete when there is an infeasible solution
dat = makeDat()
dat.categories["calories"][
"Min Nutrition"] = dat.categories["calories"]["Max Nutrition"] + 1
try:
lingo_soln = tlingo.lingo_run(
get_testing_file_path("sample_diet.lng"), in_tdf, dat,
solution_variables)
self.assertTrue(False)
except:
self.assertTrue(True)
def testNetflow_runlingoRequired(self):
self.assertTrue(tlingo._can_run_lingo_run_tests)
in_tdf = TicDatFactory(**netflowSchema())
in_tdf.add_foreign_key("arcs", "nodes", ['source', 'name'])
in_tdf.add_foreign_key("arcs", "nodes", ['destination', 'name'])
in_tdf.add_foreign_key("cost", "nodes", ['source', 'name'])
in_tdf.add_foreign_key("cost", "nodes", ['destination', 'name'])
in_tdf.add_foreign_key("cost", "commodities", ['commodity', 'name'])
in_tdf.add_foreign_key("inflow", "commodities", ['commodity', 'name'])
in_tdf.add_foreign_key("inflow", "nodes", ['node', 'name'])
solution_variables = TicDatFactory(
flow=[["Commodity", "Source", "Destination"], ["quantity"]])
dat = in_tdf.TicDat(
**
{t: getattr(netflowData(), t)
for t in in_tdf.primary_key_fields})
lingo_soln = tlingo.lingo_run(
get_testing_file_path("sample_netflow.lng"), in_tdf, dat,
solution_variables)
self.assertTrue(
nearlySame(
lingo_soln.flow["Pens", "Detroit", "New York"]["quantity"],
30))
