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