def test_period_group_query_fails_when_weeks_do_not_start_on_monday(self): multi_group_results = [ { "is": "Monday", "_subgroup": [ {"_week_start_at": d(2013, 4, 1), "_count": 1} ] }, { "is": "also Monday", "_subgroup": [ {"_week_start_at": d(2013, 4, 8), "_count": 1} ] }, { "is": "Tuesday", "_subgroup": [ {"_week_start_at": d(2013, 4, 9), "_count": 1} ] }, ] self.mock_repository.multi_group.return_value = \ multi_group_results try: self.bucket.query(Query.create(period='week', group_by='d')).data() assert_that(False) except ValueError as e: assert_that(str(e), is_( "Weeks MUST start on Monday but got date: 2013-04-09 00:00:00" ))
def test_month_and_group_query(self): self.mock_storage.execute_query.return_value = [ { 'some_group': 'val1', '_month_start_at': d(2013, 1, 1), '_count': 1 }, { 'some_group': 'val1', '_month_start_at': d(2013, 2, 1), '_count': 5 }, { 'some_group': 'val2', '_month_start_at': d(2013, 3, 1), '_count': 2 }, { 'some_group': 'val2', '_month_start_at': d(2013, 4, 1), '_count': 6 }, { 'some_group': 'val2', '_month_start_at': d(2013, 7, 1), '_count': 6 }, ] data = self.data_set.execute_query( Query.create(period=MONTH, group_by=['some_group'])) assert_that(data, has_item(has_entries({"values": has_length(2)}))) assert_that(data, has_item(has_entries({"values": has_length(3)})))
def test_period_group_query_adds_missing_periods_in_correct_order(self): self.mock_storage.execute_query.return_value = [ {'some_group': 'val1', '_week_start_at': d(2013, 1, 14), '_count': 23}, {'some_group': 'val1', '_week_start_at': d(2013, 1, 21), '_count': 41}, {'some_group': 'val2', '_week_start_at': d(2013, 1, 14), '_count': 31}, {'some_group': 'val2', '_week_start_at': d(2013, 1, 28), '_count': 12}, ] data = self.data_set.execute_query( Query.create(period=WEEK, group_by=['some_group'], start_at=d_tz(2013, 1, 7, 0, 0, 0), end_at=d_tz(2013, 2, 4, 0, 0, 0))) assert_that(data, has_item(has_entries({ "some_group": "val1", "values": contains( has_entries({"_start_at": d_tz(2013, 1, 7), "_count": 0}), has_entries({"_start_at": d_tz(2013, 1, 14), "_count": 23}), has_entries({"_start_at": d_tz(2013, 1, 21), "_count": 41}), has_entries({"_start_at": d_tz(2013, 1, 28), "_count": 0}), ), }))) assert_that(data, has_item(has_entries({ "some_group": "val2", "values": contains( has_entries({"_start_at": d_tz(2013, 1, 7), "_count": 0}), has_entries({"_start_at": d_tz(2013, 1, 14), "_count": 31}), has_entries({"_start_at": d_tz(2013, 1, 21), "_count": 0}), has_entries({"_start_at": d_tz(2013, 1, 28), "_count": 12}), ), })))
def test_sorted_week_and_group_query(self): self.mock_storage.execute_query.return_value = [ { 'some_group': 'val1', '_week_start_at': d(2013, 1, 7), '_count': 1 }, { 'some_group': 'val1', '_week_start_at': d(2013, 1, 14), '_count': 5 }, { 'some_group': 'val2', '_week_start_at': d(2013, 1, 7), '_count': 2 }, { 'some_group': 'val2', '_week_start_at': d(2013, 1, 14), '_count': 6 }, ] query = Query.create(period=WEEK, group_by=['some_group'], sort_by=["_count", "descending"]) data = self.data_set.execute_query(query) assert_that( data, contains( has_entries({'some_group': 'val2'}), has_entries({'some_group': 'val1'}), ))
def test_query_with_start_at_and__end_at(self): query = Query.create(end_at=d(2013, 3, 1, 12, 0, 0), start_at=d(2013, 2, 1, 12, 0, 0)) self.bucket.query(query) self.mock_repository.find.assert_called_with(query, sort=None, limit=None)
def test_sorted_week_and_group_query_with_limit(self): self.mock_repository.multi_group.return_value = [ { "some_group": "val1", "_count": 6, "_group_count": 2, "_subgroup": [ { "_week_start_at": d(2013, 1, 7, 0, 0, 0), "_count": 1 }, { "_week_start_at": d(2013, 1, 14, 0, 0, 0), "_count": 5 } ] } ] query = Query.create(period="week", group_by="some_group", sort_by=["_count", "descending"], limit=1, collect=[]) self.bucket.query(query) self.mock_repository.multi_group.assert_called_with( "some_group", "_week_start_at", query, sort=["_count", "descending"], limit=1, collect=[])
def test_period_group_query_fails_when_weeks_do_not_start_on_monday(self): multi_group_results = [ { "is": "Monday", "_subgroup": [ {"_week_start_at": d(2013, 4, 1), "_count": 1} ] }, { "is": "also Monday", "_subgroup": [ {"_week_start_at": d(2013, 4, 8), "_count": 1} ] }, { "is": "Tuesday", "_subgroup": [ {"_week_start_at": d(2013, 4, 9), "_count": 1} ] }, ] self.mock_repository.multi_group.return_value = \ multi_group_results query = Query.create(period=WEEK, group_by='d') assert_raises(ValueError, self.bucket.query, query)
def test_filling_data_for_missing_week_periods(self): stub_doc_1 = {"_week_start_at": d(2013, 4, 1), "_count": 5} stub_doc_2 = {"_week_start_at": d(2013, 4, 15), "_count": 5} period_data = PeriodData([stub_doc_1, stub_doc_2], period="week") period_data.fill_missing_periods(d(2013, 4, 1), d(2013, 4, 16)) assert_that(period_data.data(), has_length(3))
def test_period_group_query_adds_missing_periods_in_correct_order(self): self.mock_repository.multi_group.return_value = [ { "some_group": "val1", "_count": 6, "_group_count": 2, "_subgroup": [ { "_week_start_at": d(2013, 1, 14, 0, 0, 0), "_count": 23 }, { "_week_start_at": d(2013, 1, 21, 0, 0, 0), "_count": 41 } ] }, { "some_group": "val2", "_count": 8, "_group_count": 2, "_subgroup": [ { "_week_start_at": d(2013, 1, 14, 0, 0, 0), "_count": 31 }, { "_week_start_at": d(2013, 1, 28, 0, 0, 0), "_count": 12 } ] } ] query_result = self.bucket.query( Query.create(period="week", group_by="some_group", start_at=d_tz(2013, 1, 7, 0, 0, 0), end_at=d_tz(2013, 2, 4, 0, 0, 0))).data() assert_that(query_result, has_item(has_entries({ "some_group": "val1", "values": contains( has_entries({"_start_at": d_tz(2013, 1, 7), "_count": 0}), has_entries({"_start_at": d_tz(2013, 1, 14), "_count": 23}), has_entries({"_start_at": d_tz(2013, 1, 21), "_count": 41}), has_entries({"_start_at": d_tz(2013, 1, 28), "_count": 0}), ), }))) assert_that(query_result, has_item(has_entries({ "some_group": "val2", "values": contains( has_entries({"_start_at": d_tz(2013, 1, 7), "_count": 0}), has_entries({"_start_at": d_tz(2013, 1, 14), "_count": 31}), has_entries({"_start_at": d_tz(2013, 1, 21), "_count": 0}), has_entries({"_start_at": d_tz(2013, 1, 28), "_count": 12}), ), })))
def test_adding_multiple_mongo_documents(self): stub_document_1 = { "_subgroup": [ {"_week_start_at": d(2013, 4, 1), "_count": 5} ] } stub_document_2 = { "_subgroup": [ {"_week_start_at": d(2013, 4, 1), "_count": 5} ] } data = PeriodGroupedData([stub_document_1, stub_document_2], WEEK) assert_that(data.data(), has_length(2))
def test_that_it_returns_the_end_of_the_current_month(self): some_datetime = d(2013, 10, 4, 10, 23, 43) some_other_datetime = d(2013, 10, 4) end = MONTH.end(some_datetime) other_end = MONTH.end(some_other_datetime) assert_that(end, is_(d(2013, 11, 1))) assert_that(other_end, is_(d(2013, 11, 1)))
def test_that_middle_of_quarters_are_invalid(self): middle_first_quarter = d(2013, 1, 10, 0, 0, 0) middle_second_quarter = d(2013, 4, 15, 0, 0, 0) middle_third_quarter = d(2013, 7, 20, 0, 0, 0) middle_fourth_quarter = d(2013, 10, 13, 0, 0, 0) assert_that(QUARTER.valid_start_at(middle_first_quarter), is_(False)) assert_that(QUARTER.valid_start_at(middle_second_quarter), is_(False)) assert_that(QUARTER.valid_start_at(middle_third_quarter), is_(False)) assert_that(QUARTER.valid_start_at(middle_fourth_quarter), is_(False))
def test_key1_is_pulled_to_the_top_of_outer_group(self): self.setUpPeopleLocationData() results = self.repo.multi_group("_week_start_at", "person", Query.create()) assert_that(results, has_item(has_entry("_week_start_at", d(2013, 3, 11)))) assert_that(results, has_item(has_entry("_week_start_at", d(2013, 3, 25))))
def test_that_beginning_of_quarters_are_valid(self): first_quarter = d(2013, 1, 1, 0, 0, 0) second_quarter = d(2013, 4, 1, 0, 0, 0) third_quarter = d(2013, 7, 1, 0, 0, 0) fourth_quarter = d(2013, 10, 1, 0, 0, 0) assert_that(QUARTER.valid_start_at(first_quarter), is_(True)) assert_that(QUARTER.valid_start_at(second_quarter), is_(True)) assert_that(QUARTER.valid_start_at(third_quarter), is_(True)) assert_that(QUARTER.valid_start_at(fourth_quarter), is_(True))
def test_key1_is_pulled_to_the_top_of_outer_group(self): self.setUpPeopleLocationData() results = self.repo.multi_group("_week_start_at", "person", Query.create()) assert_that(results, has_item(has_entry( "_week_start_at", d(2013, 3, 11) ))) assert_that(results, has_item(has_entry( "_week_start_at", d(2013, 3, 25) )))
def test_end_of_quarter_is_beginning_of_next_quarter(self): first_quarter = d(2013, 1, 1, 0, 0, 0) second_quarter = d(2013, 4, 1, 0, 0, 0) third_quarter = d(2013, 7, 1, 0, 0, 0) fourth_quarter = d(2013, 10, 1, 0, 0, 0) first_quarter_2014 = d(2014, 1, 1, 0, 0, 0) assert_that(QUARTER.end(first_quarter.replace(hour=1)), is_(second_quarter)) assert_that(QUARTER.end(second_quarter.replace(hour=1)), is_(third_quarter)) assert_that(QUARTER.end(third_quarter.replace(hour=1)), is_(fourth_quarter)) assert_that(QUARTER.end(fourth_quarter.replace(hour=1)), is_(first_quarter_2014))
def test_period_datum_week_start_at_should_be_monday(self): stub_doc = {"_week_start_at": d(2013, 5, 4), "_count": 0} try: period_data = PeriodData([stub_doc], period="week") assert_that(False, "expected exception") except ValueError as e: assert_that( str(e), is_("Weeks MUST start on Monday but got date:" " " + str(d(2013, 5, 4))))
def test_period_query_fails_when_weeks_do_not_start_on_monday(self): self.mock_storage.execute_query.return_value = [ {"_week_start_at": d(2013, 1, 7, 0, 0, 0), "_count": 3}, {"_week_start_at": d(2013, 1, 8, 0, 0, 0), "_count": 1}, ] assert_raises( ValueError, self.data_set.execute_query, Query.create(period=WEEK) )
def test_period_query_fails_when_months_do_not_start_on_the_1st(self): self.mock_storage.execute_query.return_value = [ {"_month_start_at": d(2013, 1, 7, 0, 0, 0), "_count": 3}, {"_month_start_at": d(2013, 2, 8, 0, 0, 0), "_count": 1}, ] assert_raises( ValueError, self.data_set.execute_query, Query.create(period=MONTH) )
def test_month_query(self): self.mock_repository.group.return_value = [ {"_month_start_at": d(2013, 4, 1), "_count": 1}, {"_month_start_at": d(2013, 5, 1), "_count": 3} ] query = Query.create(period="month") query_result = self.bucket.query(query).data() self.mock_repository.group.assert_called_once_with( "_month_start_at", query, sort=['_month_start_at', 'ascending'], limit=None, collect=[])
def test_period_query_fails_when_months_do_not_start_on_the_1st(self): self.mock_repository.group.return_value = [ {"_month_start_at": d(2013, 1, 7, 0, 0, 0), "_count": 3}, {"_month_start_at": d(2013, 2, 8, 0, 0, 0), "_count": 1}, ] self.assertRaises( ValueError, self.bucket.query, Query.create(period='month') )
def test_multi_group_is_sorted_by_inner_key(self): self.setUpPeopleLocationData() results = self.repo.multi_group("person", "_week_start_at", Query.create()) assert_that(results, has_item(has_entries({ "person": "John", "_subgroup": contains( has_entry("_week_start_at", d(2013, 3, 11)), has_entry("_week_start_at", d(2013, 3, 18)), ) })))
def test_period_datum_week_start_at_should_be_monday(self): stub_doc = { "_week_start_at": d(2013, 5, 4), "_count": 0 } try: period_data = PeriodData([stub_doc], period="week") assert_that(False, "expected exception") except ValueError as e: assert_that(str(e), is_("Weeks MUST start on Monday but got date:" " " + str(d(2013, 5, 4))))
def test_filling_data_for_missing_month_periods(self): stub_doc_1 = { "_month_start_at": d(2013, 4, 1), "_count": 5 } stub_doc_2 = { "_month_start_at": d(2013, 6, 1), "_count": 6 } period_data = PeriodData([stub_doc_1, stub_doc_2], period=MONTH) period_data.fill_missing_periods(d(2013, 4, 1), d(2013, 6, 2)) assert_that(period_data.data(), has_length(3))
def test_filling_data_for_missing_month_periods(self): stub_doc_1 = { "_month_start_at": d(2013, 4, 1), "_count": 5 } stub_doc_2 = { "_month_start_at": d(2013, 6, 1), "_count": 6 } period_data = PeriodData([stub_doc_1, stub_doc_2], period="month") period_data.fill_missing_periods(d(2013, 4, 1), d(2013, 6, 2)) assert_that(period_data.data(), has_length(3))
def test_filling_data_for_missing_week_periods(self): stub_doc_1 = { "_week_start_at": d(2013, 4, 1), "_count": 5 } stub_doc_2 = { "_week_start_at": d(2013, 4, 15), "_count": 5 } period_data = PeriodData([stub_doc_1, stub_doc_2], period="week") period_data.fill_missing_periods(d(2013, 4, 1), d(2013, 4, 16)) assert_that(period_data.data(), has_length(3))
def test_sorted_week_and_group_query_with_limit(self): self.mock_storage.execute_query.return_value = [ {'some_group': 'val1', '_week_start_at': d(2013, 1, 7), '_count': 1}, {'some_group': 'val2', '_week_start_at': d(2013, 1, 14), '_count': 5}, ] query = Query.create(period=WEEK, group_by=['some_group'], sort_by=["_count", "descending"], limit=1, collect=[]) data = self.data_set.execute_query(query) assert_that(data, contains( has_entries({'some_group': 'val2'}) ))
def test_filled_data_without_collect(self): stub_document = { "_subgroup": [{ "_month_start_at": d(2013, 9, 1), "_count": 1 }] } stub_collect = None data = PeriodGroupedData([stub_document], MONTH) data.fill_missing_periods(d(2013, 7, 1), d(2013, 10, 1), stub_collect) values = data.data()[0]["values"] assert_that(values, has_length(3))
def test_filling_missing_months(self): stub_document = { "_subgroup": [{ "_month_start_at": d(2013, 4, 1), "_count": 1 }, { "_month_start_at": d(2013, 6, 1), "_count": 1 }] } data = MonthlyGroupedData([stub_document]) data.fill_missing_months(d(2013, 4, 1), d(2013, 6, 2)) values = data.data()[0]["values"] assert_that(values, has_length(3))
def test_period_query_adds_missing_periods_in_correct_order(self): self.mock_storage.execute_query.return_value = [ { "_week_start_at": d(2013, 1, 14, 0, 0, 0), "_count": 32 }, { "_week_start_at": d(2013, 1, 21, 0, 0, 0), "_count": 45 }, { "_week_start_at": d(2013, 2, 4, 0, 0, 0), "_count": 17 }, ] result = self.data_set.execute_query( Query.create(period=WEEK, start_at=d_tz(2013, 1, 7, 0, 0, 0), end_at=d_tz(2013, 2, 18, 0, 0, 0))) assert_that( result, contains( has_entries({ "_start_at": d_tz(2013, 1, 7), "_count": 0 }), has_entries({ "_start_at": d_tz(2013, 1, 14), "_count": 32 }), has_entries({ "_start_at": d_tz(2013, 1, 21), "_count": 45 }), has_entries({ "_start_at": d_tz(2013, 1, 28), "_count": 0 }), has_entries({ "_start_at": d_tz(2013, 2, 4), "_count": 17 }), has_entries({ "_start_at": d_tz(2013, 2, 11), "_count": 0 }), ))
def test_month_and_groups_query(self): self.mock_storage.execute_query.return_value = [ {'some_group': 'val1', 'another_group': 'val3', '_month_start_at': d(2013, 1, 1), '_count': 1}, {'some_group': 'val1', 'another_group': 'val3', '_month_start_at': d(2013, 2, 1), '_count': 5}, {'some_group': 'val2', 'another_group': 'val3', '_month_start_at': d(2013, 3, 1), '_count': 2}, {'some_group': 'val2', 'another_group': 'val3', '_month_start_at': d(2013, 4, 1), '_count': 6}, {'some_group': 'val2', 'another_group': 'val3', '_month_start_at': d(2013, 7, 1), '_count': 6}, ] data = self.data_set.execute_query(Query.create(period=MONTH, group_by=['some_group', 'another_group'])) assert_that(data, has_item(has_entries({"values": has_length(2)}))) assert_that(data, has_item(has_entries({"values": has_length(3)})))
def test_adding_multiple_mongo_documents(self): stub_document_1 = { "_subgroup": [{ "_week_start_at": d(2013, 4, 1), "_count": 5 }] } stub_document_2 = { "_subgroup": [{ "_week_start_at": d(2013, 4, 1), "_count": 5 }] } data = PeriodGroupedData([stub_document_1, stub_document_2], WEEK) assert_that(data.data(), has_length(2))
def test_period_datum_week_start_at_should_be_monday(self): stub_doc = { "_week_start_at": d(2013, 5, 4), "_count": 0 } assert_raises(ValueError, PeriodData, [stub_doc], period=WEEK)
def test_filling_missing_months(self): stub_document = { "_subgroup": [ { "_month_start_at": d(2013, 4, 1), "_count": 1 }, { "_month_start_at": d(2013, 6, 1), "_count": 1 }] } data = PeriodGroupedData([stub_document], MONTH) data.fill_missing_periods(d(2013, 4, 1), d(2013, 6, 2)) values = data.data()[0]["values"] assert_that(values, has_length(3))
def test_query_for_data_with_different_missing_fields_some_results(self): self.mongo_collection.save({ "_week_start_at": d(2013, 4, 2, 0, 0, 0), "foo": "1", }) self.mongo_collection.save({"foo": "12", "bar": "2"}) self.mongo_collection.save({ "_week_start_at": d(2013, 4, 2, 0, 0, 0), "foo": "12", "bar": "2" }) result = self.repo.multi_group("_week_start_at", "bar", Query.create()) assert_that(result, has_item(has_entry("_count", 1))) assert_that(result, has_item(has_entry("_group_count", 1)))
def test_adding_documents_converts_timestamps_to_utc(self): stub_document = { "_timestamp": d(2014, 1, 1) } data = SimpleData([stub_document]) assert_that(data.data(), has_length(1)) assert_that(data.data()[0], has_entry("_timestamp", d_tz(2014, 1, 1)))
def test_adding_more_mongo_documents_to_collection(self): stub_doc = {"_week_start_at": d(2013, 5, 6), "_count": 42} another_stub_doc = {"_week_start_at": d(2013, 5, 13), "_count": 66} period_data = PeriodData([stub_doc, another_stub_doc], period="week") assert_that(len(period_data.data()), is_(2)) assert_that(period_data.data()[0], has_entry("_start_at", d_tz(2013, 5, 6))) assert_that(period_data.data()[0], has_entry("_end_at", d_tz(2013, 5, 13))) assert_that(period_data.data()[1], has_entry("_start_at", d_tz(2013, 5, 13))) assert_that(period_data.data()[1], has_entry("_end_at", d_tz(2013, 5, 20)))
def test_month_and_group_query_with_start_and_end_at(self): self.mock_storage.execute_query.return_value = [ {'some_group': 'val1', '_month_start_at': d(2013, 1, 1), '_count': 1}, {'some_group': 'val1', '_month_start_at': d(2013, 2, 1), '_count': 5}, {'some_group': 'val2', '_month_start_at': d(2013, 3, 1), '_count': 2}, {'some_group': 'val2', '_month_start_at': d(2013, 4, 1), '_count': 6}, {'some_group': 'val2', '_month_start_at': d(2013, 7, 1), '_count': 6}, ] data = self.data_set.execute_query( Query.create(period=MONTH, group_by=['some_group'], start_at=d(2013, 1, 1), end_at=d(2013, 4, 2))) assert_that(data, has_item(has_entries({"values": has_length(4)}))) assert_that(data, has_item(has_entries({"values": has_length(4)}))) first_group = data[0]["values"] assert_that(first_group, has_item(has_entries({ "_start_at": d_tz(2013, 3, 1)}))) assert_that(first_group, has_item(has_entries({ "_start_at": d_tz(2013, 4, 1)}))) first_group = data[1]["values"] assert_that(first_group, has_item(has_entries({ "_start_at": d_tz(2013, 1, 1)}))) assert_that(first_group, has_item(has_entries({ "_start_at": d_tz(2013, 2, 1)})))
def test_month_and_group_query(self): self.mock_repository.multi_group.return_value = [ { "some_group": "val1", "_count": 6, "_group_count": 2, "_subgroup": [ { "_month_start_at": d(2013, 1, 1, 0, 0, 0), "_count": 1 }, { "_month_start_at": d(2013, 2, 1, 0, 0, 0), "_count": 5 } ] }, { "some_group": "val2", "_count": 8, "_group_count": 2, "_subgroup": [ { "_month_start_at": d(2013, 3, 1, 0, 0, 0), "_count": 2 }, { "_month_start_at": d(2013, 4, 1, 0, 0, 0), "_count": 6 }, { "_month_start_at": d(2013, 7, 1, 0, 0, 0), "_count": 6 } ] } ] query_result = self.bucket.query(Query.create(period=MONTH, group_by="some_group")) data = query_result.data() assert_that(data, has_item(has_entries({"values": has_length(2)}))) assert_that(data, has_item(has_entries({"values": has_length(3)})))
def test_returned_data_should_be_immutable(self): stub_doc = {"_timestamp": d(2014, 1, 1)} data = SimpleData([stub_doc]) another_data = data.data() try: another_data.append({"even_more_nonsense": True}) assert_that(False, "expected an exception") except AttributeError as e: assert_that(str(e), "'tuple' object has no attribute append")
def test_month_start_at_gets_expanded_into_start_and_end_fields(self): stub_document = { "_subgroup": [{ "_month_start_at": d(2013, 4, 1), "_count": 1 }]} data = PeriodGroupedData([stub_document], MONTH) values = data.data()[0]['values'] assert_that(values, has_length(1))
def test_that_it_truncates_the_time_part(self): some_datetime = d(2013, 5, 7, 10, 12, 13) start = MONTH.start(some_datetime) assert_that(start.hour, is_(0)) assert_that(start.minute, is_(0)) assert_that(start.second, is_(0)) assert_that(start.microsecond, is_(0))
def test_returned_data_should_be_immutable(self): stub_doc = {"_week_start_at": d(2013, 5, 6), "_count": 42} period_data = PeriodData([stub_doc], period="week") the_data = period_data.data() try: the_data.append({"nonsense": True}) assert_that(False, "expected an exception") except AttributeError as e: assert_that(str(e), "'tuple' object has no attribute append")
def test_period_query_for_data_with_no__week_start_at(self): self.mongo_collection.save({ "_week_start_at": d(2013, 4, 2, 0, 0, 0), "foo": "bar" }) self.mongo_collection.save({"foo": "bar2"}) result = self.repo.group('_week_start_at', Query.create()) assert_that(result, has_item(has_entry("_count", 1)))