class ConditionSetTest(unittest.TestCase):
def setUp(self):
self.df = pd.read_csv(RSC_DIR + '/census.csv')
with open(RSC_DIR + '/schema_census') as f:
schema = json.loads(f.read())
self.schema = OrderedDict(attributes=schema['attributes'], index=schema['index'])
self.table = Table('census', self.schema).data(self.df)
self.table.add_column('fake_cat', 'CATEGORICAL')
items = self.table.index_items()
fake_cat = ['C1','C2','C3','C4']
self.fake_sets = {}
for k in fake_cat:
self.fake_sets.setdefault(k, [])
for i, item in enumerate(items):
self.table.update({'State':item}, {'$set': {'fake_cat': fake_cat[i % 4]}})
self.fake_sets[fake_cat[i % 4]].append(item)
def tearDown(self):
names.clear()
def testCreation(self):
cs = ConditionSet(name='condition_set', data=self.table, setop='AND')
self.assertEqual(cs.is_empty(), True)
self.assertEqual(cs.reference, [])
self.assertEqual(cs.query, {'State': {'$in': []}})
self.assertEqual(cs.projection, {})
def testAddCondition(self):
cs = ConditionSet(name='condition_set', data=self.table, setop='AND')
cc = CategoricalCondition(data=self.table, attr='fake_cat')
cs.add_condition(cc)
cc.add_category('C1')
self.assertItemsEqual(cs.reference, self.fake_sets['C1'])
cc.add_category(['C1', 'C3'])
c1_and_c3 = self.fake_sets['C1'][:]
c1_and_c3 += self.fake_sets['C3']
self.assertItemsEqual(cs.reference, c1_and_c3)
def testAddSeveralConditions(self):
cs = ConditionSet(name='condition_set', data=self.table, setop='AND')
cc = CategoricalCondition(data=self.table, attr='fake_cat')
rc = RangeCondition(data=self.table, attr='Information')
rc.set_range(0.5, relative=True)
cs.add_condition(cc)
cc.add_category('C1')
self.assertItemsEqual(cs.reference, self.fake_sets['C1'])
cs.add_condition(rc)
self.assertItemsEqual(cs.reference, ['CA'])
cc.toggle_category(['C1', 'C3'])
self.assertItemsEqual(cs.reference, ['NY'])
rc.set_range(0, 1, relative=True)
self.assertItemsEqual(cs.reference, self.fake_sets['C3'])
def testRemoveCondition(self):
cs = ConditionSet(name='condition_set', data=self.table, setop='AND')
cc = CategoricalCondition(data=self.table, attr='fake_cat')
cs.add_condition(cc)
cc.add_category('C1')
self.assertItemsEqual(cs.reference, self.fake_sets['C1'])
cs.remove_condition(cc)
self.assertEqual(cs.reference, [])
def testEnablingChanges(self):
cs = ConditionSet(name='condition_set', data=self.table, setop='AND')
cc = CategoricalCondition(data=self.table, attr='fake_cat')
rc = RangeCondition(data=self.table, attr='Information')
rc.set_range(0.5, relative=True)
cs.add_condition(cc)
cc.add_category('C1')
self.assertItemsEqual(cs.reference, self.fake_sets['C1'])
cc.disable()
print cs.query, cs.reference
self.assertItemsEqual(cs.reference, [])
cs.add_condition(rc)
self.assertItemsEqual(cs.reference, ['CA', 'NY'])
rc.enable(False)
cc.enable()
self.assertItemsEqual(cs.reference, self.fake_sets['C1'])
cc.toggle_category(['C1', 'C3'])
rc.enable()
self.assertItemsEqual(cs.reference, ['NY'])
rc.set_range(0, 1, relative=True)
self.assertItemsEqual(cs.reference, self.fake_sets['C3'])
def testGrammar(self):
cs = ConditionSet(name='condition_set', data=self.table, setop='AND')
cc = CategoricalCondition(data=self.table, attr='fake_cat', name='catc')
rc = RangeCondition(data=self.table, attr='Information', name='rangec')
ac = AttributeCondition(data=self.table, name='attrc')
cs.add_condition(cc)
cs.add_condition(rc)
cs.add_condition(ac)
print cs.grammar
self.maxDiff = None
self.assertDictEqual(cs.grammar, {'setop': 'AND',
'conditions': ['rangec','catc','attrc'],
'data': 'census',
'name': 'condition_set'})
class CategoricalTest(unittest.TestCase):
def setUp(self):
self.df = pd.read_csv(RSC_DIR+'/census.csv')
with open(RSC_DIR+'/schema_census') as f:
schema = json.loads(f.read())
self.schema = OrderedDict(attributes = schema['attributes'], index = schema['index'])
self.table = Table('census', self.schema).data(self.df)
self.table.add_column('fake_cat', 'CATEGORICAL')
items = self.table.index_items()
fake_cat = ['C1','C2','C3','C4']
for i, item in enumerate(items):
self.table.update({'State':item}, {'$set': {'fake_cat': fake_cat[ i % 4]}})
def tearDown(self):
names.clear()
def testCreation(self):
cc = CategoricalCondition(data=self.table, attr='fake_cat')
self.assertEqual(cc.included_categories(), [])
with self.assertRaises(NotImplementedError):
cc = CategoricalCondition(data=self.table, attr='Information')
def testAdd(self):
cc = CategoricalCondition(data=self.table, attr='fake_cat')
cc.add_category('C1')
self.assertEqual(set(cc.included_categories()), set(['C1']))
cc.add_category(['C1', 'C3'])
self.assertEqual(set(cc.included_categories()), set(['C1', 'C3']))
def testRemove(self):
cc = CategoricalCondition(data=self.table, attr='fake_cat')
cc.add_category(['C1', 'C3'])
cc.remove_category('C1')
self.assertEqual(set(cc.included_categories()), set(['C3']))
def testToggleItem(self):
cc = CategoricalCondition(data=self.table, attr='fake_cat')
cc.add_category(['C1', 'C3'])
cc.toggle_category('C1')
cc.toggle_category('C2')
self.assertEqual(set(cc.included_categories()), set(['C3', 'C2']))
cc.toggle_category(['C2','C4'])
self.assertEqual(set(cc.included_categories()), set(['C3', 'C4']))
def testIncludeAll(self):
cc = CategoricalCondition(data=self.table, attr='fake_cat')
cc.include_all()
self.assertSetEqual(set(cc.included_categories()),
set(self.table.distinct('fake_cat')))
def testExcludeAll(self):
cc = CategoricalCondition(data=self.table, attr='fake_cat')
cc.add_category('C1')
cc.exclude_all()
self.assertEqual(cc.included_categories(),[])
def testToggle(self):
cc = CategoricalCondition(data=self.table, attr='fake_cat')
cc.add_category('C1')
cc.toggle()
self.assertEqual(set(cc.included_categories()), set(['C2', 'C3', 'C4']))
def testIncludedItems(self):
cc = CategoricalCondition(data=self.table, attr='fake_cat')
cc.add_category('C1')
self.assertSetEqual(set(cc.included_items()),
set(['AK', 'CA', 'DE', 'IA', 'KS', 'MD', 'MO',
'ND', 'NM', 'OK', 'SC', 'UT', 'WI']))
cc.add_category(['C2', 'C3', 'C4'])
self.assertSetEqual(set(cc.included_items()), set(self.table.distinct('State')))
def testExcludedItems(self):
cc = CategoricalCondition(data=self.table, attr='fake_cat')
cc.add_category(['C2', 'C3', 'C4'])
self.assertSetEqual(set(cc.excluded_items()),
set(['AK', 'CA', 'DE', 'IA', 'KS', 'MD', 'MO',
'ND', 'NM', 'OK', 'SC', 'UT', 'WI']))
cc.add_category('C1')
self.assertSetEqual(set(cc.excluded_items()), set([]))
class RootTest(unittest.TestCase):
def setUp(self):
self.root = Root("root")
self.root2 = Root("root2")
self.createTable()
self.createConditions()
self.createDynamics()
self.createSharedObject()
def tearDown(self):
names.clear()
def createTable(self):
self.df = pd.read_csv(RSC_DIR + '/census.csv')
with open(RSC_DIR + '/schema_census') as f:
schema = json.loads(f.read())
self.schema = OrderedDict(attributes=schema['attributes'], index=schema['index'])
self.table = Table('census', self.schema).data(self.df)
self.table.add_column('fake_cat', 'CATEGORICAL')
items = self.table.index_items()
fake_cat = ['C1','C2','C3','C4']
for i, item in enumerate(items):
self.table.update({'State':item}, {'$set': {'fake_cat': fake_cat[i % 4]}})
self.root.add_dataset(self.table)
def createConditions(self):
self.categorical_condition = CategoricalCondition(data=self.table, attr='fake_cat')
self.range_condition = RangeCondition(data=self.table, attr='Information',
range=dict(min=250000, max=500000))
self.query_condition = QueryCondition(data=self.table, query={'State':'NY'})
self.attribute_condition = AttributeCondition(data=self.table, attributes=['Information'])
self.consition_set = ConditionSet(name='condition_set', data=self.table, setop='AND')
self.consition_set.add_condition(self.categorical_condition)
self.consition_set.add_condition(self.range_condition)
self.consition_set.add_condition(self.query_condition)
self.consition_set.add_condition(self.attribute_condition)
self.root.add_condition(self.categorical_condition)
self.root.add_condition(self.range_condition)
self.root.add_condition(self.query_condition)
self.root.add_condition(self.attribute_condition)
def createDynamics(self):
self.filter1 = DynFilter("filer1", self.table)
self.filter1.add_condition(self.range_condition)
self.filter2 = DynFilter("filer2", self.table)
self.filter2.add_condition(self.query_condition)
self.filter2.add_condition(self.attribute_condition)
self.selection = DynSelect("selection", self.table)
self.selection.add_condition(self.categorical_condition)
self.root.add_dynamic(self.filter1)
self.root.add_dynamic(self.filter2)
self.root.add_dynamic(self.selection)
def createSharedObject(self):
self.shared_object = SharedObject("shared_object", {'a':42, 'b':[1,2,3,4]})
self.root.add_dataset(self.shared_object)
def testCreation(self):
from pprint import pprint
grammar = self.root.grammar
pprint(grammar)
names.clear()
objects = Root.build(grammar)
self.assertIn(self.table.name, objects)
self.assertIn(self.attribute_condition.name, objects)
self.assertIn(self.categorical_condition.name, objects)
self.assertIn(self.range_condition.name, objects)
self.assertIn(self.query_condition.name, objects)
self.assertIn(self.filter1.name, objects)
self.assertIn(self.filter2.name, objects)
self.assertIn(self.selection.name, objects)
self.assertIn(self.shared_object.name, objects)
self.assertIsInstance(self.table, Table)
self.assertIsInstance(self.attribute_condition, AttributeCondition)
self.assertIsInstance(self.categorical_condition, CategoricalCondition)
self.assertIsInstance(self.range_condition, RangeCondition)
self.assertIsInstance(self.query_condition, QueryCondition)
self.assertIsInstance(self.filter1, DynFilter)
self.assertIsInstance(self.filter2, DynFilter)
self.assertIsInstance(self.selection, DynSelect)
self.assertIsInstance(self.shared_object, SharedObject)
