Python validity_matcher.is_invalid_with_message函数代码示例

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