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))