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