def test_schema_any_all_of_invalid_properties(
self, value, unmarshaller_factory
):
schema = {
"allOf": [
{
"type": "object",
"required": ["somestr"],
"properties": {
"somestr": {
"type": "string",
},
},
},
{
"type": "object",
"required": ["someint"],
"properties": {
"someint": {
"type": "integer",
},
},
},
],
"additionalProperties": False,
}
spec = Spec.from_dict(schema)
with pytest.raises(InvalidSchemaValue):
unmarshaller_factory(spec)(value)
def test_object_no_one_of(self, value, validator_factory):
one_of = [
{
"type": "object",
"required": [
"test1",
],
"properties": {
"test1": {
"type": "string",
},
},
},
{
"type": "object",
"required": [
"test2",
],
"properties": {
"test2": {
"type": "string",
},
},
},
]
schema = {
"type": "object",
"oneOf": one_of,
}
spec = Spec.from_dict(schema)
with pytest.raises(InvalidSchemaValue):
validator_factory(spec).validate(value)
def spec(self, info, paths, servers):
spec = {
"info": info,
"servers": servers,
"paths": paths,
}
return Spec.from_dict(spec)
def test_boolean_invalid(self, value, validator_factory):
schema = {
"type": "boolean",
}
spec = Spec.from_dict(schema)
with pytest.raises(InvalidSchemaValue):
validator_factory(spec).validate(value)
def test_object_not_an_object(self, value, validator_factory):
schema = {
"type": "object",
}
spec = Spec.from_dict(schema)
with pytest.raises(InvalidSchemaValue):
validator_factory(spec).validate(value)
def test_array_no_schema(self, value, validator_factory):
schema = {
"type": "array",
}
spec = Spec.from_dict(schema)
with pytest.raises(InvalidSchemaValue):
validator_factory(spec).validate(value)
def test_non_string_empty_value(self, schema_type, unmarshaller_factory):
schema = {
"type": schema_type,
}
spec = Spec.from_dict(schema)
value = ""
with pytest.raises(InvalidSchemaValue):
unmarshaller_factory(spec)(value)
def test_string_format_byte_invalid(self, value, validator_factory):
schema = {
"type": "string",
"format": "byte",
}
spec = Spec.from_dict(schema)
with pytest.raises(InvalidSchemaValue):
validator_factory(spec).validate(value)
def test_null(self, schema_type, validator_factory):
schema = {
"type": schema_type,
}
spec = Spec.from_dict(schema)
value = None
with pytest.raises(InvalidSchemaValue):
validator_factory(spec).validate(value)
def test_number_multiple_of_invalid(self, value, validator_factory):
schema = {
"type": "number",
"multipleOf": 3,
}
spec = Spec.from_dict(schema)
with pytest.raises(InvalidSchemaValue):
validator_factory(spec).validate(value)
def test_integer_maximum_invalid(self, value, validator_factory):
schema = {
"type": "integer",
"maximum": 3,
}
spec = Spec.from_dict(schema)
with pytest.raises(InvalidSchemaValue):
validator_factory(spec).validate(value)
def test_number_string_invalid(self, unmarshaller_factory):
schema = {
"type": "number",
}
spec = Spec.from_dict(schema)
value = "1.23"
with pytest.raises(InvalidSchemaValue):
unmarshaller_factory(spec)(value)
def test_schema_type_invalid(self, unmarshaller_factory):
schema = {
"type": "integer",
}
spec = Spec.from_dict(schema)
value = "test"
with pytest.raises(InvalidSchemaFormatValue):
unmarshaller_factory(spec).unmarshal(value)
def test_boolean_string_invalid(self, unmarshaller_factory):
schema = {
"type": "boolean",
}
spec = Spec.from_dict(schema)
value = "True"
with pytest.raises(InvalidSchemaValue):
unmarshaller_factory(spec)(value)
def test_integer_invalid(self, unmarshaller_factory):
schema = {
"type": "integer",
}
spec = Spec.from_dict(schema)
value = "abc"
with pytest.raises(InvalidSchemaValue):
unmarshaller_factory(spec)(value)
def test_string_float_invalid(self, unmarshaller_factory):
schema = {
"type": "string",
}
spec = Spec.from_dict(schema)
value = 1.23
with pytest.raises(InvalidSchemaValue):
unmarshaller_factory(spec)(value)
def test_string_pattern_invalid(self, value, validator_factory):
schema = {
"type": "string",
"pattern": "baz",
}
spec = Spec.from_dict(schema)
with pytest.raises(InvalidSchemaValue):
validator_factory(spec).validate(value)
def test_object_additional_properties(self, value, validator_factory):
schema = {
"type": "object",
}
spec = Spec.from_dict(schema)
result = validator_factory(spec).validate(value)
assert result is None
def test_string_max_length_invalid(self, value, validator_factory):
schema = {
"type": "string",
"maxLength": 1,
}
spec = Spec.from_dict(schema)
with pytest.raises(InvalidSchemaValue):
validator_factory(spec).validate(value)
def test_boolean(self, value, validator_factory):
schema = {
"type": "boolean",
}
spec = Spec.from_dict(schema)
result = validator_factory(spec).validate(value)
assert result is None
def test_unsupported(self, deserializer_factory):
spec = {"name": "param", "in": "header", "style": "unsupported"}
param = Spec.from_dict(spec)
value = ""
with pytest.warns(UserWarning):
result = deserializer_factory(param)(value)
assert result == value
def test_defaults(self, location, expected):
spec = {
"name": "default",
"in": location,
}
param = Spec.from_dict(spec)
result = get_style(param)
assert result == expected
def test_defaults_true(self, location):
spec = {
"name": "default",
"in": location,
"style": "form",
}
param = Spec.from_dict(spec)
result = get_explode(param)
assert result is True
def test_defaults_false(self, style, location):
spec = {
"name": "default",
"in": location,
"style": style,
}
param = Spec.from_dict(spec)
result = get_explode(param)
assert result is False
def test_defined(self, style, location):
spec = {
"name": "default",
"in": location,
"style": style,
}
param = Spec.from_dict(spec)
result = get_style(param)
assert result == style
def test_object_max_properties_invalid_schema(self, value,
validator_factory):
schema = {
"type": "object",
"maxProperties": -1,
}
spec = Spec.from_dict(schema)
with pytest.raises(InvalidSchemaValue):
validator_factory(spec).validate(value)
def test_string_format_unknown(self, value, validator_factory):
unknown_format = "unknown"
schema = {
"type": "string",
"format": unknown_format,
}
spec = Spec.from_dict(schema)
with pytest.raises(FormatterNotFoundError):
validator_factory(spec).validate(value)
def test_object_default_property(self, value, validator_factory):
schema = {
"type": "object",
"default": "value1",
}
spec = Spec.from_dict(schema)
result = validator_factory(spec).validate(value)
assert result is None
def test_string_max_length(self, value, validator_factory):
schema = {
"type": "string",
"maxLength": 1,
}
spec = Spec.from_dict(schema)
result = validator_factory(spec).validate(value)
assert result is None
def test_string_pattern(self, value, validator_factory):
schema = {
"type": "string",
"pattern": "bar",
}
spec = Spec.from_dict(schema)
result = validator_factory(spec).validate(value)
assert result is None