def test_get_shema(s, c, v): table = Table(s) table.add_columns([c]) table.columns[c].add_value(v) schema = table.get_schema() assert c in schema and schema[c]["id"] == c and "count" in schema[ c] and schema[c]["count"] == 1
def __init__(self,data): self.name = data['name'] self.dataCount = data['data-count'] self.tables = [] for tbl in data['data-defns']: tblObj = Table(tbl) tblObj.setParent(self) self.tables.append(tblObj)
def test_clone(s, c, v, e): table1 = Table(s) table1.add_columns([c]) table1.columns[c].add_value(v, e) schema1 = table1.get_schema() table2 = table1.clone() schema2 = table2.get_schema() assert schema1 == schema2
def __init__(self, id, variable, dependencies): """ variable - dictionary containing the variable name to its possible values dependencies - dictionary containing the dependencies to its possible values """ self.id = id self.varName = list(variable.keys())[0] self.table = Table(variable, dependencies)
def test_get_row(s, c, list, index): table = Table(s) table.add_columns([c]) for v in list: table.columns[c].add_value(v) row = table.get_row(index) has_row = (index < len(table.columns[c].values) and row and (c in row) and len(row) == 1) empty_table = len(table.columns[c].values) == 0 inValid_index = len(table.columns[c].values) <= index assert has_row or empty_table or inValid_index
def test_join(s, c, v0, e0, v1, e1): table1 = Table(s) table1.add_columns([c]) table1.columns[c].add_value(v0, e0) table2 = Table(s) table2.add_columns([c]) table2.columns[c].add_value(v1, e1) jtable = table1.join(table2) assert len(jtable.columns[c].values) == 2
def test_clone(s, c, v): table1 = Table(s) table1.add_columns([c]) table1.columns[c].add_value(v) schema1 = table1.get_schema() table2 = table1.clone() schema2 = table2.get_schema() assert schema1 == schema2
def test_apply_filter(s, c, list, min_value, max_value): table = Table(s) table.add_columns([c]) for v in list: table.columns[c].add_value(v) filter = dict() filter["table"] = s filter["column"] = c filter["from"] = min_value filter["to"] = max_value filtered_table = table.apply_filter(filter) schema = filtered_table.get_schema() column_in_schema = c in schema column_has_values_inside_range = (schema[c]["count"] > 0 and schema[c]["min_value"] >= min_value and schema[c]["max_value"] <= max_value) column_is_empty = (schema[c]["count"] == 0) wrong_filter_range = min_value > max_value assert column_in_schema and (column_has_values_inside_range or column_is_empty or wrong_filter_range)
def test_add_row(s, c, v): table = Table(s) table.add_columns([c]) row = dict() row[c] = v table.add_row(row) assert len(table.columns[c].values) == 1
def get_table(emitter=print): """Get an instance of Table""" heroes = [ hero_factory.hero('benji', 'barbarian'), hero_factory.hero('austin', 'healer'), ] # Draws the hero's initial hand for _ in range(0, 5): for hero in heroes: hero.draw_card() # Deal boss mat and door deck boss = doorcard_factory.create_boss() doordeck = doorcard_factory.deal_deck(boss.num_door_cards, len(heroes), boss) game = GameState(doordeck, heroes, logging=mylog) return Table(game, emitter, mylog)
def get_empty_gti_table(): table = Table("GTI") table.add_columns(["START", "STOP", "START_EVENT_IDX", "END_EVENT_IDX"]) return table
def test_add_columns(s, c): table = Table(s) table.add_columns([c]) assert len(table.columns) == 1
def setUp(self): self.logger = logging.getLogger() self.dataFile = Datafile("test.model.items.xml", self.id()) self.table = Table(self.logger, self.dataFile.getFilename(), "ArtShowItems", "Item", ItemField.ALL_PERSISTENT)
class TestTable(unittest.TestCase): def setUpClass(): logging.basicConfig(level=logging.DEBUG) def setUp(self): self.logger = logging.getLogger() self.dataFile = Datafile("test.model.items.xml", self.id()) self.table = Table(self.logger, self.dataFile.getFilename(), "ArtShowItems", "Item", ItemField.ALL_PERSISTENT) def tearDown(self): self.dataFile.clear() del self.table def test_loadSave(self): self.assertTrue(self.table.load()) self.table.save(True) self.assertTrue(self.table.load()) def test_select(self): self.assertTrue(self.table.load()) # Select exactly one row with a mandatory column that is not available rows = self.table.select(["Code", "Title", "Note"], 'Code == "A2"') self.assertEqual(1, len(rows)) self.assertDictEqual({"Title": "Cougar", "Code": "A2", "Note": None}, rows[0]) self.assertFalse(self.table.changed(), "Table.Select: Run SELECT but the table is marked as changed") # Select all rows rows = self.table.select(["Code", "Author"]) self.assertTrue( len(rows) == self.table.len() and len(rows[0]) == 2, "Table.Select: Expected all rows with columns {Code, Author} but received %(row)s" % {"row": str(rows)}, ) self.assertFalse(self.table.changed(), "Table.Select: Run SELECT but the table is marked as changed") def test_update(self): self.assertTrue(self.table.load()) # Update row row = self.table.select(["Code", "Title"], 'Code == "A2"')[0] numUpdated = self.table.update({"Title": "ragouC"}, 'Code == "AXXX"') self.assertEqual( numUpdated, 0, "Table.Update: Updating a row (%(numUpdated)d) even though the row does not exist" % {"numUpdated": numUpdated}, ) self.assertFalse(self.table.changed(), "Table.Update: Running UPDATE failed but the table is marked as changed") numUpdated = self.table.update({"Title": "ragouC"}, 'Code == "A2"') rowUpdated = self.table.select(["Author", "Title"], 'Code == "A2"')[0] self.assertTrue( numUpdated == 1 and row["Title"] == "Cougar" and rowUpdated["Title"] == "ragouC", "Table.Update: Updated row but the selecting the row returned %(row)s" % {"row": str(rowUpdated)}, ) self.assertTrue(self.table.changed(), "Table.Update: Run UPDATE but the table is marked as not changed") def test_insert(self): self.assertTrue(self.table.load()) insertedConflict = self.table.insert({"Code": "A2", "Title": "Meow"}, "Code") self.assertFalse(insertedConflict, "Table.Insert: Inserting a conflicting record did not fail") self.assertFalse(self.table.changed(), "Table.Insert: Running INSERT failed but the table is marked as changed") inserted = self.table.insert({"Code": "A234", "Title": "Meow"}, "Code") self.assertTrue(inserted, "Table.Insert: Inserting failed") self.assertTrue(self.table.changed(), "Table.Insert: Run INSERT but the table is marked as not changed") self.assertTrue(self.table.insert({"Code": "A999"}, "Code")) self.assertEqual(len(self.table.select("Code", 'Code == "A999" and Title is None')), 1) def test_delete(self): self.assertTrue(self.table.load()) rowDelete = self.table.delete('Code == "A2503"') self.assertEqual( rowDelete, 0, "Table.Delete: Requested deleting a record that does not exist but it deleted %(num)d record(s)." % {"num": rowDelete}, ) self.assertFalse(self.table.changed(), "Table.Delete: Running DELETE failed but the table is marked as changed") rowDelete = self.table.delete('Code == "A2"') self.assertEqual( rowDelete, 1, "Table.Delete: Requested deleting a record but it deleted %(num)d record(s)." % {"num": rowDelete}, ) self.assertTrue(self.table.changed(), "Table.Delete: Run DELETE but the table is marked as not changed") rows = self.table.select(["Code", "Title"], 'Code == "A2"') self.assertEqual(len(rows), 0, "Table.Delete: Deleted record selected ({0}).".format(rows))
def setUp(self): self.logger = logging.getLogger() self.dataFile = Datafile('test.model.items.xml', self.id()) self.table = Table(self.logger, self.dataFile.getFilename(), 'ArtShowItems', 'Item', ItemField.ALL_PERSISTENT)
def test_init(s): table = Table(s) assert table and table.id == s
class Node: def __init__(self, id, variable, dependencies): """ variable - dictionary containing the variable name to its possible values dependencies - dictionary containing the dependencies to its possible values """ self.id = id self.varName = list(variable.keys())[0] self.table = Table(variable, dependencies) def getVarName(self): return self.var_name def fillTable(self, cptMapping): """ cptMapping - dictionary mapping the probability query to the probability value """ for mapping in cptMapping: query, evidence = self._unpackMap(mapping) self.setProb(query, evidence, cptMapping[mapping]) def _unpackMap(self, mapping): """ mapping - string of the form of a probability query e.g. A = True | B = False, A = False Returns: query - dictionary mapping the variable and its value evidence - dictionary mapping the evidence and its value """ if mapping.find('|') != -1: queryStr, evidenceStr = mapping.split('|') query = dict() queryVar, queryVal = [x.strip() for x in queryStr.split('=')] query[queryVar] = queryVal evidence = dict() eviStrs = [x.strip() for x in evidenceStr.split(',')] for eviStr in eviStrs: eviVar, eviVal = [x.strip() for x in eviStr.split('=')] evidence[eviVar] = eviVal return (query, evidence) else: query = dict() queryVar, queryVal = [x.strip() for x in mapping.split('=')] query[queryVar] = queryVal return (query, None) def getProb(self, query, evidence): return self.table.getProb(query, evidence) def setProb(self, query, evidence, prob): self.table.setProb(query, evidence, prob) def getFactor(self, conditions): return self.table.getFactor(conditions)
def get_empty_gti_table(): table = Table ("GTI") table.add_columns (["START", "STOP"]) return table
def add_table(self, table_id, column_names ): self.tables[table_id] = Table (table_id) self.tables[table_id].add_columns (column_names)
class TestTable(unittest.TestCase): def setUpClass(): logging.basicConfig(level=logging.DEBUG) def setUp(self): self.logger = logging.getLogger() self.dataFile = Datafile('test.model.items.xml', self.id()) self.table = Table(self.logger, self.dataFile.getFilename(), 'ArtShowItems', 'Item', ItemField.ALL_PERSISTENT) def tearDown(self): self.dataFile.clear() del self.table def test_loadSave(self): self.assertTrue(self.table.load()) self.table.save(True) self.assertTrue(self.table.load()) def test_select(self): self.assertTrue(self.table.load()) # Select exactly one row with a mandatory column that is not available rows = self.table.select(['Code', 'Title', 'Note'], 'Code == "A2"') self.assertEqual(1, len(rows)) self.assertDictEqual({ 'Title': 'Cougar', 'Code': 'A2', 'Note': None }, rows[0]) self.assertFalse( self.table.changed(), 'Table.Select: Run SELECT but the table is marked as changed') # Select all rows rows = self.table.select(['Code', 'Author']) self.assertTrue( len(rows) == self.table.len() and len(rows[0]) == 2, 'Table.Select: Expected all rows with columns {Code, Author} but received %(row)s' % {'row': str(rows)}) self.assertFalse( self.table.changed(), 'Table.Select: Run SELECT but the table is marked as changed') def test_update(self): self.assertTrue(self.table.load()) # Update row row = self.table.select(['Code', 'Title'], 'Code == "A2"')[0] numUpdated = self.table.update({'Title': 'ragouC'}, 'Code == "AXXX"') self.assertEqual( numUpdated, 0, 'Table.Update: Updating a row (%(numUpdated)d) even though the row does not exist' % {'numUpdated': numUpdated}) self.assertFalse( self.table.changed(), 'Table.Update: Running UPDATE failed but the table is marked as changed' ) numUpdated = self.table.update({'Title': 'ragouC'}, 'Code == "A2"') rowUpdated = self.table.select(['Author', 'Title'], 'Code == "A2"')[0] self.assertTrue( numUpdated == 1 and row['Title'] == 'Cougar' and rowUpdated['Title'] == 'ragouC', 'Table.Update: Updated row but the selecting the row returned %(row)s' % {'row': str(rowUpdated)}) self.assertTrue( self.table.changed(), 'Table.Update: Run UPDATE but the table is marked as not changed') def test_insert(self): self.assertTrue(self.table.load()) insertedConflict = self.table.insert({ 'Code': 'A2', 'Title': 'Meow' }, 'Code') self.assertFalse( insertedConflict, 'Table.Insert: Inserting a conflicting record did not fail') self.assertFalse( self.table.changed(), 'Table.Insert: Running INSERT failed but the table is marked as changed' ) inserted = self.table.insert({'Code': 'A234', 'Title': 'Meow'}, 'Code') self.assertTrue(inserted, 'Table.Insert: Inserting failed') self.assertTrue( self.table.changed(), 'Table.Insert: Run INSERT but the table is marked as not changed') self.assertTrue(self.table.insert({'Code': 'A999'}, 'Code')) self.assertEqual( len(self.table.select('Code', 'Code == "A999" and Title is None')), 1) def test_delete(self): self.assertTrue(self.table.load()) rowDelete = self.table.delete('Code == "A2503"') self.assertEqual( rowDelete, 0, 'Table.Delete: Requested deleting a record that does not exist but it deleted %(num)d record(s).' % {'num': rowDelete}) self.assertFalse( self.table.changed(), 'Table.Delete: Running DELETE failed but the table is marked as changed' ) rowDelete = self.table.delete('Code == "A2"') self.assertEqual( rowDelete, 1, 'Table.Delete: Requested deleting a record but it deleted %(num)d record(s).' % {'num': rowDelete}) self.assertTrue( self.table.changed(), 'Table.Delete: Run DELETE but the table is marked as not changed') rows = self.table.select(['Code', 'Title'], 'Code == "A2"') self.assertEqual( len(rows), 0, 'Table.Delete: Deleted record selected ({0}).'.format(rows))