def test_objects_with_invalid_start_ats_are_disallowed(self):
validation_result = validate_record_data(
{'_start_at': 'this is not a timestamp'})
assert_that(
validation_result,
is_invalid_with_message(
"_start_at is not a valid datetime object"))
def test_queries_with_collect_and_no_group_by_are_disallowed(self):
validation_result_without_group_by = validate_request_args(MultiDict([
("collect", 'foo')
]))
assert_that(validation_result_without_group_by,
is_invalid_with_message(
'collect can be use only with group_by'))
def test_queries_sorting_by_invalid_field_names_are_disallowed(self):
validation_result = validate_request_args({
'sort_by': 'with-hyphen:ascending'
})
assert_that(validation_result, is_invalid_with_message(
'Cannot sort by an invalid field name'
))
def test_queries_with_unrecognized_sort_by_values_are_disallowed(self):
validation_result = validate_request_args({
'sort_by': 'foo:random',
})
assert_that( validation_result, is_invalid_with_message(
'Unrecognised sort direction. Supported directions '
'include: ascending, descending') )
def test_queries_with_code_injection_collect_values_are_disallowed(self):
validation_result_without_group_by = validate_request_args(
MultiDict([("group_by", 'bar'),
("collect", 'something);while(1){myBadFunction()}')]))
assert_that(
validation_result_without_group_by,
is_invalid_with_message("Cannot collect an invalid field name"))
def test_filter_by_prefix_with_invalid_field_names_is_disallowed(self):
validation_result = validate_request_args({
'filter_by_prefix': 'with-hyphen:bar'
})
assert_that(validation_result, is_invalid_with_message(
'Cannot filter by an invalid field name'
))
def test_just_end_at_isnt_allowed(self):
validation_result = validate_request_args({
'end_at': '2000-02-02T00:00:00+00:00',
})
assert_that(validation_result, is_invalid_with_message(
"Use of 'end_at' requires 'start_at' or 'duration'"))
def test_queries_with_period_values_must_be_certain_values(self):
validation_result = validate_request_args({
'period': 'fortnight'
})
assert_that(validation_result, is_invalid_with_message(
"'period' must be one of ['hour', 'day', 'week', 'month']"))
def test_objects_with_invalid_timestamps_are_disallowed(self):
validation_result = validate_record_data({
'_timestamp': 'this is not a timestamp'
})
assert_that(validation_result,
is_invalid_with_message(
"_timestamp is not a valid datetime object"))
def test_queries_with_grouping_on_internal_fields_are_disallowed(self):
validation_result = validate_request_args({"group_by": "_internal"})
assert_that(
validation_result,
is_invalid_with_message(
"Cannot group by internal fields, internal fields "
"start with an underscore"))
def test_queries_grouping_and_collecting_equal_fields_are_disallowed(self):
validation_result_without_group_by = validate_request_args(
MultiDict([("group_by", 'a_field'), ("collect", 'a_field')]))
assert_that(
validation_result_without_group_by,
is_invalid_with_message(
"Cannot collect by a field that is used for group_by"))
def test_objects_with_unrecognised_internal_keys_are_disallowed(self):
validation_result = validate_record_data({
'_unknown': 'whatever'
})
assert_that(validation_result,
is_invalid_with_message(
"_unknown is not a recognised internal field"))
def test_queries_with_collect_and_no_group_by_are_disallowed(self):
validation_result_without_group_by = validate_request_args(
MultiDict([("collect", 'foo')]))
assert_that(
validation_result_without_group_by,
is_invalid_with_message("collect can be use only with either "
"['group_by', 'period']"))
def test_queries_with_grouping_on_internal_fields_are_disallowed(self):
validation_result = validate_request_args({
"group_by": "_internal"
})
assert_that(validation_result, is_invalid_with_message(
"Cannot group by internal fields, internal fields "
"start with an underscore"))
def test_queries_with_period_values_must_be_certain_values(self):
validation_result = validate_request_args({'period': 'fortnight'})
assert_that(
validation_result,
is_invalid_with_message(
"'period' must be one of ['week', 'month']"))
def test_queries_with_no_colon_in_filter_by_are_disallowed(self):
validation_result = validate_request_args({'filter_by': 'bar'})
assert_that(
validation_result,
is_invalid_with_message(
"filter_by must be a field name and value separated by a "
"colon (:) eg. authority:Westminster"))
def test_duration_is_a_valid_number(self):
validation_result = validate_request_args({
'period': 'day',
'duration': 'laierughrelg',
})
assert_that(validation_result, is_invalid_with_message(
"duration must be a positive integer"))
def test_queries_with_sort_by_and_period_are_disallowed(self):
validation_result = validate_request_args({
"sort_by": "foo:ascending",
"period": "week"
})
assert_that( validation_result, is_invalid_with_message(
"Cannot sort for period queries without group_by. "
"Period queries are always sorted by time.") )
def test_queries_with_non_existent_dates_are_disallowed(self):
validation_result = validate_request_args({
'start_at': '2013-13-70T00:00:00Z',
'end_at': '2013-12-70T00:00:00Z'
})
assert_that(validation_result, is_invalid_with_message(
"start_at is not a valid datetime"))
def test_just_duration_isnt_allowed(self):
validation_result = validate_request_args({
'duration': '3',
})
assert_that(validation_result, is_invalid_with_message(
"If 'duration' is requested (for relative time), 'period' is "
"required - please add a period (like 'day', 'month' etc)"))
def test_queries_without_a_colon_in_sort_by_are_disallowed(self):
validation_result = validate_request_args({'sort_by': 'lulz'})
assert_that(
validation_result,
is_invalid_with_message(
'sort_by must be a field name and sort direction separated '
'by a colon (:) eg. authority:ascending'))
def test_queries_with_no_colon_in_filter_by_are_disallowed(self):
validation_result = validate_request_args({
'filter_by': 'bar'
})
assert_that( validation_result, is_invalid_with_message(
"filter_by must be a field name and value separated by a "
"colon (:) eg. authority:Westminster"
))
def test_queries_grouping_and_collecting_equal_fields_are_disallowed(self):
validation_result_without_group_by = validate_request_args(MultiDict([
("group_by", 'a_field'),
("collect", 'a_field')
]))
assert_that(validation_result_without_group_by,
is_invalid_with_message(
"Cannot collect by a field that is used for group_by"))
def test_zero_duration_isnt_allowed(self):
validation_result = validate_request_args({
'period': 'day',
'duration': '0',
})
assert_that(validation_result, is_invalid_with_message(
"'duration' must not be zero"))
def test_queries_with_internal_collect_values_are_disallowed(self):
validation_result_without_group_by = validate_request_args(
MultiDict([("group_by", 'bar'), ("collect", '_internal_field')]))
assert_that(
validation_result_without_group_by,
is_invalid_with_message("Cannot collect internal fields, "
"internal fields start "
"with an underscore"))
def test_negative_dutaion_isnt_allowed(self):
validation_result = validate_request_args({
'period': 'day',
'duration': '-3',
})
assert_that(validation_result, is_invalid_with_message(
"duration must be a positive integer"))
def test_queries_with_badly_formatted_end_at_are_disallowed(self):
assert_that(
validate_request_args({
'start_at': '2000-02-02T00:02:02+00:00',
'end_at': 'foo'
}),
is_invalid_with_message("end_at is not a valid datetime")
)
def test_that_queries_with_invalid_timezone_are_disallowed(self):
validation_result = validate_request_args({
'start_at': '2013-01-01T00:00:00+24:00',
'end_at': '2013-01-08T00:00:00+24:00'
})
assert_that(validation_result, is_invalid_with_message(
"start_at is not a valid datetime"))
def test_that_collect_queries_with_invalid_method_are_disallowed(self):
validation_result = validate_request_args({
'group_by': 'foo',
'collect': 'field:infinity',
})
assert_that(validation_result,
is_invalid_with_message(("Unknown collection method")))
def test_queries_collecting_invalid_field_names_are_disallowed(self):
validation_result = validate_request_args(MultiDict([
("group_by", "bar"),
("collect", "with-hyphen")
]))
assert_that(validation_result, is_invalid_with_message(
"Cannot collect an invalid field name"
))
def test_that_end_at_with_time_other_than_midnight_is_disallowed(self):
validation_result = validate_request_args({
'group_by': 'some_key',
'start_at': '2013-04-01T00:00:00Z',
'end_at': '2013-04-08T00:00:01Z'
})
assert_that(validation_result, is_invalid_with_message(
'end_at must be midnight'))
def test_queries_with_code_injection_collect_values_are_disallowed(self):
validation_result_without_group_by = validate_request_args(MultiDict([
("group_by", 'bar'),
("collect", 'something);while(1){myBadFunction()}')
]))
assert_that(validation_result_without_group_by,
is_invalid_with_message(
"Cannot collect an invalid field name"))
def test_queries_with_badly_formatted_start_at_are_disallowed(self):
assert_that(
validate_request_args({
'start_at': 'i am not a time',
'end_at': 'i am not a time'
}),
is_invalid_with_message("start_at is not a valid datetime")
)
def test_that_period_queries_not_ending_on_monday_are_disallowed(self):
validation_result_not_a_monday = validate_request_args({
'period': 'week',
'start_at': '2013-04-01T00:00:00Z',
'end_at': '2013-04-09T00:00:00Z'
})
assert_that(validation_result_not_a_monday, is_invalid_with_message(
'end_at must be a monday'))
def test_queries_without_a_colon_in_sort_by_are_disallowed(self):
validation_result = validate_request_args({
'sort_by': 'lulz'
})
assert_that(validation_result, is_invalid_with_message(
'sort_by must be a field name and sort direction separated '
'by a colon (:) eg. authority:ascending'))
def test_subsequent_filter_by_parameters_are_validated(self):
validation_result = validate_request_args(MultiDict([
('filter_by', 'foo:bar'),
('filter_by', 'bar'),
]))
assert_that(validation_result, is_invalid_with_message(
"filter_by must be a field name and value separated by a colon "
"(:) eg. authority:Westminster"
))
def test_queries_collecting_internal_fields_are_disallowed(self):
validation_result = validate_request_args(
MultiDict([('group_by', 'not_walruses'), ('collect', '_walrus')]))
assert_that(
validation_result,
is_invalid_with_message(
'Cannot collect internal fields, internal fields start '
'with an underscore'))
def test_queries_with_both_filter_by_params_are_disallowed(self):
validation_result = validate_request_args({
'filter_by': 'bar',
'filter_by_prefix': 'foo'
})
assert_that( validation_result, is_invalid_with_message(
"Cannot use both filter_by "
"and filter_by_prefix in the same query"
))
def test_queries_spanning_less_than_seven_days_are_not_allowed(self):
validation_result = validate_request_args({
'period': 'day',
'start_at': '2000-02-02T00:00:00+00:00',
'end_at': '2000-02-08T00:00:00+00:00'
}, False)
assert_that(validation_result, is_invalid_with_message(
"The minimum time span for a query is 7 days"
))
def test_queries_with_dates_at_middle_of_day_are_not_allowed(self):
validation_result = validate_request_args({
'period': 'day',
'start_at': '2000-02-02T12:00:00+00:00',
'end_at': '2000-02-19T13:00:00+00:00'
}, False)
assert_that(validation_result, is_invalid_with_message(
"start_at must be midnight"
))
def test_that_collect_queries_with_invalid_method_are_disallowed(self):
validation_result = validate_request_args({
'group_by': 'foo',
'collect': 'field:infinity',
})
assert_that(validation_result, is_invalid_with_message(
"Unknown collection method"
))
def test_queries_with_unrecognized_sort_by_values_are_disallowed(self):
validation_result = validate_request_args({
'sort_by': 'foo:random',
})
assert_that(
validation_result,
is_invalid_with_message(
'Unrecognised sort direction. Supported directions '
'include: ascending, descending'))
def test_queries_with_multiple_collect_values_as_code_are_disallowed(self):
validation_result_without_group_by = validate_request_args(
MultiDict([
("group_by", 'bar'),
("collect", '$foo'),
("collect", 'foo'),
]))
assert_that(
validation_result_without_group_by,
is_invalid_with_message("Cannot collect an invalid field name"))
def test_subsequent_collect_values_are_validated(self):
validation_result = validate_request_args(
MultiDict([
("group_by", "foo"),
("collect", "bar"),
("collect", "{}"),
]))
assert_that(
validation_result,
is_invalid_with_message("Cannot collect an invalid field name"))
def test_queries_with_sort_by_and_period_are_disallowed(self):
validation_result = validate_request_args({
"sort_by": "foo:ascending",
"period": "week"
})
assert_that(
validation_result,
is_invalid_with_message(
"Cannot sort for period queries without group_by. "
"Period queries are always sorted by time."))
def test_queries_grouping_week_start_at_with_period_are_disallowed(self):
validation_result = validate_request_args({
'period': 'week',
'group_by': '_week_start_at'
})
assert_that(
validation_result,
is_invalid_with_message(
"Cannot group by internal fields, internal fields "
"start with an underscore"))
def test_that_queries_with_invalid_timezone_are_disallowed(self):
validation_result = validate_request_args({
'start_at':
'2013-01-01T00:00:00+24:00',
'end_at':
'2013-01-08T00:00:00+24:00'
})
assert_that(
validation_result,
is_invalid_with_message("start_at is not a valid datetime"))
def test_queries_with_non_existent_dates_are_disallowed(self):
validation_result = validate_request_args({
'start_at':
'2013-13-70T00:00:00Z',
'end_at':
'2013-12-70T00:00:00Z'
})
assert_that(
validation_result,
is_invalid_with_message("start_at is not a valid datetime"))
def test_that_end_at_with_time_other_than_midnight_is_disallowed(self):
validation_result = validate_request_args({
'group_by':
'some_key',
'start_at':
'2013-04-01T00:00:00Z',
'end_at':
'2013-04-08T00:00:01Z'
})
assert_that(validation_result,
is_invalid_with_message('end_at must be midnight'))
def test_subsequent_filter_by_parameters_are_validated(self):
validation_result = validate_request_args(
MultiDict([
('filter_by', 'foo:bar'),
('filter_by', 'bar'),
]))
assert_that(
validation_result,
is_invalid_with_message(
"filter_by must be a field name and value separated by a colon "
"(:) eg. authority:Westminster"))
def test_that_period_queries_not_ending_on_monday_are_disallowed(self):
validation_result_not_a_monday = validate_request_args({
'period':
'week',
'start_at':
'2013-04-01T00:00:00Z',
'end_at':
'2013-04-09T00:00:00Z'
})
assert_that(validation_result_not_a_monday,
is_invalid_with_message('end_at must be a monday'))
def test_that_queries_which_are_not_midnight_utc_are_disallowed(self):
validation_result = validate_request_args({
'group_by':
'some_key',
'start_at':
'2013-04-01T00:00:00+04:30',
'end_at':
'2013-04-08T00:00:00+00:00'
})
assert_that(validation_result,
is_invalid_with_message("start_at must be midnight"))
def test_that_end_at_alone_is_disallowed(self):
validation_result = validate_request_args({
'period':
'week',
'end_at':
'2013-04-01T00:00:00Z'
})
assert_that(
validation_result,
is_invalid_with_message(
"Either 'duration' or both 'start_at' and 'end_at' "
"are required for a period query"))
def test_that_querying_for_less_than_7_days_of_data_is_disallowed(self):
validation_result = validate_request_args({
'period':
'week',
'start_at':
'2012-01-01T00:00:00Z',
'end_at':
'2012-01-05T00:00:00Z'
})
assert_that(
validation_result,
is_invalid_with_message(
'The minimum time span for a query is 7 days'))
def test_that_grouping_by_month_requires_dates_at_start_of_month(self):
validation_result = validate_request_args({
"period":
"month",
"start_at":
"2013-01-02T00:00:00Z",
"end_at":
"2014-01-01T00:00:00Z"
})
assert_that(
validation_result,
is_invalid_with_message(
"'start_at' must be the first of the month for "
"period=month queries"))
def test_objects_with_invalid_ids_are_disallowed(self):
validation_result = validate_record_data({'_id': 'invalid id'})
assert_that(
validation_result,
is_invalid_with_message("_id \"invalid id\" is not a valid id"))
def test_non_aggregate_queries_are_invalid(self):
validation_result = validate_request_args({})
assert_that(
validation_result,
is_invalid_with_message("querying for raw data is not allowed"))
def test_objects_with_invalid_keys_are_disallowed(self):
validation_result = validate_record_data({'foo-bar': 'bar'})
assert_that(validation_result,
is_invalid_with_message("foo-bar is not a valid key"))
def test_objects_with_invalid_values_are_disallowed(self):
validation_result = validate_record_data({'foo': tuple()})
assert_that(validation_result,
is_invalid_with_message("foo has an invalid value"))
def test_objects_with_unrecognised_internal_keys_are_disallowed(self):
validation_result = validate_record_data({'_unknown': 'whatever'})
assert_that(
validation_result,
is_invalid_with_message(
"_unknown is not a recognised internal field"))
