class TestGetOrCreateSchema(SimpleTestCase): def setUp(self): self.db = FormQuestionSchema.get_db() self.fakedb = FakeCouchDb() FormQuestionSchema.set_db(self.fakedb) self.domain = 'test' self.app_id = '123' self.xmlns = 'this_xmlns' self.schema = FormQuestionSchema(domain=self.domain, app_id=self.app_id, xmlns=self.xmlns) def tearDown(self): FormQuestionSchema.set_db(self.db) def test_required_props(self): with self.assertRaises(BadValueError): schema = FormQuestionSchema(app_id=self.app_id, xmlns=self.xmlns) schema.save() # with self.assertRaises(BadValueError): # schema = FormQuestionSchema(domain=self.domain, xmlns=self.xmlns) # schema.save() with self.assertRaises(BadValueError): schema = FormQuestionSchema(domain=self.domain, app_id=self.app_id) schema.save() def test_unique_key(self): self.schema.save() dupe_schema = FormQuestionSchema(domain=self.domain, app_id=self.app_id, xmlns=self.xmlns) with self.assertRaises(ResourceConflict): dupe_schema.save() def test_get_existing(self): self.schema.save() schema = FormQuestionSchema.get_or_create(self.domain, self.app_id, self.xmlns) self.assertIsNotNone(schema) self.assertEqual(schema._rev, self.schema._rev) def test_get_new(self): self.schema.save() schema = FormQuestionSchema.get_or_create('new_domain', self.app_id, self.xmlns) self.assertIsNotNone(schema) def test_migrate_old(self): self.schema._id = '123' self.schema.last_processed_version = 12 self.schema.save() second_schema = FormQuestionSchema(domain=self.domain, app_id=self.app_id, xmlns=self.xmlns, _id='1234') second_schema.save() self.assertEqual(len(self.fakedb.mock_docs), 2) self.fakedb.add_view( 'form_question_schema/by_xmlns', [({ 'key': [self.domain, self.app_id, self.xmlns], 'include_docs': True }, [self.schema.to_json(), second_schema.to_json()])]) schema = FormQuestionSchema.get_or_create(self.domain, self.app_id, self.xmlns) self.assertEqual(schema.last_processed_version, self.schema.last_processed_version) self.assertNotEqual(schema.get_id, self.schema.get_id) self.assertNotEqual(schema.get_id, second_schema.get_id) self.assertEqual(len(self.fakedb.mock_docs), 1) self.assertTrue(schema.get_id in self.fakedb.mock_docs)
class FluffTest(TestCase): @classmethod def setUpClass(cls): super(FluffTest, cls).setUpClass() # hack - force disconnecting the signals because ctable doesn't play nice with mocks cls.previous_signal_receivers = indicator_document_updated.receivers indicator_document_updated.receivers = [] cls.engine = connection_manager.get_engine(DEFAULT_ENGINE_ID) def setUp(self): self.fakedb = FakeCouchDb() MockIndicators.set_db(self.fakedb) MockIndicatorsWithGetters.set_db(self.fakedb) MockDoc.set_db(self.fakedb) MockIndicatorsSql.set_db(self.fakedb) rebuild_table(self.engine, None, MockIndicatorsSql) rebuild_table(self.engine, None, MockIndicatorsSqlWithFlatFields) @classmethod def tearDownClass(cls): indicator_document_updated.receivers = cls.previous_signal_receivers super(FluffTest, cls).tearDownClass() def tearDown(self): with self.engine.begin() as connection: MockIndicatorsSql()._table.drop(connection, checkfirst=True) MockIndicatorsSqlWithFlatFields()._table.drop(connection, checkfirst=True) self.engine.dispose() def test_calculator_base_classes(self): # Base0 self.assertEqual(Base0._fluff_emitters, set([ 'base_0_emitter', ])) self.assertEqual(Base0._fluff_filters, set([ 'base_0_filter', ])) # Base1 self.assertEqual(Base1._fluff_emitters, set([ 'base_0_emitter', 'base_1_emitter', ])) self.assertEqual(Base1._fluff_filters, set([ 'base_0_filter', 'base_1_filter', ])) # Base2 self.assertEqual(Base2._fluff_emitters, set([ 'base_0_emitter', 'base_2_emitter', ])) self.assertEqual(Base2._fluff_filters, set([ 'base_0_filter', 'base_2_filter', ])) # Base2 self.assertEqual(Base3._fluff_emitters, set([ 'base_0_emitter', 'base_1_emitter', 'base_2_emitter', 'base_3_emitter', ])) self.assertEqual(Base3._fluff_filters, set([ 'base_0_filter', 'base_1_filter', 'base_2_filter', 'base_3_filter', ])) def test_indicator_classes(self): self.assertEqual(list(Indicators1._calculators), ['base0']) self.assertEqual(list(Indicators2._calculators), ['base1', 'base2']) def test_indicator_calculation(self): actions = [dict(date="2012-09-23", x=2), dict(date="2012-09-24", x=3)] doc = dict( actions=actions, get_id="123", domain="mock", owner_id="test_owner", doc_type='MockDoc' ) for cls in [MockIndicators, MockIndicatorsWithGetters]: classname = cls.__name__ pillow = cls.pillow()() pillow.process_change(change_from_couch_row({'changes': [], 'id': '123', 'seq': 1, 'doc': doc})) indicator = self.fakedb.mock_docs.get("%s-123" % classname, None) self.assertIsNotNone(indicator) self.assertEqual(11, len(indicator)) self.assertEqual(8, len(indicator['value_week'])) self.assertIn("value_week", indicator) self.assertIn("date", indicator["value_week"]) self.assertIn("null", indicator["value_week"]) self.assertIn("date_value", indicator["value_week"]) self.assertIn("null_value", indicator["value_week"]) self.assertEqual({'date': "2012-09-23", 'value': 1, 'group_by': None}, indicator["value_week"]["date"][0]) self.assertEqual({'date': "2012-09-24", 'value': 1, 'group_by': None}, indicator["value_week"]["date"][1]) self.assertEqual({'date': None, 'value': 1, 'group_by': None}, indicator["value_week"]["null"][0]) self.assertEqual({'date': "2012-09-23", 'value': 2, 'group_by': None}, indicator["value_week"]["date_value"][0]) self.assertEqual({'date': "2012-09-24", 'value': 3, 'group_by': None}, indicator["value_week"]["date_value"][1]) self.assertEqual({'date': None, 'value': 2, 'group_by': None}, indicator["value_week"]["null_value"][0]) self.assertEqual(dict(date='2013-01-01', group_by=['abc', 'xyz'], value=3), indicator["value_week"]["group_list"][0]) self.assertEqual(dict(date='2013-01-01', group_by=['abc', '123'], value=2), indicator["value_week"]["group_val"][0]) self.assertEqual(dict(date='2013-01-01', group_by=['abc', '123'], value=1), indicator["value_week"]["group_no_val"][0]) def test_calculator_calculate(self): calc = ValueCalculator(WEEK) calc.fluff = MockIndicators values = calc.calculate(MockDoc.wrap(dict(actions=[dict(date="2012-09-23", x=2), dict(date="2012-09-24", x=3)]))) self.assertEqual(len(list(values)), 8) self.assertEqual(values['null_value'], [dict(date=None, value=2, group_by=None)]) self.assertEqual(values['date_value'], [ dict(date=date(2012, 9, 23), value=2, group_by=None), dict(date=date(2012, 9, 24), value=3, group_by=None)]) self.assertEqual(values['date'], [ dict(date=date(2012, 9, 23), value=1, group_by=None), dict(date=date(2012, 9, 24), value=1, group_by=None)]) self.assertEqual(values['null'], [dict(date=None, value=1, group_by=None)]) self.assertEqual(values['group_list'], [dict(date=date(2013, 1, 1), group_by=['abc', 'xyz'], value=3)]) self.assertEqual(values['group_val'], [dict(date=date(2013, 1, 1), group_by=['abc', '123'], value=2)]) self.assertEqual(values['group_no_val'], [dict(date=date(2013, 1, 1), group_by=['abc', '123'], value=1)]) self.assertEqual(values['group_null'], [dict(date=None, group_by=['abc', 'xyz'], value=1)]) def test_calculator_get_result(self): key = ['a', 'b'] now = datetime.utcnow().date() start = json_format_date(now - WEEK) end = json_format_date(now) for cls in [MockIndicators, MockIndicatorsWithGetters]: classname = cls.__name__ self.fakedb.add_view('fluff/generic', [ ( {'reduce': True, 'key': [classname, 'a', 'b', 'value_week', 'null', None]}, [{"key": None, "value": {"sum": 3}}] ), ( {'reduce': True, 'key': [classname, 'a', 'b', 'value_week', 'null_value', None]}, [{"key": None, "value": {"max": 8}}] ), ( {'startkey': [classname, 'a', 'b', 'value_week', 'date', start], 'endkey': [classname, 'a', 'b', 'value_week', 'date', end], 'reduce': True}, [{"key": None, "value": {"count": 7}}] ), ( {'startkey': [classname, 'a', 'b', 'value_week', 'date_value', start], 'endkey': [classname, 'a', 'b', 'value_week', 'date_value', end], 'reduce': True}, [{"key": None, "value": {"sum": 11}}] ) ]) value = cls.get_result('value_week', key, reduce=True) self.assertEqual(value['null'], 3) self.assertEqual(value['date'], 7) self.assertEqual(value['date_value'], 11) self.assertEqual(value['null_value'], 8) def test_indicator_diff_new(self): for cls in [MockIndicators, MockIndicatorsWithGetters]: classname = cls.__name__ doc = cls( domain="mock", owner_id="123", value_week=dict( date=[[date(2012, 2, 23), 1]], null=[], date_value=[], null_value=[[None, 3]] ) ) diff = doc.diff(None) self.maxDiff = None expected = dict(domains=['mock'], database=cls.Meta.app_label, doc_type=classname, group_values=['mock', '123'], group_names=['domain', 'owner_id'], group_type_map={'domain': 'integer', 'owner_id': 'string'}, indicator_changes=[ dict(calculator='value_week', emitter='date', emitter_type='date', reduce_type='count', values=[dict(date=date(2012, 2, 23), value=1, group_by=None)]), dict(calculator='value_week', emitter='null_value', emitter_type='null', reduce_type='max', values=[dict(date=None, value=3, group_by=None)]) ], all_indicators=self.all_indicators()) self.assertItemsEqual(expected.pop('all_indicators'), diff.pop('all_indicators')) self.assertItemsEqual(expected.pop('indicator_changes'), diff.pop('indicator_changes')) self.assertEqual(expected, diff) def test_indicator_diff_same(self): for cls in [MockIndicators, MockIndicatorsWithGetters]: doc = cls(domain="mock", owner_id="123", value_week=dict( date=[date(2012, 2, 23)], null=[], date_value=[], null_value=[[None, 3]] )) another = cls(doc.to_json()) diff = doc.diff(another) self.assertIsNone(diff) def all_indicators(self): return [ dict(calculator='value_week', emitter='date_value', emitter_type='date', reduce_type='sum'), dict(calculator='value_week', emitter='date', emitter_type='date', reduce_type='count'), dict(calculator='value_week', emitter='null', emitter_type='null', reduce_type='sum'), dict(calculator='value_week', emitter='null_value', emitter_type='null', reduce_type='max'), ] def test_indicator_diff(self): for cls in [MockIndicators, MockIndicatorsWithGetters]: current = cls(domain="mock", owner_id="123", value_week=dict(date=[[date(2012, 2, 23), 1]], null=[], date_value=[[date(2012, 2, 23), 3]], null_value=[])) new = cls(domain="mock", owner_id="123", value_week=dict( date=[[date(2012, 2, 24), 1]], null=[[None, 1]], date_value=[[date(2012, 2, 23), 4]], null_value=[[None, 2]])) diff = new.diff(current) self.assertIsNotNone(diff) self.maxDiff = None expected = dict(domains=['mock'], database=cls.Meta.app_label, doc_type=cls.__name__, group_values=['mock', '123'], group_names=['domain', 'owner_id'], group_type_map={'domain': 'integer', 'owner_id': 'string'}, indicator_changes=[ dict(calculator='value_week', emitter='date_value', emitter_type='date', reduce_type='sum', values=[dict(date=date(2012, 2, 23), value=4, group_by=None)]), dict(calculator='value_week', emitter='date', emitter_type='date', reduce_type='count', values=[dict(date=date(2012, 2, 24), value=1, group_by=None)]), dict(calculator='value_week', emitter='null', emitter_type='null', reduce_type='sum', values=[dict(date=None, value=1, group_by=None)]), dict(calculator='value_week', emitter='null_value', emitter_type='null', reduce_type='max', values=[dict(date=None, value=2, group_by=None)]) ], all_indicators=self.all_indicators()) self.assertItemsEqual(expected.pop('all_indicators'), diff.pop('all_indicators')) self.assertItemsEqual(expected.pop('indicator_changes'), diff.pop('indicator_changes')) self.assertEqual(expected, diff) def test_indicator_diff_dict(self): for cls in [MockIndicators, MockIndicatorsWithGetters]: current = cls(domain="mock", owner_id="123", value_week=dict( date=[dict(date=date(2012, 2, 23), value=1, group_by=None)], date_value=[[date(2012, 2, 24), 1]], group_list=[], null_value=[dict(date=None, value=1, group_by='abc')], )) new = cls(domain="mock", owner_id="123", value_week=dict( date=[[date(2012, 2, 24), 1]], date_value=[dict(date=date(2012, 2, 20), value=2, group_by=None)], group_list=[dict(date=date(2013, 1, 1), value=3, group_by=['abc', '123'])], null_value=[dict(date=None, value=1, group_by='abc')], )) diff = new.diff(current) self.assertIsNotNone(diff) self.maxDiff = None expected = dict(domains=['mock'], database=cls.Meta.app_label, doc_type=cls.__name__, group_values=['mock', '123'], group_names=['domain', 'owner_id'], group_type_map={'domain': 'integer', 'owner_id': 'string'}, indicator_changes=[ dict(calculator='value_week', emitter='date_value', emitter_type='date', reduce_type='sum', values=[dict(date=date(2012, 2, 20), value=2, group_by=None)]), dict(calculator='value_week', emitter='date', emitter_type='date', reduce_type='count', values=[dict(date=date(2012, 2, 24), value=1, group_by=None)]), dict(calculator='value_week', emitter='group_list', emitter_type='date', reduce_type='sum', values=[dict(date=date(2013, 1, 1), value=3, group_by=['abc', '123'])]), ], all_indicators=[ dict(calculator='value_week', emitter='date_value', emitter_type='date', reduce_type='sum'), dict(calculator='value_week', emitter='date', emitter_type='date', reduce_type='count'), dict(calculator='value_week', emitter='group_list', emitter_type='date', reduce_type='sum'), dict(calculator='value_week', emitter='null_value', emitter_type='null', reduce_type='max'), ]) self.assertItemsEqual(expected.pop('all_indicators'), diff.pop('all_indicators')) self.assertItemsEqual(expected.pop('indicator_changes'), diff.pop('indicator_changes')) self.assertEqual(expected, diff) def test_flat_field_types(self): str_field = fluff.FlatField(lambda case: "hello") self.assertEqual(str_field.calculate('bar'), "hello") unicode_field = fluff.FlatField(lambda case: "unicode!!") self.assertEqual(unicode_field.calculate('bar'), "unicode!!") num_field = fluff.FlatField(lambda case: 432123141) self.assertRaises(AssertionError, num_field.calculate, 'bar') def test_save_to_sql(self): actions = [dict(date="2012-09-23", x=2), dict(date="2012-09-24", x=3)] doc = dict( actions=actions, get_id="123", domain="mock", owner_id="test_owner" ) current = MockIndicatorsSql(_id='234') current.calculate(MockDoc.wrap(doc)) current.save_to_sql(current.diff(None), self.engine) expected = [ ('123', date(1, 1, 1), 'mock', 'test_owner', None, None, None, None, None, None, 1, 2), ('123', date(2013, 1, 1), 'abc', '123', None, None, None, 1, None, 2, None, None), ('123', date(2012, 9, 24), 'mock', 'test_owner', 1, 3, None, None, None, None, None, None), ('123', date(2012, 9, 23), 'mock', 'test_owner', 1, 2, None, None, None, None, None, None), ('123', date(1, 1, 1), 'abc', 'xyz', None, None, None, None, 1, None, None, None), ('123', date(2013, 1, 1), 'abc', 'xyz', None, None, 3, None, None, None, None, None), ] with self.engine.begin() as connection: rows = connection.execute(sqlalchemy.select([current._table])) self.assertItemsEqual(rows, expected) def test_save_to_sql_update(self): self.test_save_to_sql() actions = [dict(date="2012-09-23", x=5)] doc = dict( actions=actions, get_id="123", domain="mock", owner_id="test_owner" ) current = MockIndicatorsSql(_id='234') current.calculate(MockDoc.wrap(doc)) current.save_to_sql(current.diff(None), self.engine) expected = [ ('123', date(1, 1, 1), 'mock', 'test_owner', None, None, None, None, None, None, 1, 2), ('123', date(2013, 1, 1), 'abc', '123', None, None, None, 1, None, 2, None, None), ('123', date(2012, 9, 23), 'mock', 'test_owner', 1, 5, None, None, None, None, None, None), ('123', date(1, 1, 1), 'abc', 'xyz', None, None, None, None, 1, None, None, None), ('123', date(2013, 1, 1), 'abc', 'xyz', None, None, 3, None, None, None, None, None), ] with self.engine.begin() as connection: rows = connection.execute(sqlalchemy.select([current._table])) self.assertItemsEqual(rows, expected) def test_save_to_sql_flat_fields(self): actions = [dict(date="2012-09-23", x=2), dict(date="2012-09-24", x=3)] doc = dict( actions=actions, opened_on="2012-09-23", closed_on="2013-09-23", get_id="123", domain="mock", owner_id="test_owner" ) current = MockIndicatorsSqlWithFlatFields(_id='234') current.calculate(MockDoc.wrap(doc)) current.save_to_sql(current.diff(None), self.engine) expected = [ ('123', date(2012, 9, 24), '2012-09-23', '2013-09-23', 'mock', 'test_owner', 1, 3, None, None, None, None, None, None), ('123', date(2013, 1, 1), '2012-09-23', '2013-09-23', 'abc', '123', None, None, None, 1, None, 2, None, None), ('123', date(1, 1, 1), '2012-09-23', '2013-09-23', 'abc', 'xyz', None, None, None, None, 1, None, None, None), ('123', date(2012, 9, 23), '2012-09-23', '2013-09-23', 'mock', 'test_owner', 1, 2, None, None, None, None, None, None), ('123', date(1, 1, 1), '2012-09-23', '2013-09-23', 'mock', 'test_owner', None, None, None, None, None, None, 1, 2), ('123', date(2013, 1, 1), '2012-09-23', '2013-09-23', 'abc', 'xyz', None, None, 3, None, None, None, None, None), ] with self.engine.begin() as connection: rows = connection.execute(sqlalchemy.select([current._table])) self.assertItemsEqual(rows, expected) def test_deleting_on_doc_type_change(self): actions = [dict(date="2012-09-23", x=2), dict(date="2012-09-24", x=3)] doc = dict( actions=actions, get_id="123", domain="mock", owner_id="test_owner", doc_type='MockDoc' ) for cls in [MockIndicators, MockIndicatorsWithGetters]: classname = cls.__name__ pillow = cls.pillow()() pillow.process_change(change_from_couch_row({'changes': [], 'id': '123', 'seq': 1, 'doc': doc})) indicator = self.fakedb.mock_docs.get("%s-123" % classname, None) self.assertIsNotNone(indicator) doc['doc_type'] = 'MockArchive' for cls in [MockIndicators, MockIndicatorsWithGetters]: classname = cls.__name__ pillow = cls.pillow()() pillow.process_change(change_from_couch_row({'changes': [], 'id': '123', 'seq': 1, 'doc': doc})) indicator = self.fakedb.mock_docs.get("%s-123" % classname, None) self.assertIsNone(indicator) def test_deleting_on_doc_type_change_sql(self): actions = [dict(date="2012-09-23", x=2), dict(date="2012-09-24", x=3)] doc = dict( actions=actions, get_id="123", domain="mock", owner_id="test_owner", doc_type='MockDoc' ) for cls in [MockIndicatorsSql]: pillow = cls.pillow()() pillow.process_change(change_from_couch_row({'changes': [], 'id': '123', 'seq': 1, 'doc': doc})) with self.engine.begin() as connection: rows = connection.execute(sqlalchemy.select([cls._table])) self.assertEqual(rows.rowcount, 6) doc['doc_type'] = 'MockArchive' for cls in [MockIndicatorsSql]: pillow = cls.pillow()() pillow.process_change(change_from_couch_row({'changes': [], 'id': '123', 'seq': 1, 'doc': doc})) with self.engine.begin() as connection: rows = connection.execute(sqlalchemy.select([cls._table])) self.assertEqual(rows.rowcount, 0)
class FluffTest(TestCase): @classmethod def setUpClass(cls): # hack - force disconnecting the signals because ctable doesn't play nice with mocks cls.previous_signal_receivers = indicator_document_updated.receivers indicator_document_updated.receivers = [] cls.engine = sqlalchemy.create_engine(settings.SQL_REPORTING_DATABASE_URL) def setUp(self): self.fakedb = FakeCouchDb() MockIndicators.set_db(self.fakedb) MockIndicatorsWithGetters.set_db(self.fakedb) MockDoc.set_db(self.fakedb) MockIndicatorsSql.set_db(self.fakedb) rebuild_table(self.engine, None, MockIndicatorsSql) rebuild_table(self.engine, None, MockIndicatorsSqlWithFlatFields) @classmethod def tearDownClass(cls): indicator_document_updated.receivers = cls.previous_signal_receivers def tearDown(self): with self.engine.begin() as connection: MockIndicatorsSql()._table.drop(connection, checkfirst=True) MockIndicatorsSqlWithFlatFields()._table.drop(connection, checkfirst=True) self.engine.dispose() def test_calculator_base_classes(self): # Base0 self.assertEqual(Base0._fluff_emitters, set([ 'base_0_emitter', ])) self.assertEqual(Base0._fluff_filters, set([ 'base_0_filter', ])) # Base1 self.assertEqual(Base1._fluff_emitters, set([ 'base_0_emitter', 'base_1_emitter', ])) self.assertEqual(Base1._fluff_filters, set([ 'base_0_filter', 'base_1_filter', ])) # Base2 self.assertEqual(Base2._fluff_emitters, set([ 'base_0_emitter', 'base_2_emitter', ])) self.assertEqual(Base2._fluff_filters, set([ 'base_0_filter', 'base_2_filter', ])) # Base2 self.assertEqual(Base3._fluff_emitters, set([ 'base_0_emitter', 'base_1_emitter', 'base_2_emitter', 'base_3_emitter', ])) self.assertEqual(Base3._fluff_filters, set([ 'base_0_filter', 'base_1_filter', 'base_2_filter', 'base_3_filter', ])) def test_indicator_classes(self): self.assertEquals(Indicators1._calculators.keys(), ['base0']) self.assertEquals(Indicators2._calculators.keys(), ['base1', 'base2']) def test_indicator_calculation(self): actions = [dict(date="2012-09-23", x=2), dict(date="2012-09-24", x=3)] doc = dict( actions=actions, get_id="123", domain="mock", owner_id="test_owner", doc_type='MockDoc' ) for cls in [MockIndicators, MockIndicatorsWithGetters]: classname = cls.__name__ pillow = cls.pillow()() pillow.process_change(change_from_couch_row({'changes': [], 'id': '123', 'seq': 1, 'doc': doc})) indicator = self.fakedb.mock_docs.get("%s-123" % classname, None) self.assertIsNotNone(indicator) self.assertEqual(11, len(indicator)) self.assertEqual(8, len(indicator['value_week'])) self.assertIn("value_week", indicator) self.assertIn("date", indicator["value_week"]) self.assertIn("null", indicator["value_week"]) self.assertIn("date_value", indicator["value_week"]) self.assertIn("null_value", indicator["value_week"]) self.assertEqual({'date': "2012-09-23", 'value': 1, 'group_by': None}, indicator["value_week"]["date"][0]) self.assertEqual({'date': "2012-09-24", 'value': 1, 'group_by': None}, indicator["value_week"]["date"][1]) self.assertEqual({'date': None, 'value': 1, 'group_by': None}, indicator["value_week"]["null"][0]) self.assertEqual({'date': "2012-09-23", 'value': 2, 'group_by': None}, indicator["value_week"]["date_value"][0]) self.assertEqual({'date': "2012-09-24", 'value': 3, 'group_by': None}, indicator["value_week"]["date_value"][1]) self.assertEqual({'date': None, 'value': 2, 'group_by': None}, indicator["value_week"]["null_value"][0]) self.assertEqual(dict(date='2013-01-01', group_by=['abc', 'xyz'], value=3), indicator["value_week"]["group_list"][0]) self.assertEqual(dict(date='2013-01-01', group_by=['abc', '123'], value=2), indicator["value_week"]["group_val"][0]) self.assertEqual(dict(date='2013-01-01', group_by=['abc', '123'], value=1), indicator["value_week"]["group_no_val"][0]) def test_calculator_calculate(self): calc = ValueCalculator(WEEK) calc.fluff = MockIndicators values = calc.calculate(MockDoc.wrap(dict(actions=[dict(date="2012-09-23", x=2), dict(date="2012-09-24", x=3)]))) self.assertEquals(len(values.keys()), 8) self.assertEquals(values['null_value'], [dict(date=None, value=2, group_by=None)]) self.assertEquals(values['date_value'], [ dict(date=date(2012, 9, 23), value=2, group_by=None), dict(date=date(2012, 9, 24), value=3, group_by=None)]) self.assertEquals(values['date'], [ dict(date=date(2012, 9, 23), value=1, group_by=None), dict(date=date(2012, 9, 24), value=1, group_by=None)]) self.assertEquals(values['null'], [dict(date=None, value=1, group_by=None)]) self.assertEquals(values['group_list'], [dict(date=date(2013, 1, 1), group_by=['abc', 'xyz'], value=3)]) self.assertEquals(values['group_val'], [dict(date=date(2013, 1, 1), group_by=['abc', '123'], value=2)]) self.assertEquals(values['group_no_val'], [dict(date=date(2013, 1, 1), group_by=['abc', '123'], value=1)]) self.assertEquals(values['group_null'], [dict(date=None, group_by=['abc', 'xyz'], value=1)]) def test_calculator_get_result(self): key = ['a', 'b'] now = datetime.utcnow().date() start = json_format_date(now - WEEK) end = json_format_date(now) for cls in [MockIndicators, MockIndicatorsWithGetters]: classname = cls.__name__ self.fakedb.add_view('fluff/generic', [ ( {'reduce': True, 'key': [classname, 'a', 'b', 'value_week', 'null', None], 'wrap_doc': True}, [{"key": None, "value": {"sum": 3}}] ), ( {'reduce': True, 'key': [classname, 'a', 'b', 'value_week', 'null_value', None], 'wrap_doc': True}, [{"key": None, "value": {"max": 8}}] ), ( {'startkey': [classname, 'a', 'b', 'value_week', 'date', start], 'endkey': [classname, 'a', 'b', 'value_week', 'date', end], 'reduce': True, 'wrap_doc': True}, [{"key": None, "value": {"count": 7}}] ), ( {'startkey': [classname, 'a', 'b', 'value_week', 'date_value', start], 'endkey': [classname, 'a', 'b', 'value_week', 'date_value', end], 'reduce': True, 'wrap_doc': True}, [{"key": None, "value": {"sum": 11}}] ) ]) value = cls.get_result('value_week', key, reduce=True) self.assertEqual(value['null'], 3) self.assertEqual(value['date'], 7) self.assertEqual(value['date_value'], 11) self.assertEqual(value['null_value'], 8) def test_indicator_diff_new(self): for cls in [MockIndicators, MockIndicatorsWithGetters]: classname = cls.__name__ doc = cls( domain="mock", owner_id="123", value_week=dict( date=[[date(2012, 02, 23), 1]], null=[], date_value=[], null_value=[[None, 3]] ) ) diff = doc.diff(None) self.maxDiff = None expected = dict(domains=['mock'], database=cls.Meta.app_label, doc_type=classname, group_values=['mock', '123'], group_names=['domain', 'owner_id'], group_type_map={'domain': 'integer', 'owner_id': 'string'}, indicator_changes=[ dict(calculator='value_week', emitter='date', emitter_type='date', reduce_type='count', values=[dict(date=date(2012, 2, 23), value=1, group_by=None)]), dict(calculator='value_week', emitter='null_value', emitter_type='null', reduce_type='max', values=[dict(date=None, value=3, group_by=None)]) ], all_indicators=self.all_indicators()) self.assertEqual(expected, diff)
class FluffTest(TestCase): @classmethod def setUpClass(cls): super(FluffTest, cls).setUpClass() # hack - force disconnecting the signals because ctable doesn't play nice with mocks cls.previous_signal_receivers = indicator_document_updated.receivers indicator_document_updated.receivers = [] cls.engine = connection_manager.get_engine('default') def setUp(self): self.fakedb = FakeCouchDb() MockIndicators.set_db(self.fakedb) MockIndicatorsWithGetters.set_db(self.fakedb) MockDoc.set_db(self.fakedb) MockIndicatorsSql.set_db(self.fakedb) rebuild_table(self.engine, None, MockIndicatorsSql) rebuild_table(self.engine, None, MockIndicatorsSqlWithFlatFields) @classmethod def tearDownClass(cls): indicator_document_updated.receivers = cls.previous_signal_receivers super(FluffTest, cls).tearDownClass() def tearDown(self): with self.engine.begin() as connection: MockIndicatorsSql()._table.drop(connection, checkfirst=True) MockIndicatorsSqlWithFlatFields()._table.drop(connection, checkfirst=True) self.engine.dispose() def test_calculator_base_classes(self): # Base0 self.assertEqual(Base0._fluff_emitters, set([ 'base_0_emitter', ])) self.assertEqual(Base0._fluff_filters, set([ 'base_0_filter', ])) # Base1 self.assertEqual(Base1._fluff_emitters, set([ 'base_0_emitter', 'base_1_emitter', ])) self.assertEqual(Base1._fluff_filters, set([ 'base_0_filter', 'base_1_filter', ])) # Base2 self.assertEqual(Base2._fluff_emitters, set([ 'base_0_emitter', 'base_2_emitter', ])) self.assertEqual(Base2._fluff_filters, set([ 'base_0_filter', 'base_2_filter', ])) # Base2 self.assertEqual(Base3._fluff_emitters, set([ 'base_0_emitter', 'base_1_emitter', 'base_2_emitter', 'base_3_emitter', ])) self.assertEqual(Base3._fluff_filters, set([ 'base_0_filter', 'base_1_filter', 'base_2_filter', 'base_3_filter', ])) def test_indicator_classes(self): self.assertEquals(Indicators1._calculators.keys(), ['base0']) self.assertEquals(Indicators2._calculators.keys(), ['base1', 'base2']) def test_indicator_calculation(self): actions = [dict(date="2012-09-23", x=2), dict(date="2012-09-24", x=3)] doc = dict( actions=actions, get_id="123", domain="mock", owner_id="test_owner", doc_type='MockDoc' ) for cls in [MockIndicators, MockIndicatorsWithGetters]: classname = cls.__name__ pillow = cls.pillow()() pillow.process_change(change_from_couch_row({'changes': [], 'id': '123', 'seq': 1, 'doc': doc})) indicator = self.fakedb.mock_docs.get("%s-123" % classname, None) self.assertIsNotNone(indicator) self.assertEqual(11, len(indicator)) self.assertEqual(8, len(indicator['value_week'])) self.assertIn("value_week", indicator) self.assertIn("date", indicator["value_week"]) self.assertIn("null", indicator["value_week"]) self.assertIn("date_value", indicator["value_week"]) self.assertIn("null_value", indicator["value_week"]) self.assertEqual({'date': "2012-09-23", 'value': 1, 'group_by': None}, indicator["value_week"]["date"][0]) self.assertEqual({'date': "2012-09-24", 'value': 1, 'group_by': None}, indicator["value_week"]["date"][1]) self.assertEqual({'date': None, 'value': 1, 'group_by': None}, indicator["value_week"]["null"][0]) self.assertEqual({'date': "2012-09-23", 'value': 2, 'group_by': None}, indicator["value_week"]["date_value"][0]) self.assertEqual({'date': "2012-09-24", 'value': 3, 'group_by': None}, indicator["value_week"]["date_value"][1]) self.assertEqual({'date': None, 'value': 2, 'group_by': None}, indicator["value_week"]["null_value"][0]) self.assertEqual(dict(date='2013-01-01', group_by=['abc', 'xyz'], value=3), indicator["value_week"]["group_list"][0]) self.assertEqual(dict(date='2013-01-01', group_by=['abc', '123'], value=2), indicator["value_week"]["group_val"][0]) self.assertEqual(dict(date='2013-01-01', group_by=['abc', '123'], value=1), indicator["value_week"]["group_no_val"][0]) def test_calculator_calculate(self): calc = ValueCalculator(WEEK) calc.fluff = MockIndicators values = calc.calculate(MockDoc.wrap(dict(actions=[dict(date="2012-09-23", x=2), dict(date="2012-09-24", x=3)]))) self.assertEquals(len(values.keys()), 8) self.assertEquals(values['null_value'], [dict(date=None, value=2, group_by=None)]) self.assertEquals(values['date_value'], [ dict(date=date(2012, 9, 23), value=2, group_by=None), dict(date=date(2012, 9, 24), value=3, group_by=None)]) self.assertEquals(values['date'], [ dict(date=date(2012, 9, 23), value=1, group_by=None), dict(date=date(2012, 9, 24), value=1, group_by=None)]) self.assertEquals(values['null'], [dict(date=None, value=1, group_by=None)]) self.assertEquals(values['group_list'], [dict(date=date(2013, 1, 1), group_by=['abc', 'xyz'], value=3)]) self.assertEquals(values['group_val'], [dict(date=date(2013, 1, 1), group_by=['abc', '123'], value=2)]) self.assertEquals(values['group_no_val'], [dict(date=date(2013, 1, 1), group_by=['abc', '123'], value=1)]) self.assertEquals(values['group_null'], [dict(date=None, group_by=['abc', 'xyz'], value=1)]) def test_calculator_get_result(self): key = ['a', 'b'] now = datetime.utcnow().date() start = json_format_date(now - WEEK) end = json_format_date(now) for cls in [MockIndicators, MockIndicatorsWithGetters]: classname = cls.__name__ self.fakedb.add_view('fluff/generic', [ ( {'reduce': True, 'key': [classname, 'a', 'b', 'value_week', 'null', None], 'wrap_doc': True}, [{"key": None, "value": {"sum": 3}}] ), ( {'reduce': True, 'key': [classname, 'a', 'b', 'value_week', 'null_value', None], 'wrap_doc': True}, [{"key": None, "value": {"max": 8}}] ), ( {'startkey': [classname, 'a', 'b', 'value_week', 'date', start], 'endkey': [classname, 'a', 'b', 'value_week', 'date', end], 'reduce': True, 'wrap_doc': True}, [{"key": None, "value": {"count": 7}}] ), ( {'startkey': [classname, 'a', 'b', 'value_week', 'date_value', start], 'endkey': [classname, 'a', 'b', 'value_week', 'date_value', end], 'reduce': True, 'wrap_doc': True}, [{"key": None, "value": {"sum": 11}}] ) ]) value = cls.get_result('value_week', key, reduce=True) self.assertEqual(value['null'], 3) self.assertEqual(value['date'], 7) self.assertEqual(value['date_value'], 11) self.assertEqual(value['null_value'], 8) def test_indicator_diff_new(self): for cls in [MockIndicators, MockIndicatorsWithGetters]: classname = cls.__name__ doc = cls( domain="mock", owner_id="123", value_week=dict( date=[[date(2012, 02, 23), 1]], null=[], date_value=[], null_value=[[None, 3]] ) ) diff = doc.diff(None) self.maxDiff = None expected = dict(domains=['mock'], database=cls.Meta.app_label, doc_type=classname, group_values=['mock', '123'], group_names=['domain', 'owner_id'], group_type_map={'domain': 'integer', 'owner_id': 'string'}, indicator_changes=[ dict(calculator='value_week', emitter='date', emitter_type='date', reduce_type='count', values=[dict(date=date(2012, 2, 23), value=1, group_by=None)]), dict(calculator='value_week', emitter='null_value', emitter_type='null', reduce_type='max', values=[dict(date=None, value=3, group_by=None)]) ], all_indicators=self.all_indicators()) self.assertEqual(expected, diff)
class Test(TestCase): def setUp(self): self.fakedb = FakeCouchDb() MockIndicators.set_db(self.fakedb) MockIndicatorsWithGetters.set_db(self.fakedb) MockDoc.set_db(self.fakedb) def test_calculator_base_classes(self): # Base0 self.assertEqual(Base0._fluff_emitters, set([ 'base_0_emitter', ])) self.assertEqual(Base0._fluff_filters, set([ 'base_0_filter', ])) # Base1 self.assertEqual(Base1._fluff_emitters, set([ 'base_0_emitter', 'base_1_emitter', ])) self.assertEqual(Base1._fluff_filters, set([ 'base_0_filter', 'base_1_filter', ])) # Base2 self.assertEqual(Base2._fluff_emitters, set([ 'base_0_emitter', 'base_2_emitter', ])) self.assertEqual(Base2._fluff_filters, set([ 'base_0_filter', 'base_2_filter', ])) # Base2 self.assertEqual( Base3._fluff_emitters, set([ 'base_0_emitter', 'base_1_emitter', 'base_2_emitter', 'base_3_emitter', ])) self.assertEqual( Base3._fluff_filters, set([ 'base_0_filter', 'base_1_filter', 'base_2_filter', 'base_3_filter', ])) def test_indicator_classes(self): self.assertEquals(Indicators1._calculators.keys(), ['base0']) self.assertEquals(Indicators2._calculators.keys(), ['base1', 'base2']) def test_indicator_calculation(self): actions = [dict(date="2012-09-23", x=2), dict(date="2012-09-24", x=3)] self.fakedb.mock_docs["123"] = dict(actions=actions, get_id="123", domain="mock", owner_id="test_owner") for cls in [MockIndicators, MockIndicatorsWithGetters]: classname = cls.__name__ pillow = cls.pillow()() pillow.processor({'changes': [], 'id': '123', 'seq': 1}) indicator = self.fakedb.mock_docs.get("%s-123" % classname, None) self.assertIsNotNone(indicator) self.assertEqual(9, len(indicator)) self.assertEqual(8, len(indicator['value_week'])) self.assertIn("value_week", indicator) self.assertIn("date", indicator["value_week"]) self.assertIn("null", indicator["value_week"]) self.assertIn("date_value", indicator["value_week"]) self.assertIn("null_value", indicator["value_week"]) self.assertEqual( { 'date': "2012-09-23", 'value': 1, 'group_by': None }, indicator["value_week"]["date"][0]) self.assertEqual( { 'date': "2012-09-24", 'value': 1, 'group_by': None }, indicator["value_week"]["date"][1]) self.assertEqual({ 'date': None, 'value': 1, 'group_by': None }, indicator["value_week"]["null"][0]) self.assertEqual( { 'date': "2012-09-23", 'value': 2, 'group_by': None }, indicator["value_week"]["date_value"][0]) self.assertEqual( { 'date': "2012-09-24", 'value': 3, 'group_by': None }, indicator["value_week"]["date_value"][1]) self.assertEqual({ 'date': None, 'value': 2, 'group_by': None }, indicator["value_week"]["null_value"][0]) self.assertEqual( dict(date='2013-01-01', group_by=['abc', 'xyz'], value=3), indicator["value_week"]["group_list"][0]) self.assertEqual( dict(date='2013-01-01', group_by=['abc'], value=2), indicator["value_week"]["group_val"][0]) self.assertEqual( dict(date='2013-01-01', group_by=['abc'], value=1), indicator["value_week"]["group_no_val"][0]) def test_calculator_calculate(self): calc = ValueCalculator(WEEK) values = calc.calculate( MockDoc.wrap( dict(actions=[ dict(date="2012-09-23", x=2), dict(date="2012-09-24", x=3) ]))) self.assertEquals(len(values.keys()), 8) self.assertEquals(values['null_value'], [dict(date=None, value=2, group_by=None)]) self.assertEquals(values['date_value'], [ dict(date=date(2012, 9, 23), value=2, group_by=None), dict(date=date(2012, 9, 24), value=3, group_by=None) ]) self.assertEquals(values['date'], [ dict(date=date(2012, 9, 23), value=1, group_by=None), dict(date=date(2012, 9, 24), value=1, group_by=None) ]) self.assertEquals(values['null'], [dict(date=None, value=1, group_by=None)]) self.assertEquals( values['group_list'], [dict(date=date(2013, 1, 1), group_by=['abc', 'xyz'], value=3)]) self.assertEquals( values['group_val'], [dict(date=date(2013, 1, 1), group_by=['abc'], value=2)]) self.assertEquals( values['group_no_val'], [dict(date=date(2013, 1, 1), group_by=['abc'], value=1)]) self.assertEquals(values['group_null'], [dict(date=None, group_by=['abc'], value=1)]) def test_calculator_get_result(self): key = ['a', 'b'] now = datetime.utcnow().date() start = json_format_date(now - WEEK) end = json_format_date(now) for cls in [MockIndicators, MockIndicatorsWithGetters]: classname = cls.__name__ self.fakedb.add_view('fluff/generic', [ ({ 'reduce': True, 'key': [classname, 'a', 'b', 'value_week', 'null', None] }, [{ "key": None, "value": { "sum": 3 } }]), ({ 'reduce': True, 'key': [classname, 'a', 'b', 'value_week', 'null_value', None] }, [{ "key": None, "value": { "max": 8 } }]), ({ 'startkey': [classname, 'a', 'b', 'value_week', 'date', start], 'endkey': [classname, 'a', 'b', 'value_week', 'date', end], 'reduce': True }, [{ "key": None, "value": { "count": 7 } }]), ({ 'startkey': [classname, 'a', 'b', 'value_week', 'date_value', start], 'endkey': [classname, 'a', 'b', 'value_week', 'date_value', end], 'reduce': True }, [{ "key": None, "value": { "sum": 11 } }]) ]) value = cls.get_result('value_week', key, reduce=True) self.assertEqual(value['null'], 3) self.assertEqual(value['date'], 7) self.assertEqual(value['date_value'], 11) self.assertEqual(value['null_value'], 8) def test_indicator_diff_new(self): for cls in [MockIndicators, MockIndicatorsWithGetters]: classname = cls.__name__ doc = cls(domain="mock", owner_id="123", value_week=dict(date=[[date(2012, 02, 23), 1]], null=[], date_value=[], null_value=[[None, 3]])) diff = doc.diff(None) self.maxDiff = None expected = dict( domains=['test'], database=cls.Meta.app_label, doc_type=classname, group_values=['mock', '123'], group_names=['domain', 'owner_id'], group_type_map={ 'domain': 'integer', 'owner_id': 'string' }, indicator_changes=[ dict(calculator='value_week', emitter='date', emitter_type='date', reduce_type='count', values=[ dict(date=date(2012, 2, 23), value=1, group_by=None) ]), dict(calculator='value_week', emitter='null_value', emitter_type='null', reduce_type='max', values=[dict(date=None, value=3, group_by=None)]) ], all_indicators=self.all_indicators()) self.assertEqual(expected, diff)
class Test(TestCase): def setUp(self): self.fakedb = FakeCouchDb() MockIndicators.set_db(self.fakedb) MockIndicatorsWithGetters.set_db(self.fakedb) MockDoc.set_db(self.fakedb) def test_calculator_base_classes(self): # Base0 self.assertEqual(Base0._fluff_emitters, set([ 'base_0_emitter', ])) self.assertEqual(Base0._fluff_filters, set([ 'base_0_filter', ])) # Base1 self.assertEqual(Base1._fluff_emitters, set([ 'base_0_emitter', 'base_1_emitter', ])) self.assertEqual(Base1._fluff_filters, set([ 'base_0_filter', 'base_1_filter', ])) # Base2 self.assertEqual(Base2._fluff_emitters, set([ 'base_0_emitter', 'base_2_emitter', ])) self.assertEqual(Base2._fluff_filters, set([ 'base_0_filter', 'base_2_filter', ])) # Base2 self.assertEqual(Base3._fluff_emitters, set([ 'base_0_emitter', 'base_1_emitter', 'base_2_emitter', 'base_3_emitter', ])) self.assertEqual(Base3._fluff_filters, set([ 'base_0_filter', 'base_1_filter', 'base_2_filter', 'base_3_filter', ])) def test_indicator_classes(self): self.assertEquals(Indicators1._calculators.keys(), ['base0']) self.assertEquals(Indicators2._calculators.keys(), ['base1', 'base2']) def test_indicator_calculation(self): actions = [dict(date="2012-09-23", x=2), dict(date="2012-09-24", x=3)] self.fakedb.mock_docs["123"] = dict(actions=actions, get_id="123", domain="mock", owner_id="test_owner") for cls in [MockIndicators, MockIndicatorsWithGetters]: classname = cls.__name__ pillow = cls.pillow()() pillow.processor({'changes': [], 'id': '123', 'seq': 1}) indicator = self.fakedb.mock_docs.get("%s-123" % classname, None) self.assertIsNotNone(indicator) self.assertEqual(9, len(indicator)) self.assertEqual(8, len(indicator['value_week'])) self.assertIn("value_week", indicator) self.assertIn("date", indicator["value_week"]) self.assertIn("null", indicator["value_week"]) self.assertIn("date_value", indicator["value_week"]) self.assertIn("null_value", indicator["value_week"]) self.assertEqual({'date': "2012-09-23", 'value': 1, 'group_by': None}, indicator["value_week"]["date"][0]) self.assertEqual({'date': "2012-09-24", 'value': 1, 'group_by': None}, indicator["value_week"]["date"][1]) self.assertEqual({'date': None, 'value': 1, 'group_by': None}, indicator["value_week"]["null"][0]) self.assertEqual({'date': "2012-09-23", 'value': 2, 'group_by': None}, indicator["value_week"]["date_value"][0]) self.assertEqual({'date': "2012-09-24", 'value': 3, 'group_by': None}, indicator["value_week"]["date_value"][1]) self.assertEqual({'date': None, 'value': 2, 'group_by': None}, indicator["value_week"]["null_value"][0]) self.assertEqual(dict(date='2013-01-01', group_by=['abc', 'xyz'], value=3), indicator["value_week"]["group_list"][0]) self.assertEqual(dict(date='2013-01-01', group_by=['abc'], value=2), indicator["value_week"]["group_val"][0]) self.assertEqual(dict(date='2013-01-01', group_by=['abc'], value=1), indicator["value_week"]["group_no_val"][0]) def test_calculator_calculate(self): calc = ValueCalculator(WEEK) values = calc.calculate(MockDoc.wrap(dict(actions=[dict(date="2012-09-23", x=2), dict(date="2012-09-24", x=3)]))) self.assertEquals(len(values.keys()), 8) self.assertEquals(values['null_value'], [dict(date=None, value=2, group_by=None)]) self.assertEquals(values['date_value'], [ dict(date=date(2012, 9, 23), value=2, group_by=None), dict(date=date(2012, 9, 24), value=3, group_by=None)]) self.assertEquals(values['date'], [ dict(date=date(2012, 9, 23), value=1, group_by=None), dict(date=date(2012, 9, 24), value=1, group_by=None)]) self.assertEquals(values['null'], [dict(date=None, value=1, group_by=None)]) self.assertEquals(values['group_list'], [dict(date=date(2013, 1, 1), group_by=['abc', 'xyz'], value=3)]) self.assertEquals(values['group_val'], [dict(date=date(2013, 1, 1), group_by=['abc'], value=2)]) self.assertEquals(values['group_no_val'], [dict(date=date(2013, 1, 1), group_by=['abc'], value=1)]) self.assertEquals(values['group_null'], [dict(date=None, group_by=['abc'], value=1)]) def test_calculator_get_result(self): key = ['a', 'b'] now = datetime.utcnow().date() start = json_format_date(now - WEEK) end = json_format_date(now) for cls in [MockIndicators, MockIndicatorsWithGetters]: classname = cls.__name__ self.fakedb.add_view('fluff/generic', [ ( {'reduce': True, 'key': [classname, 'a', 'b', 'value_week', 'null', None]}, [{"key": None, "value": {"sum": 3}}] ), ( {'reduce': True, 'key': [classname, 'a', 'b', 'value_week', 'null_value', None]}, [{"key": None, "value": {"max": 8}}] ), ( {'startkey': [classname, 'a', 'b', 'value_week', 'date', start], 'endkey': [classname, 'a', 'b', 'value_week', 'date', end], 'reduce': True}, [{"key": None, "value": {"count": 7}}] ), ( {'startkey': [classname, 'a', 'b', 'value_week', 'date_value', start], 'endkey': [classname, 'a', 'b', 'value_week', 'date_value', end], 'reduce': True}, [{"key": None, "value": {"sum": 11}}] ) ]) value = cls.get_result('value_week', key, reduce=True) self.assertEqual(value['null'], 3) self.assertEqual(value['date'], 7) self.assertEqual(value['date_value'], 11) self.assertEqual(value['null_value'], 8) def test_indicator_diff_new(self): for cls in [MockIndicators, MockIndicatorsWithGetters]: classname = cls.__name__ doc = cls( domain="mock", owner_id="123", value_week=dict( date=[[date(2012, 02, 23), 1]], null=[], date_value=[], null_value=[[None, 3]] ) ) diff = doc.diff(None) self.maxDiff = None expected = dict(domains=['test'], database=cls.Meta.app_label, doc_type=classname, group_values=['mock', '123'], group_names=['domain', 'owner_id'], group_type_map={'domain': 'integer', 'owner_id': 'string'}, indicator_changes=[ dict(calculator='value_week', emitter='date', emitter_type='date', reduce_type='count', values=[dict(date=date(2012, 2, 23), value=1, group_by=None)]), dict(calculator='value_week', emitter='null_value', emitter_type='null', reduce_type='max', values=[dict(date=None, value=3, group_by=None)]) ], all_indicators=self.all_indicators()) self.assertEqual(expected, diff)
class TestGetOrCreateSchema(SimpleTestCase): def setUp(self): self.db = FormQuestionSchema.get_db() self.fakedb = FakeCouchDb() FormQuestionSchema.set_db(self.fakedb) self.domain = 'test' self.app_id = '123' self.xmlns = 'this_xmlns' self.schema = FormQuestionSchema(domain=self.domain, app_id=self.app_id, xmlns=self.xmlns) def tearDown(self): FormQuestionSchema.set_db(self.db) def test_required_props(self): with self.assertRaises(BadValueError): schema = FormQuestionSchema(app_id=self.app_id, xmlns=self.xmlns) schema.save() # with self.assertRaises(BadValueError): # schema = FormQuestionSchema(domain=self.domain, xmlns=self.xmlns) # schema.save() with self.assertRaises(BadValueError): schema = FormQuestionSchema(domain=self.domain, app_id=self.app_id) schema.save() def test_unique_key(self): self.schema.save() dupe_schema = FormQuestionSchema(domain=self.domain, app_id=self.app_id, xmlns=self.xmlns) with self.assertRaises(ResourceConflict): dupe_schema.save() def test_get_existing(self): self.schema.save() schema = FormQuestionSchema.get_or_create(self.domain, self.app_id, self.xmlns) self.assertIsNotNone(schema) self.assertEqual(schema._rev, self.schema._rev) def test_get_new(self): self.schema.save() schema = FormQuestionSchema.get_or_create('new_domain', self.app_id, self.xmlns) self.assertIsNotNone(schema) def test_migrate_old(self): self.schema._id = '123' self.schema.last_processed_version = 12 self.schema.save() second_schema = FormQuestionSchema(domain=self.domain, app_id=self.app_id, xmlns=self.xmlns, _id='1234') second_schema.save() self.assertEqual(len(self.fakedb.mock_docs), 2) self.fakedb.add_view( 'form_question_schema/by_xmlns', [( {'key': [self.domain, self.app_id, self.xmlns], 'include_docs': True}, [ self.schema.to_json(), second_schema.to_json() ] )] ) schema = FormQuestionSchema.get_or_create(self.domain, self.app_id, self.xmlns) self.assertEqual(schema.last_processed_version, self.schema.last_processed_version) self.assertNotEqual(schema.get_id, self.schema.get_id) self.assertNotEqual(schema.get_id, second_schema.get_id) self.assertEqual(len(self.fakedb.mock_docs), 1) self.assertTrue(schema.get_id in self.fakedb.mock_docs)