def test_call_to_jsonschema_if_not_param(minimal_swagger_spec):
    property_spec = {'type': 'integer'}
    validator = Mock()
    required = True
    instance = 34
    with patch('jsonschema._validators.required_draft4') as m:
        list(
            required_validator(minimal_swagger_spec, validator, required,
                               instance, property_spec))
    m.assert_called_once_with(validator, required, instance, property_spec)
def test_pass_if_not_required_parameter_and_not_present(
        minimal_swagger_spec, param_spec):
    param_spec['required'] = False
    errors = list(
        required_validator(minimal_swagger_spec,
                           validator=None,
                           required=param_spec['required'],
                           instance=None,
                           schema=param_spec))
    assert len(errors) == 0
Ejemplo n.º 3
0
def test_fail_if_required_parameter_but_not_present():
    param_schema = {'name': 'foo', 'in': 'query', 'required': True}
    result = required_validator(
        validator=None,
        required=param_schema['required'],
        instance=None,
        schema=param_schema)
    error = result[0]
    assert isinstance(error, ValidationError)
    assert 'foo is required' in str(error)
def test_fail_if_required_parameter_but_not_present(minimal_swagger_spec,
                                                    param_spec):
    errors = list(
        required_validator(minimal_swagger_spec,
                           validator=None,
                           required=param_spec['required'],
                           instance=None,
                           schema=param_spec))
    error = errors[0]
    assert isinstance(error, ValidationError)
    assert 'foo is a required parameter' in str(error)
def test_pass_if_not_required_parameter_and_not_present(minimal_swagger_spec,
                                                        param_spec):
    param_spec['required'] = False
    errors = list(
        required_validator(
            minimal_swagger_spec,
            validator=None,
            required=param_spec['required'],
            instance=None,
            schema=param_spec)
    )
    assert len(errors) == 0
def test_fail_if_required_parameter_but_not_present(minimal_swagger_spec,
                                                    param_spec):
    errors = list(
        required_validator(
            minimal_swagger_spec,
            validator=None,
            required=param_spec['required'],
            instance=None,
            schema=param_spec))
    error = errors[0]
    assert isinstance(error, ValidationError)
    assert 'foo is a required parameter' in str(error)
def test_call_to_jsonschema_if_not_param(minimal_swagger_spec):
    property_spec = {'type': 'integer'}
    validator = Mock()
    required = True
    instance = 34
    with patch('jsonschema._validators.required_draft4') as m:
        list(required_validator(
            minimal_swagger_spec,
            validator,
            required,
            instance,
            property_spec))
    m.assert_called_once_with(validator, required, instance, property_spec)
Ejemplo n.º 8
0
def test_call_to_jsonschema_if_not_param(jsonschema_required_validator,
                                         minimal_swagger_spec):
    property_spec = {'type': 'integer'}
    validator = Mock()
    required = True
    instance = 34
    list(
        required_validator(
            minimal_swagger_spec,
            validator,
            required,
            instance,
            property_spec,
        ))
    jsonschema_required_validator.assert_called_once_with(
        validator, required, instance, property_spec)
Ejemplo n.º 9
0
def test_call_to_jsonschema_if_not_param(minimal_swagger_spec):
    param_schema = {'name': 'foo', 'required': True}
    with mock.patch('jsonschema._validators.required_draft4') as m:
        required_validator(minimal_swagger_spec, 'a', 'b', 'c', param_schema)
    m.assert_called_once_with('a', 'b', 'c', param_schema)
Ejemplo n.º 10
0
def test_pass_if_not_required_parameter_and_not_present(minimal_swagger_spec):
    param_schema = {'name': 'foo', 'in': 'query', 'required': False}
    assert required_validator(
        minimal_swagger_spec, None, param_schema['required'], None,
        param_schema) is None
Ejemplo n.º 11
0
def test_call_to_jsonschema_if_not_param():
    param_schema = {'name': 'foo', 'required': True}
    with mock.patch('jsonschema._validators.required_draft4') as m:
        required_validator('a', 'b', 'c', param_schema)
    m.assert_called_once_with('a', 'b', 'c', param_schema)
Ejemplo n.º 12
0
def test_pass_if_not_required_parameter_and_not_present():
    param_schema = {'name': 'foo', 'in': 'query', 'required': False}
    assert required_validator(
        None, param_schema['required'], None, param_schema) is None