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