No OneTemporary
Actions

Size

57 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/open_api_spex.ex b/lib/open_api_spex.ex
	index 08d2ef3..bbae919 100644
	--- a/lib/open_api_spex.ex
	+++ b/lib/open_api_spex.ex
	@@ -1,217 +1,217 @@
	defmodule OpenApiSpex do
	@moduledoc """
	Provides the entry-points for defining schemas, validating and casting.
	"""

	alias OpenApiSpex.{
	OpenApi,
	Operation,
	Operation2,
	Reference,
	Schema,
	SchemaException,
	SchemaResolver
	}

	alias OpenApiSpex.Cast.Error

	@doc """
	Adds schemas to the api spec from the modules specified in the Operations.

	Eg, if the response schema for an operation is defined with:

	responses: %{
	200 => Operation.response("User", "application/json", UserResponse)
	}

	Then the `UserResponse.schema()` function will be called to load the schema, and
	a `Reference` to the loaded schema will be used in the operation response.

	See `OpenApiSpex.schema` macro for a convenient syntax for defining schema modules.
	"""
	@spec resolve_schema_modules(OpenApi.t()) :: OpenApi.t()
	def resolve_schema_modules(spec = %OpenApi{}) do
	SchemaResolver.resolve_schema_modules(spec)
	end

	def cast_and_validate(
	spec = %OpenApi{},
	operation = %Operation{},
	conn = %Plug.Conn{},
	content_type \\ nil
	) do
	- Operation2.cast(operation, conn, content_type, spec.components.schemas)
	+ Operation2.cast(operation, conn, content_type, spec.components)
	end

	@doc """
	Cast params to conform to a `OpenApiSpex.Schema`.

	See `OpenApiSpex.Schema.cast/3` for additional examples and details.
	"""
	@spec cast(OpenApi.t(), Schema.t() \| Reference.t(), any) :: {:ok, any} \| {:error, String.t()}
	def cast(spec = %OpenApi{}, schema = %Schema{}, params) do
	Schema.cast(schema, params, spec.components.schemas)
	end

	def cast(spec = %OpenApi{}, schema = %Reference{}, params) do
	Schema.cast(schema, params, spec.components.schemas)
	end

	@doc """
	Cast all params in `Plug.Conn` to conform to the schemas for `OpenApiSpex.Operation`.

	Returns `{:ok, Plug.Conn.t}` with `params` and `body_params` fields updated if successful,
	or `{:error, reason}` if casting fails.

	`content_type` may optionally be supplied to select the `requestBody` schema.
	"""
	@spec cast(OpenApi.t(), Operation.t(), Plug.Conn.t(), content_type \| nil) ::
	{:ok, Plug.Conn.t()} \| {:error, String.t()}
	when content_type: String.t()
	def cast(spec = %OpenApi{}, operation = %Operation{}, conn = %Plug.Conn{}, content_type \\ nil) do
	Operation.cast(operation, conn, content_type, spec.components.schemas)
	end

	@doc """
	Validate params against `OpenApiSpex.Schema`.

	See `OpenApiSpex.Schema.validate/3` for examples of error messages.
	"""
	@spec validate(OpenApi.t(), Schema.t() \| Reference.t(), any) :: :ok \| {:error, String.t()}
	def validate(spec = %OpenApi{}, schema = %Schema{}, params) do
	Schema.validate(schema, params, spec.components.schemas)
	end

	def validate(spec = %OpenApi{}, schema = %Reference{}, params) do
	Schema.validate(schema, params, spec.components.schemas)
	end

	@doc """
	Validate all params in `Plug.Conn` against `OpenApiSpex.Operation` `parameter` and `requestBody` schemas.

	`content_type` may be optionally supplied to select the `requestBody` schema.
	"""
	@spec validate(OpenApi.t(), Operation.t(), Plug.Conn.t(), content_type \| nil) ::
	:ok \| {:error, String.t()}
	when content_type: String.t()
	def validate(
	spec = %OpenApi{},
	operation = %Operation{},
	conn = %Plug.Conn{},
	content_type \\ nil
	) do
	Operation.validate(operation, conn, content_type, spec.components.schemas)
	end

	def path_to_string(%Error{} = error) do
	Error.path_to_string(error)
	end

	@doc """
	Declares a struct based `OpenApiSpex.Schema`

	- defines the schema/0 callback
	- ensures the schema is linked to the module by "x-struct" extension property
	- defines a struct with keys matching the schema properties
	- defines a @type `t` for the struct
	- derives a `Jason.Encoder` and/or `Poison.Encoder` for the struct

	See `OpenApiSpex.Schema` for additional examples and details.

	## Example

	require OpenApiSpex

	defmodule User do
	OpenApiSpex.schema %{
	title: "User",
	description: "A user of the app",
	type: :object,
	properties: %{
	id: %Schema{type: :integer, description: "User ID"},
	name: %Schema{type: :string, description: "User name", pattern: ~r/[a-zA-Z][a-zA-Z0-9_]+/},
	email: %Schema{type: :string, description: "Email address", format: :email},
	inserted_at: %Schema{type: :string, description: "Creation timestamp", format: :'date-time'},
	updated_at: %Schema{type: :string, description: "Update timestamp", format: :'date-time'}
	},
	required: [:name, :email],
	example: %{
	"id" => 123,
	"name" => "Joe User",
	"email" => "joe@gmail.com",
	"inserted_at" => "2017-09-12T12:34:55Z",
	"updated_at" => "2017-09-13T10:11:12Z"
	}
	}
	end
	"""
	defmacro schema(body) do
	quote do
	@compile {:report_warnings, false}
	@behaviour OpenApiSpex.Schema
	@schema struct(
	OpenApiSpex.Schema,
	Map.put(Map.delete(unquote(body), :__struct__), :"x-struct", __MODULE__)
	)
	def schema, do: @schema

	@derive Enum.filter([Poison.Encoder, Jason.Encoder], &Code.ensure_loaded?/1)
	defstruct Schema.properties(@schema)
	@type t :: %__MODULE__{}

	Map.from_struct(@schema) \|> OpenApiSpex.validate_compiled_schema()
	end
	end

	@doc """
	Validate the compiled schema's properties to ensure the schema is not improperly
	defined. Only errors which would cause a given schema to _always_ fail should be
	raised here.
	"""
	def validate_compiled_schema(schema) do
	Enum.each(schema, fn prop_and_val ->
	:ok = validate_compiled_schema(prop_and_val, schema)
	end)
	end

	def validate_compiled_schema({_, %Schema{} = schema}, _parent) do
	validate_compiled_schema(schema)
	end

	@doc """
	Used for validating the schema at compile time, otherwise we're forced
	to raise errors for improperly defined schemas at runtime.
	"""
	def validate_compiled_schema({:discriminator, %{propertyName: property, mapping: _}}, %{
	anyOf: schemas
	})
	when is_list(schemas) do
	Enum.each(schemas, fn schema ->
	case schema do
	%Schema{title: title} when is_binary(title) -> :ok
	_ -> error!(:discriminator_schema_missing_title, schema, property_name: property)
	end
	end)
	end

	def validate_compiled_schema({:discriminator, %{propertyName: _, mapping: _}}, schema) do
	case {schema.anyOf, schema.allOf, schema.oneOf} do
	{nil, nil, nil} ->
	error!(:discriminator_missing_composite_key, schema)

	_ ->
	:ok
	end
	end

	def validate_compiled_schema({_property, _value}, _schema), do: :ok

	@doc """
	Raises compile time errors for improperly defined schemas.
	"""
	@spec error!(atom(), Schema.t(), keyword()) :: no_return()
	@spec error!(atom(), Schema.t()) :: no_return()
	def error!(error, schema, details \\ []) do
	raise SchemaException, %{error: error, schema: schema, details: details}
	end
	end
	diff --git a/lib/open_api_spex/cast_parameters.ex b/lib/open_api_spex/cast_parameters.ex
	index b6587dd..3890a78 100644
	--- a/lib/open_api_spex/cast_parameters.ex
	+++ b/lib/open_api_spex/cast_parameters.ex
	@@ -1,37 +1,44 @@
	defmodule OpenApiSpex.CastParameters do
	@moduledoc false
	- alias OpenApiSpex.{Cast, Operation, Parameter, Schema}
	+ alias OpenApiSpex.{Cast, Operation, Parameter, Schema, Reference, Components}
	alias OpenApiSpex.Cast.{Error, Object}
	alias Plug.Conn

	- @spec cast(Plug.Conn.t(), Operation.t(), Schema.schemas()) ::
	+ @spec cast(Plug.Conn.t(), Operation.t(), Components.t()) ::
	{:error, [Error.t()]} \| {:ok, Conn.t()}
	- def cast(conn, operation, schemas) do
	+ def cast(conn, operation, components) do
	# Taken together as a set, operation parameters are similar to an object schema type.
	# Convert parameters to an object schema, then delegate to `Cast.Object.cast/1`

	+ # Operation's parameters list may include references - resolving here
	+ resolved_parameters =
	+ Enum.map(operation.parameters, fn
	+ ref = %Reference{} -> Reference.resolve_parameter(ref, components.parameters)
	+ param = %Parameter{} -> param
	+ end)
	+
	properties =
	- operation.parameters
	+ resolved_parameters
	\|> Enum.map(fn parameter -> {parameter.name, Parameter.schema(parameter)} end)
	\|> Map.new()

	required =
	- operation.parameters
	+ resolved_parameters
	\|> Enum.filter(& &1.required)
	\|> Enum.map(& &1.name)

	object_schema = %Schema{
	type: :object,
	properties: properties,
	required: required
	}

	params = Map.merge(conn.path_params, conn.query_params)

	- ctx = %Cast{value: params, schema: object_schema, schemas: schemas}
	+ ctx = %Cast{value: params, schema: object_schema, schemas: components.schemas}

	with {:ok, params} <- Object.cast(ctx) do
	{:ok, %{conn \| params: params}}
	end
	end
	end
	diff --git a/lib/open_api_spex/discriminator.ex b/lib/open_api_spex/discriminator.ex
	index 9b1f5db..b71b521 100644
	--- a/lib/open_api_spex/discriminator.ex
	+++ b/lib/open_api_spex/discriminator.ex
	@@ -1,64 +1,64 @@
	defmodule OpenApiSpex.Discriminator do
	@moduledoc """
	Defines the `OpenApiSpex.Discriminator.t` type.
	"""

	alias OpenApiSpex.Schema

	@enforce_keys :propertyName
	defstruct [
	:propertyName,
	:mapping
	]

	@typedoc """
	[Discriminator Object](https://swagger.io/specification/#discriminatorObject)

	When request bodies or response payloads may be one of a number of different schemas,
	a discriminator object can be used to aid in serialization, deserialization, and validation.
	The discriminator is a specific object in a schema which is used to inform the consumer of the
	specification of an alternative schema based on the value associated with it.
	"""
	@type t :: %__MODULE__{
	propertyName: String.t,
	mapping: %{String.t => String.t} \| nil
	}

	@doc """
	Resolve the schema that should be used to cast/validate a value using a `Discriminator`.
	"""
	@spec resolve(t, map, %{String.t => Schema.t}) :: {:ok, Schema.t} \| {:error, String.t}
	def resolve(%{propertyName: name, mapping: mapping}, value = %{}, schemas = %{}) do
	with {:ok, val} <- get_property_value(value, name) do
	mapped = map_property_value(mapping, val)
	lookup_schema(schemas, mapped)
	else
	{:error, reason} -> {:error, reason}
	end
	end

	@spec get_property_value(map, String.t) :: {:ok, any} \| {:error, String.t}
	defp get_property_value(value = %{}, property_name) do
	case Map.fetch(value, property_name) do
	{:ok, val} -> {:ok, val}
	:error -> {:error, "No value for required disciminator property: #{property_name}"}
	end
	end

	@spec map_property_value(%{String.t => String.t} \| nil, String.t) :: String.t
	defp map_property_value(nil, val), do: val
	defp map_property_value(mapping = %{}, val) do
	Map.get(mapping, val, val)
	end

	@spec lookup_schema(%{String.t => Schema.t}, String.t) :: {:ok, Schema.t} \| {:error, String.t}
	- defp lookup_schema(schemas, "#components/schemas/" <> name) do
	+ defp lookup_schema(schemas, "#/components/schemas/" <> name) do
	lookup_schema(schemas, name)
	end
	defp lookup_schema(schemas, name) do
	case Map.fetch(schemas, name) do
	{:ok, schema} -> {:ok, schema}
	:error -> {:error, "Unknown schema: #{name}"}
	end
	end
	end
	diff --git a/lib/open_api_spex/operation2.ex b/lib/open_api_spex/operation2.ex
	index 8644d3b..35c7f71 100644
	--- a/lib/open_api_spex/operation2.ex
	+++ b/lib/open_api_spex/operation2.ex
	@@ -1,48 +1,49 @@
	defmodule OpenApiSpex.Operation2 do
	@moduledoc """
	Casts and validates a request from a Plug conn.
	"""
	alias OpenApiSpex.{
	Cast,
	CastParameters,
	Operation,
	RequestBody,
	- Schema
	+ Components
	}

	alias OpenApiSpex.Cast.Error
	alias Plug.Conn

	- @spec cast(Operation.t(), Conn.t(), String.t() \| nil, Schema.schemas()) ::
	+ @spec cast(Operation.t(), Conn.t(), String.t() \| nil, Components.t()) ::
	{:error, [Error.t()]} \| {:ok, Conn.t()}
	- def cast(operation = %Operation{}, conn = %Conn{}, content_type, schemas) do
	- with {:ok, conn} <- cast_parameters(conn, operation, schemas),
	+ def cast(operation = %Operation{}, conn = %Conn{}, content_type, components = %Components{}) do
	+ with {:ok, conn} <- cast_parameters(conn, operation, components),
	{:ok, body} <-
	- cast_request_body(operation.requestBody, conn.body_params, content_type, schemas) do
	+ cast_request_body(operation.requestBody, conn.body_params, content_type, components) do
	{:ok, %{conn \| body_params: body}}
	end
	end

	## Private functions

	- defp cast_parameters(conn, operation, schemas) do
	- CastParameters.cast(conn, operation, schemas)
	+ defp cast_parameters(conn, operation, components) do
	+ CastParameters.cast(conn, operation, components)
	end

	defp cast_request_body(nil, _, _, _), do: {:ok, %{}}

	defp cast_request_body(%{required: false}, _, nil, _), do: {:ok, %{}}

	defp cast_request_body(%{required: true}, _, nil, _) do
	{:error, [Error.new(%{path: [], value: nil}, {:missing_header, "content-type"})]}
	end

	- defp cast_request_body(%RequestBody{content: content}, params, content_type, schemas) do
	+ defp cast_request_body(%RequestBody{content: content}, params, content_type, components = %Components{}) do
	case content do
	%{^content_type => media_type} ->
	- Cast.cast(media_type.schema, params, schemas)
	+ Cast.cast(media_type.schema, params, components.schemas)
	+
	_ ->
	{:error, [Error.new(%{path: [], value: content_type}, {:invalid_header, "content-type"})]}
	end
	end
	end
	diff --git a/lib/open_api_spex/parameter.ex b/lib/open_api_spex/parameter.ex
	index adf9d94..953b683 100644
	--- a/lib/open_api_spex/parameter.ex
	+++ b/lib/open_api_spex/parameter.ex
	@@ -1,95 +1,97 @@
	defmodule OpenApiSpex.Parameter do
	@moduledoc """
	Defines the `OpenApiSpex.Parameter.t` type.
	"""
	alias OpenApiSpex.{
	Schema, Reference, Example, MediaType, Parameter
	}

	@enforce_keys [:name, :in]
	defstruct [
	:name,
	:in,
	:description,
	:required,
	:deprecated,
	:allowEmptyValue,
	:style,
	:explode,
	:allowReserved,
	:schema,
	:example,
	:examples,
	:content,
	]
	@typedoc """
	Valid values for the `in` key in the `OpenApiSpex.Parameter` struct.
	"""
	@type location :: :path \| :query \| :header \| :cookie

	@typedoc """
	Valid values for the `style` key in the `OpenApiSpex.Parameter` struct.
	"""
	@type style :: :matrix \| :label \| :form \| :simple \| :spaceDelimited \| :pipeDelimited \| :deepObject

	@typedoc """
	[Parameter Object](https://swagger.io/specification/#parameterObject)

	Describes a single operation parameter.

	A unique parameter is defined by a combination of a name and location.

	## Parameter Locations

	There are four possible parameter locations specified by the in field:

	- path: Used together with Path Templating, where the parameter value is actually part of the operation's URL. This does not include the host or base path of the API. For example, in `/items/{itemId}`, the path parameter is itemId.
	- query: Parameters that are appended to the URL. For example, in `/items?id=###`, the query parameter is id.
	- header: Custom headers that are expected as part of the request. Note that RFC7230 states header names are case insensitive.
	- cookie: Used to pass a specific cookie value to the API.
	"""
	@type t :: %__MODULE__{
	name: atom,
	in: location,
	description: String.t \| nil,
	required: boolean \| nil,
	deprecated: boolean \| nil,
	allowEmptyValue: boolean \| nil,
	style: style \| nil,
	explode: boolean \| nil,
	allowReserved: boolean \| nil,
	schema: Schema.t \| Reference.t \| atom \| nil,
	example: any,
	examples: %{String.t => Example.t \| Reference.t} \| nil,
	content: %{String.t => MediaType.t} \| nil
	}

	+ @type parameters :: %{String.t => t \| Reference.t} \| nil
	+
	@doc """
	Sets the schema for a parameter from a simple type, reference or Schema
	"""
	@spec put_schema(t, Reference.t \| Schema.t \| atom) :: t
	def put_schema(parameter = %Parameter{}, type = %Reference{}) do
	%{parameter \| schema: type}
	end
	def put_schema(parameter = %Parameter{}, type = %Schema{}) do
	%{parameter \| schema: type}
	end
	def put_schema(parameter = %Parameter{}, type) when type in [:boolean, :integer, :number, :string, :array, :object] do
	%{parameter \| schema: %Schema{type: type}}
	end
	def put_schema(parameter = %Parameter{}, type) when is_atom(type) do
	%{parameter \| schema: type}
	end

	@doc """
	Gets the schema for a parameter, from the `schema` key or `content` key, which ever is populated.
	"""
	@spec schema(Parameter.t) :: Schema.t \| Reference.t \| atom
	def schema(%Parameter{schema: schema = %{}}) do
	schema
	end
	def schema(%Parameter{content: content = %{}}) do
	{_type, %MediaType{schema: schema}} = Enum.at(content, 0)
	schema
	end
	end
	diff --git a/lib/open_api_spex/reference.ex b/lib/open_api_spex/reference.ex
	index e8b75ec..b7ec073 100644
	--- a/lib/open_api_spex/reference.ex
	+++ b/lib/open_api_spex/reference.ex
	@@ -1,35 +1,38 @@
	defmodule OpenApiSpex.Reference do
	@moduledoc """
	Defines the `OpenApiSpex.Reference.t` type.
	"""

	alias OpenApiSpex.Reference

	@enforce_keys :"$ref"
	defstruct [
	:"$ref"
	]

	@typedoc """
	[Reference Object](https://swagger.io/specification/#referenceObject)

	A simple object to allow referencing other components in the specification, internally and externally.
	The Reference Object is defined by JSON Reference and follows the same structure, behavior and rules.
	"""
	@type t :: %Reference{
	"$ref": String.t
	}

	@doc """
	Resolve a `Reference` to the `Schema` it refers to.

	## Examples

	iex> alias OpenApiSpex.{Reference, Schema}
	...> schemas = %{"user" => %Schema{title: "user", type: :object}}
	...> Reference.resolve_schema(%Reference{"$ref": "#/components/schemas/user"}, schemas)
	%OpenApiSpex.Schema{type: :object, title: "user"}
	"""
	@spec resolve_schema(Reference.t, %{String.t => Schema.t}) :: Schema.t \| nil
	def resolve_schema(%Reference{"$ref": "#/components/schemas/" <> name}, schemas), do: schemas[name]
	+
	+ @spec resolve_parameter(Reference.t, %{String.t => Parameter.t}) :: Parameter.t \| nil
	+ def resolve_parameter(%Reference{"$ref": "#/components/parameters/" <> name}, parameters), do: parameters[name]
	end
	diff --git a/lib/open_api_spex/schema.ex b/lib/open_api_spex/schema.ex
	index 2647ca5..bf68fc5 100644
	--- a/lib/open_api_spex/schema.ex
	+++ b/lib/open_api_spex/schema.ex
	@@ -1,868 +1,868 @@
	defmodule OpenApiSpex.Schema do
	@moduledoc """
	Defines the `OpenApiSpex.Schema.t` type and operations for casting and validating against a schema.

	The `OpenApiSpex.schema` macro can be used to declare schemas with an associated struct and JSON Encoder.

	## Examples

	defmodule MyApp.Schemas do
	defmodule EmailString do
	@behaviour OpenApiSpex.Schema
	def schema do
	%OpenApiSpex.Schema {
	title: "EmailString",
	type: :string,
	format: :email
	}
	end
	end

	defmodule Person do
	require OpenApiSpex
	alias OpenApiSpex.{Reference, Schema}

	OpenApiSpex.schema(%{
	type: :object,
	required: [:name],
	properties: %{
	name: %Schema{type: :string},
	- address: %Reference{"$ref": "#components/schemas/Address"},
	+ address: %Reference{"$ref": "#/components/schemas/Address"},
	age: %Schema{type: :integer, format: :int32, minimum: 0}
	}
	})
	end

	defmodule StringDictionary do
	@behaviour OpenApiSpex.Schema

	def schema() do
	%OpenApiSpex.Schema{
	type: :object,
	additionalProperties: %{
	type: :string
	}
	}
	end
	end

	defmodule Pet do
	require OpenApiSpex
	alias OpenApiSpex.{Schema, Discriminator}

	OpenApiSpex.schema(%{
	title: "Pet",
	type: :object,
	discriminator: %Discriminator{
	propertyName: "petType"
	},
	properties: %{
	name: %Schema{type: :string},
	petType: %Schema{type: :string}
	},
	required: [:name, :petType]
	})
	end

	defmodule Cat do
	require OpenApiSpex
	alias OpenApiSpex.Schema

	OpenApiSpex.schema(%{
	title: "Cat",
	type: :object,
	description: "A representation of a cat. Note that `Cat` will be used as the discriminator value.",
	allOf: [
	Pet,
	%Schema{
	type: :object,
	properties: %{
	huntingSkill: %Schema{
	type: :string,
	description: "The measured skill for hunting",
	default: "lazy",
	enum: ["clueless", "lazy", "adventurous", "aggresive"]
	}
	},
	required: [:huntingSkill]
	}
	]
	})
	end

	defmodule Dog do
	require OpenApiSpex
	alias OpenApiSpex.Schema

	OpenApiSpex.schema(%{
	type: :object,
	title: "Dog",
	description: "A representation of a dog. Note that `Dog` will be used as the discriminator value.",
	allOf: [
	Pet,
	%Schema {
	type: :object,
	properties: %{
	packSize: %Schema{
	type: :integer,
	format: :int32,
	description: "the size of the pack the dog is from",
	default: 0,
	minimum: 0
	}
	},
	required: [
	:packSize
	]
	}
	]
	})
	end
	end
	"""

	alias OpenApiSpex.{
	Schema,
	Reference,
	Discriminator,
	Xml,
	ExternalDocumentation
	}

	@doc """
	A module implementing the `OpenApiSpex.Schema` behaviour should export a `schema/0` function
	that produces an `OpenApiSpex.Schema` struct.
	"""
	@callback schema() :: t

	defstruct [
	:title,
	:multipleOf,
	:maximum,
	:exclusiveMaximum,
	:minimum,
	:exclusiveMinimum,
	:maxLength,
	:minLength,
	:pattern,
	:maxItems,
	:minItems,
	:uniqueItems,
	:maxProperties,
	:minProperties,
	:required,
	:enum,
	:type,
	:allOf,
	:oneOf,
	:anyOf,
	:not,
	:items,
	:properties,
	:additionalProperties,
	:description,
	:format,
	:default,
	:nullable,
	:discriminator,
	:readOnly,
	:writeOnly,
	:xml,
	:externalDocs,
	:example,
	:deprecated,
	:"x-struct"
	]

	@typedoc """
	[Schema Object](https://swagger.io/specification/#schemaObject)

	The Schema Object allows the definition of input and output data types.
	These types can be objects, but also primitives and arrays.
	This object is an extended subset of the JSON Schema Specification Wright Draft 00.

	## Example
	alias OpenApiSpex.Schema

	%Schema{
	title: "User",
	type: :object,
	properties: %{
	id: %Schema{type: :integer, minimum: 1},
	name: %Schema{type: :string, pattern: "[a-zA-Z][a-zA-Z0-9_]+"},
	email: %Scheam{type: :string, format: :email},
	last_login: %Schema{type: :string, format: :"date-time"}
	},
	required: [:name, :email],
	example: %{
	"name" => "joe",
	"email" => "joe@gmail.com"
	}
	}
	"""
	@type t :: %__MODULE__{
	title: String.t() \| nil,
	multipleOf: number \| nil,
	maximum: number \| nil,
	exclusiveMaximum: boolean \| nil,
	minimum: number \| nil,
	exclusiveMinimum: boolean \| nil,
	maxLength: integer \| nil,
	minLength: integer \| nil,
	pattern: String.t() \| Regex.t() \| nil,
	maxItems: integer \| nil,
	minItems: integer \| nil,
	uniqueItems: boolean \| nil,
	maxProperties: integer \| nil,
	minProperties: integer \| nil,
	required: [atom] \| nil,
	enum: [String.t()] \| nil,
	type: data_type \| nil,
	allOf: [Schema.t() \| Reference.t() \| module] \| nil,
	oneOf: [Schema.t() \| Reference.t() \| module] \| nil,
	anyOf: [Schema.t() \| Reference.t() \| module] \| nil,
	not: Schema.t() \| Reference.t() \| module \| nil,
	items: Schema.t() \| Reference.t() \| module \| nil,
	properties: %{atom => Schema.t() \| Reference.t() \| module} \| nil,
	additionalProperties: boolean \| Schema.t() \| Reference.t() \| module \| nil,
	description: String.t() \| nil,
	format: String.t() \| atom \| nil,
	default: any,
	nullable: boolean \| nil,
	discriminator: Discriminator.t() \| nil,
	readOnly: boolean \| nil,
	writeOnly: boolean \| nil,
	xml: Xml.t() \| nil,
	externalDocs: ExternalDocumentation.t() \| nil,
	example: any,
	deprecated: boolean \| nil,
	"x-struct": module \| nil
	}

	@typedoc """
	The basic data types supported by openapi.

	[Reference](https://swagger.io/docs/specification/data-models/data-types/)
	"""
	@type data_type :: :string \| :number \| :integer \| :boolean \| :array \| :object

	@typedoc """
	Global schemas lookup by name.
	"""
	@type schemas :: %{String.t() => t()}

	@doc """
	Cast a simple value to the elixir type defined by a schema.

	By default, object types are cast to maps, however if the "x-struct" attribute is set in the schema,
	the result will be constructed as an instance of the given struct type.

	## Examples

	iex> OpenApiSpex.Schema.cast(%Schema{type: :integer}, "123", %{})
	{:ok, 123}

	iex> {:ok, dt = %DateTime{}} = OpenApiSpex.Schema.cast(%Schema{type: :string, format: :"date-time"}, "2018-04-02T13:44:55Z", %{})
	...> dt \|> DateTime.to_iso8601()
	"2018-04-02T13:44:55Z"

	## Casting Polymorphic Schemas

	Schemas using `discriminator`, `allOf`, `oneOf`, `anyOf` are cast using the following rules:

	- If a `discriminator` is present, cast the properties defined in the base schema, then
	cast the result using the schema identified by the discriminator. To avoid infinite recursion,
	the discriminator is only dereferenced if the discriminator property has not already been cast.

	- Cast the properties using each schema listing in `allOf`. When a property is defined in
	multiple `allOf` schemas, it will be cast using the first schema listed containing the property.

	- Cast the value using each schema listed in `oneOf`, stopping as soon as a sucessful cast is made.

	- Cast the value using each schema listed in `anyOf`, stopping as soon as a succesful cast is made.
	"""
	def cast(%Schema{type: :boolean}, value, _schemas) when is_boolean(value), do: {:ok, value}

	def cast(%Schema{type: :boolean}, value, _schemas) when is_binary(value) do
	case value do
	"true" -> {:ok, true}
	"false" -> {:ok, false}
	_ -> {:error, "Invalid boolean: #{inspect(value)}"}
	end
	end

	def cast(%Schema{type: :integer}, value, _schemas) when is_integer(value), do: {:ok, value}

	def cast(%Schema{type: :integer}, value, _schemas) when is_binary(value) do
	case Integer.parse(value) do
	{i, ""} -> {:ok, i}
	_ -> {:error, :bad_integer}
	end
	end

	def cast(%Schema{type: :number}, value, _schemas) when is_float(value), do: {:ok, value}

	def cast(%Schema{type: :number}, value, _schemas) when is_integer(value), do: {:ok, value / 1}

	def cast(%Schema{type: :number}, value, _schemas) when is_binary(value) do
	case Float.parse(value) do
	{x, ""} -> {:ok, x}
	_ -> {:error, :bad_float}
	end
	end

	def cast(%Schema{type: :string, format: :"date-time"}, value, _schemas) when is_binary(value) do
	case DateTime.from_iso8601(value) do
	{:ok, date_time = %DateTime{}, _offset} -> {:ok, date_time}
	error = {:error, _reason} -> error
	end
	end

	def cast(%Schema{type: :string, format: :date}, value, _schemas) when is_binary(value) do
	case Date.from_iso8601(value) do
	{:ok, date = %Date{}} -> {:ok, date}
	error = {:error, _reason} -> error
	end
	end

	def cast(%Schema{type: :string, format: :binary}, %Plug.Upload{} = value, _schemas) do
	{:ok, value}
	end

	def cast(%Schema{type: :string}, value, _schemas) when is_binary(value), do: {:ok, value}

	def cast(%Schema{type: :array, items: nil}, value, _schemas) when is_list(value),
	do: {:ok, value}

	def cast(%Schema{type: :array}, [], _schemas), do: {:ok, []}

	def cast(schema = %Schema{type: :array, items: items_schema}, [x \| rest], schemas) do
	with {:ok, x_cast} <- cast(items_schema, x, schemas),
	{:ok, rest_cast} <- cast(schema, rest, schemas) do
	{:ok, [x_cast \| rest_cast]}
	end
	end

	def cast(%Schema{type: :array}, value, _schemas) when not is_list(value) do
	{:error, "Invalid array: #{inspect(value)}"}
	end

	def cast(
	schema = %Schema{type: :object, discriminator: discriminator = %{}},
	value = %{},
	schemas
	) do
	discriminator_property = String.to_existing_atom(discriminator.propertyName)

	already_cast? =
	if Map.has_key?(value, discriminator_property) do
	{:error, :already_cast}
	else
	:ok
	end

	with :ok <- already_cast?,
	{:ok, partial_cast} <-
	cast(%Schema{type: :object, properties: schema.properties}, value, schemas),
	{:ok, derived_schema} <- Discriminator.resolve(discriminator, value, schemas),
	{:ok, result} <- cast(derived_schema, partial_cast, schemas) do
	{:ok, make_struct(result, schema)}
	else
	{:error, :already_cast} -> {:ok, value}
	{:error, reason} -> {:error, reason}
	end
	end

	def cast(schema = %Schema{type: :object, allOf: [first \| rest]}, value = %{}, schemas) do
	with {:ok, cast_first} <- cast(first, value, schemas),
	{:ok, result} <- cast(%{schema \| allOf: rest}, cast_first, schemas) do
	{:ok, result}
	else
	{:error, reason} -> {:error, reason}
	end
	end

	def cast(schema = %Schema{type: :object, allOf: []}, value = %{}, schemas) do
	cast(%{schema \| allOf: nil}, value, schemas)
	end

	def cast(schema = %Schema{oneOf: [first \| rest]}, value, schemas) do
	case cast(first, value, schemas) do
	{:ok, result} ->
	cast(%{schema \| oneOf: nil}, result, schemas)

	{:error, _reason} ->
	cast(%{schema \| oneOf: rest}, value, schemas)
	end
	end

	def cast(%Schema{oneOf: []}, _value, _schemas) do
	{:error, "Failed to cast to any schema in oneOf"}
	end

	def cast(schema = %Schema{anyOf: [first \| rest]}, value, schemas) do
	case cast(first, value, schemas) do
	{:ok, result} ->
	cast(%{schema \| anyOf: nil}, result, schemas)

	{:error, _reason} ->
	cast(%{schema \| anyOf: rest}, value, schemas)
	end
	end

	def cast(%Schema{anyOf: []}, _value, _schemas) do
	{:error, "Failed to cast to any schema in anyOf"}
	end

	def cast(schema = %Schema{type: :object}, value, schemas) when is_map(value) do
	schema = %{schema \| properties: schema.properties \|\| %{}}

	{regular_properties, others} =
	value
	\|> no_struct()
	\|> Enum.split_with(fn {k, _v} -> is_binary(k) end)

	with {:ok, props} <- cast_properties(schema, regular_properties, schemas) do
	result = Map.new(others ++ props) \|> make_struct(schema)
	{:ok, result}
	end
	end

	def cast(ref = %Reference{}, val, schemas),
	do: cast(Reference.resolve_schema(ref, schemas), val, schemas)

	def cast(_additionalProperties = false, val, _schemas) do
	{:error, "Unexpected field with value #{inspect(val)}"}
	end

	def cast(_additionalProperties, val, _schemas), do: {:ok, val}

	defp make_struct(val = %_{}, _), do: val
	defp make_struct(val, %{"x-struct": nil}), do: val

	defp make_struct(val, %{"x-struct": mod}) do
	Enum.reduce(val, struct(mod), fn {k, v}, acc ->
	Map.put(acc, k, v)
	end)
	end

	defp no_struct(val), do: Map.delete(val, :__struct__)

	@spec cast_properties(Schema.t(), list, %{String.t() => Schema.t()}) ::
	{:ok, list} \| {:error, String.t()}
	defp cast_properties(%Schema{}, [], _schemas), do: {:ok, []}

	defp cast_properties(object_schema = %Schema{}, [{key, value} \| rest], schemas) do
	{name, schema} =
	Enum.find(
	object_schema.properties,
	{key, object_schema.additionalProperties},
	fn {name, _schema} -> to_string(name) == to_string(key) end
	)

	with {:ok, new_value} <- cast(schema, value, schemas),
	{:ok, cast_tail} <- cast_properties(object_schema, rest, schemas) do
	{:ok, [{name, new_value} \| cast_tail]}
	end
	end

	@doc ~S"""
	Validate a value against a Schema.

	This expects that the value has already been `cast` to the appropriate data type.

	## Examples

	iex> OpenApiSpex.Schema.validate(%OpenApiSpex.Schema{type: :integer, minimum: 5}, 3, %{})
	{:error, "#: 3 is smaller than minimum 5"}

	iex> OpenApiSpex.Schema.validate(%OpenApiSpex.Schema{type: :string, pattern: "(.)@(.)"}, "joe@gmail.com", %{})
	:ok

	iex> OpenApiSpex.Schema.validate(%OpenApiSpex.Schema{type: :string, pattern: "(.)@(.)"}, "joegmail.com", %{})
	{:error, "#: Value \"joegmail.com\" does not match pattern: (.)@(.)"}
	"""
	@spec validate(Schema.t() \| Reference.t(), any, %{String.t() => Schema.t() \| Reference.t()}) ::
	:ok \| {:error, String.t()}
	def validate(schema, val, schemas), do: validate(schema, val, "#", schemas)

	@spec validate(Schema.t() \| Reference.t(), any, String.t(), %{
	String.t() => Schema.t() \| Reference.t()
	}) :: :ok \| {:error, String.t()}
	def validate(ref = %Reference{}, val, path, schemas),
	do: validate(Reference.resolve_schema(ref, schemas), val, path, schemas)

	def validate(%Schema{nullable: true}, nil, _path, _schemas), do: :ok

	def validate(%Schema{type: type}, nil, path, _schemas) when not is_nil(type) do
	{:error, "#{path}: null value where #{type} expected"}
	end

	def validate(schema = %Schema{anyOf: valid_schemas}, value, path, schemas)
	when is_list(valid_schemas) do
	if Enum.any?(valid_schemas, &(validate(&1, value, path, schemas) == :ok)) do
	validate(%{schema \| anyOf: nil}, value, path, schemas)
	else
	{:error, "#{path}: Failed to validate against any schema"}
	end
	end

	def validate(schema = %Schema{oneOf: valid_schemas}, value, path, schemas)
	when is_list(valid_schemas) do
	case Enum.count(valid_schemas, &(validate(&1, value, path, schemas) == :ok)) do
	1 -> validate(%{schema \| oneOf: nil}, value, path, schemas)
	0 -> {:error, "#{path}: Failed to validate against any schema"}
	other -> {:error, "#{path}: Validated against #{other} schemas when only one expected"}
	end
	end

	def validate(schema = %Schema{allOf: required_schemas}, value, path, schemas)
	when is_list(required_schemas) do
	required_schemas
	\|> Enum.map(&validate(&1, value, path, schemas))
	\|> Enum.reject(&(&1 == :ok))
	\|> Enum.map(fn {:error, msg} -> msg end)
	\|> case do
	[] -> validate(%{schema \| allOf: nil}, value, path, schemas)
	errors -> {:error, Enum.join(errors, "\n")}
	end
	end

	def validate(schema = %Schema{not: not_schema}, value, path, schemas)
	when not is_nil(not_schema) do
	case validate(not_schema, value, path, schemas) do
	{:error, _} -> validate(%{schema \| not: nil}, value, path, schemas)
	:ok -> {:error, "#{path}: Value is valid for schema given in `not`"}
	end
	end

	def validate(%Schema{enum: options = [_ \| _]}, value, path, _schemas) do
	case Enum.member?(options, value) do
	true ->
	:ok

	_ ->
	{:error, "#{path}: Value not in enum: #{inspect(value)}"}
	end
	end

	def validate(schema = %Schema{type: :integer}, value, path, _schemas) when is_integer(value) do
	validate_number_types(schema, value, path)
	end

	def validate(schema = %Schema{type: :number}, value, path, _schemas) when is_number(value) do
	validate_number_types(schema, value, path)
	end

	def validate(schema = %Schema{type: :string}, value, path, _schemas) when is_binary(value) do
	validate_string_types(schema, value, path)
	end

	def validate(%Schema{type: :string, format: :"date-time"}, %DateTime{}, _path, _schemas) do
	:ok
	end

	def validate(%Schema{type: :string, format: :binary}, %Plug.Upload{}, _path, _schemas) do
	:ok
	end

	def validate(%Schema{type: expected_type}, %DateTime{}, path, _schemas) do
	{:error, "#{path}: invalid type DateTime where #{expected_type} expected"}
	end

	def validate(%Schema{type: :string, format: :date}, %Date{}, _path, _schemas) do
	:ok
	end

	def validate(%Schema{type: expected_type}, %Date{}, path, _schemas) do
	{:error, "#{path}: invalid type Date where #{expected_type} expected"}
	end

	def validate(%Schema{type: :boolean}, value, _path, _schemas) when is_boolean(value), do: :ok

	def validate(schema = %Schema{type: :array}, value, path, schemas) when is_list(value) do
	with :ok <- validate_max_items(schema, value, path),
	:ok <- validate_min_items(schema, value, path),
	:ok <- validate_unique_items(schema, value, path),
	:ok <- validate_array_items(schema, value, {path, 0}, schemas) do
	:ok
	end
	end

	def validate(schema = %Schema{type: :object}, value = %{}, path, schemas) do
	schema = %{schema \| properties: schema.properties \|\| %{}, required: schema.required \|\| []}

	with :ok <- validate_required_properties(schema, value, path),
	:ok <- validate_max_properties(schema, value, path),
	:ok <- validate_min_properties(schema, value, path),
	:ok <-
	validate_object_properties(
	schema.properties,
	MapSet.new(schema.required),
	value,
	path,
	schemas
	) do
	:ok
	end
	end

	def validate(%Schema{type: nil}, _value, _path, _schemas) do
	# polymorphic schemas will terminate here after validating against anyOf/oneOf/allOf/not
	:ok
	end

	def validate(%Schema{type: expected_type}, value, path, _schemas)
	when not is_nil(expected_type) do
	{:error, "#{path}: invalid type #{term_type(value)} where #{expected_type} expected"}
	end

	@spec term_type(term) :: data_type \| nil \| String.t()
	defp term_type(v) when is_list(v), do: :array
	defp term_type(v) when is_map(v), do: :object
	defp term_type(v) when is_binary(v), do: :string
	defp term_type(v) when is_boolean(v), do: :boolean
	defp term_type(v) when is_integer(v), do: :integer
	defp term_type(v) when is_number(v), do: :number
	defp term_type(v) when is_nil(v), do: nil
	defp term_type(v), do: inspect(v)

	@spec validate_number_types(Schema.t(), number, String.t()) :: :ok \| {:error, String.t()}
	defp validate_number_types(schema, value, path) do
	with :ok <- validate_multiple(schema, value, path),
	:ok <- validate_maximum(schema, value, path),
	:ok <- validate_minimum(schema, value, path) do
	:ok
	end
	end

	@spec validate_string_types(Schema.t(), String.t(), String.t()) :: :ok \| {:error, String.t()}
	defp validate_string_types(schema, value, path) do
	with :ok <- validate_max_length(schema, value, path),
	:ok <- validate_min_length(schema, value, path),
	:ok <- validate_pattern(schema, value, path) do
	:ok
	end
	end

	@spec validate_multiple(Schema.t(), number, String.t()) :: :ok \| {:error, String.t()}
	defp validate_multiple(%{multipleOf: nil}, _, _), do: :ok
	defp validate_multiple(%{multipleOf: n}, value, _) when round(value / n) * n == value, do: :ok

	defp validate_multiple(%{multipleOf: n}, value, path),
	do: {:error, "#{path}: #{value} is not a multiple of #{n}"}

	@spec validate_maximum(Schema.t(), number, String.t()) :: :ok \| {:error, String.t()}
	defp validate_maximum(%{maximum: nil}, _val, _path), do: :ok

	defp validate_maximum(%{maximum: n, exclusiveMaximum: true}, value, _path) when value < n,
	do: :ok

	defp validate_maximum(%{maximum: n, exclusiveMaximum: true}, value, path),
	do: {:error, "#{path}: #{value} is larger than the exclusive maximum #{n}"}

	defp validate_maximum(%{maximum: n}, value, _path) when value <= n, do: :ok

	defp validate_maximum(%{maximum: n}, value, path),
	do: {:error, "#{path}: #{value} is larger than maximum #{n}"}

	@spec validate_minimum(Schema.t(), number, String.t()) :: :ok \| {:error, String.t()}
	defp validate_minimum(%{minimum: nil}, _val, _path), do: :ok

	defp validate_minimum(%{minimum: n, exclusiveMinimum: true}, value, _path) when value > n,
	do: :ok

	defp validate_minimum(%{minimum: n, exclusiveMinimum: true}, value, path),
	do: {:error, "#{path}: #{value} is smaller than the exclusive minimum #{n}"}

	defp validate_minimum(%{minimum: n}, value, _path) when value >= n, do: :ok

	defp validate_minimum(%{minimum: n}, value, path),
	do: {:error, "#{path}: #{value} is smaller than minimum #{n}"}

	@spec validate_max_length(Schema.t(), String.t(), String.t()) :: :ok \| {:error, String.t()}
	defp validate_max_length(%{maxLength: nil}, _val, _path), do: :ok

	defp validate_max_length(%{maxLength: n}, value, path) do
	case String.length(value) <= n do
	true -> :ok
	_ -> {:error, "#{path}: String length is larger than maxLength: #{n}"}
	end
	end

	@spec validate_min_length(Schema.t(), String.t(), String.t()) :: :ok \| {:error, String.t()}
	defp validate_min_length(%{minLength: nil}, _val, _path), do: :ok

	defp validate_min_length(%{minLength: n}, value, path) do
	case String.length(value) >= n do
	true -> :ok
	_ -> {:error, "#{path}: String length is smaller than minLength: #{n}"}
	end
	end

	@spec validate_pattern(Schema.t(), String.t(), String.t()) :: :ok \| {:error, String.t()}
	defp validate_pattern(%{pattern: nil}, _val, _path), do: :ok

	defp validate_pattern(schema = %{pattern: regex}, val, path) when is_binary(regex) do
	with {:ok, regex} <- Regex.compile(regex) do
	validate_pattern(%{schema \| pattern: regex}, val, path)
	end
	end

	defp validate_pattern(%{pattern: regex = %Regex{}}, val, path) do
	case Regex.match?(regex, val) do
	true -> :ok
	_ -> {:error, "#{path}: Value #{inspect(val)} does not match pattern: #{regex.source}"}
	end
	end

	@spec validate_max_items(Schema.t(), list, String.t()) :: :ok \| {:error, String.t()}
	defp validate_max_items(%Schema{maxItems: nil}, _val, _path), do: :ok
	defp validate_max_items(%Schema{maxItems: n}, value, _path) when length(value) <= n, do: :ok

	defp validate_max_items(%Schema{maxItems: n}, value, path) do
	{:error, "#{path}: Array length #{length(value)} is larger than maxItems: #{n}"}
	end

	@spec validate_min_items(Schema.t(), list, String.t()) :: :ok \| {:error, String.t()}
	defp validate_min_items(%Schema{minItems: nil}, _val, _path), do: :ok
	defp validate_min_items(%Schema{minItems: n}, value, _path) when length(value) >= n, do: :ok

	defp validate_min_items(%Schema{minItems: n}, value, path) do
	{:error, "#{path}: Array length #{length(value)} is smaller than minItems: #{n}"}
	end

	@spec validate_unique_items(Schema.t(), list, String.t()) :: :ok \| {:error, String.t()}
	defp validate_unique_items(%Schema{uniqueItems: true}, value, path) do
	unique_size =
	value
	\|> MapSet.new()
	\|> MapSet.size()

	case unique_size == length(value) do
	true -> :ok
	_ -> {:error, "#{path}: Array items must be unique"}
	end
	end

	defp validate_unique_items(_schema, _value, _path), do: :ok

	@spec validate_array_items(Schema.t(), list, {String.t(), integer}, %{String.t() => Schema.t()}) ::
	:ok \| {:error, String.t()}
	defp validate_array_items(%Schema{type: :array, items: nil}, value, _path, _schemas)
	when is_list(value),
	do: :ok

	defp validate_array_items(%Schema{type: :array}, [], _path, _schemas), do: :ok

	defp validate_array_items(
	schema = %Schema{type: :array, items: item_schema},
	[x \| rest],
	{path, index},
	schemas
	) do
	with :ok <- validate(item_schema, x, "#{path}/#{index}", schemas) do
	validate_array_items(schema, rest, {path, index + 1}, schemas)
	end
	end

	@spec validate_required_properties(Schema.t(), %{}, String.t()) :: :ok \| {:error, String.t()}
	defp validate_required_properties(%Schema{type: :object, required: nil}, _val, _path), do: :ok

	defp validate_required_properties(%Schema{type: :object, required: required}, value = %{}, path) do
	missing = required -- Map.keys(value)

	case missing do
	[] -> :ok
	_ -> {:error, "#{path}: Missing required properties: #{inspect(missing)}"}
	end
	end

	@spec validate_max_properties(Schema.t(), %{}, String.t()) :: :ok \| {:error, String.t()}
	defp validate_max_properties(%Schema{type: :object, maxProperties: nil}, _val, _path), do: :ok

	defp validate_max_properties(%Schema{type: :object, maxProperties: n}, val, _path)
	when map_size(val) <= n,
	do: :ok

	defp validate_max_properties(%Schema{type: :object, maxProperties: n}, val, path) do
	{:error,
	"#{path}: Object property count #{map_size(val)} is greater than maxProperties: #{n}"}
	end

	@spec validate_min_properties(Schema.t(), %{}, String.t()) :: :ok \| {:error, String.t()}
	defp validate_min_properties(%Schema{type: :object, minProperties: nil}, _val, _path), do: :ok

	defp validate_min_properties(%Schema{type: :object, minProperties: n}, val, _path)
	when map_size(val) >= n,
	do: :ok

	defp validate_min_properties(%Schema{type: :object, minProperties: n}, val, path) do
	{:error, "#{path}: Object property count #{map_size(val)} is less than minProperties: #{n}"}
	end

	@spec validate_object_properties(Enumerable.t(), MapSet.t(), %{}, String.t(), %{
	String.t() => Schema.t() \| Reference.t()
	}) :: :ok \| {:error, String.t()}
	defp validate_object_properties(properties = %{}, required, value = %{}, path, schemas = %{}) do
	properties
	\|> Enum.filter(fn {name, _schema} -> Map.has_key?(value, name) end)
	\|> validate_object_properties(required, value, path, schemas)
	end

	defp validate_object_properties([], _required, _val, _path, _schemas), do: :ok

	defp validate_object_properties(
	[{name, schema} \| rest],
	required,
	value = %{},
	path,
	schemas = %{}
	) do
	property_required = MapSet.member?(required, name)
	property_value = Map.get(value, name)
	property_path = "#{path}/#{name}"

	with :ok <-
	validate_object_property(
	schema,
	property_required,
	property_value,
	property_path,
	schemas
	),
	:ok <- validate_object_properties(rest, required, value, path, schemas) do
	:ok
	end
	end

	defp validate_object_property(_schema, false, nil, _path, _schemas), do: :ok

	defp validate_object_property(schema, _required, value, path, schemas) do
	validate(schema, value, path, schemas)
	end

	@doc """
	Get the names of all properties definied for a schema.

	Includes all properties directly defined in the schema, and all schemas
	included in the `allOf` list.
	"""
	def properties(schema = %Schema{type: :object, properties: properties = %{}}) do
	for({name, property} <- properties, do: {name, default(property)}) ++
	properties(%{schema \| properties: nil})
	end

	def properties(%Schema{allOf: schemas}) when is_list(schemas) do
	Enum.flat_map(schemas, &properties/1) \|> Enum.uniq()
	end

	def properties(schema_module) when is_atom(schema_module) do
	properties(schema_module.schema())
	end

	def properties(_), do: []

	defp default(schema_module) when is_atom(schema_module), do: schema_module.schema().default
	defp default(%{default: default}), do: default
	end
	diff --git a/test/operation2_test.exs b/test/operation2_test.exs
	index d5377d2..cb45fc3 100644
	--- a/test/operation2_test.exs
	+++ b/test/operation2_test.exs
	@@ -1,236 +1,258 @@
	defmodule OpenApiSpex.Operation2Test do
	use ExUnit.Case
	- alias OpenApiSpex.{Operation, Operation2, Schema}
	+ alias OpenApiSpex.{Operation, Operation2, Schema, Components, Reference}
	alias OpenApiSpex.Cast.Error

	defmodule SchemaFixtures do
	@user %Schema{
	type: :object,
	properties: %{
	user: %Schema{
	type: :object,
	properties: %{
	email: %Schema{type: :string}
	}
	}
	}
	}
	@user_list %Schema{
	type: :array,
	items: @user
	}
	@schemas %{"User" => @user, "UserList" => @user_list}

	def user, do: @user
	def user_list, do: @user_list
	def schemas, do: @schemas
	end

	+ defmodule ParameterFixtures do
	+ alias OpenApiSpex.Operation
	+
	+ def parameters do
	+ %{
	+ "member" => Operation.parameter(:member, :query, :boolean, "Membership flag")
	+ }
	+ end
	+ end
	+
	defmodule OperationFixtures do
	@user_index %Operation{
	operationId: "UserController.index",
	parameters: [
	Operation.parameter(:name, :query, :string, "Filter by user name"),
	- Operation.parameter(:age, :query, :integer, "User's age")
	+ Operation.parameter(:age, :query, :integer, "User's age"),
	+ %Reference{"$ref": "#/components/parameters/member"}
	],
	responses: %{
	200 => Operation.response("User", "application/json", SchemaFixtures.user())
	}
	}

	def user_index, do: @user_index

	@create_user %Operation{
	operationId: "UserController.create",
	parameters: [
	Operation.parameter(:name, :query, :string, "Filter by user name")
	],
	requestBody:
	Operation.request_body("request body", "application/json", SchemaFixtures.user(),
	required: true
	),
	responses: %{
	200 => Operation.response("User list", "application/json", SchemaFixtures.user_list())
	}
	}

	def create_user, do: @create_user
	end

	defmodule SpecModule do
	@behaviour OpenApiSpex.OpenApi

	@impl OpenApiSpex.OpenApi
	def spec do
	paths = %{
	"/users" => %{
	"post" => OperationFixtures.create_user()
	}
	}

	%OpenApiSpex.OpenApi{
	info: nil,
	paths: paths,
	- components: %{
	- schemas: SchemaFixtures.schemas()
	+ components: %Components{
	+ schemas: SchemaFixtures.schemas(),
	+ parameters: ParameterFixtures.parameters()
	}
	}
	end
	end

	defmodule RenderError do
	def init(_) do
	nil
	end

	def call(_conn, _errors) do
	raise "should not have errors"
	end
	end

	describe "cast/4" do
	test "cast request body" do
	conn = create_conn(%{"user" => %{"email" => "foo@bar.com"}})

	assert {:ok, conn} =
	Operation2.cast(
	OperationFixtures.create_user(),
	conn,
	"application/json",
	- SchemaFixtures.schemas()
	+ SpecModule.spec().components
	)

	assert %Plug.Conn{} = conn
	end

	test "cast request body - invalid data type" do
	conn = create_conn(%{"user" => %{"email" => 123}})

	assert {:error, errors} =
	Operation2.cast(
	OperationFixtures.create_user(),
	conn,
	"application/json",
	- SchemaFixtures.schemas()
	+ SpecModule.spec().components
	)

	assert [error] = errors
	assert %Error{} = error
	assert error.reason == :invalid_type
	end

	+ test "casts valid query params" do
	+ valid_query_params = %{"name" => "Rubi", "age" => "31", "member" => "true"}
	+ assert {:ok, conn} = do_index_cast(valid_query_params)
	+ assert conn.params == %{age: 31, member: true, name: "Rubi"}
	+ end
	+
	test "validate undefined query param name" do
	query_params = %{"unknown" => "asdf"}

	assert {:error, [error]} = do_index_cast(query_params)

	assert %Error{} = error
	assert error.reason == :unexpected_field
	assert error.name == "unknown"
	assert error.path == ["unknown"]
	end

	test "validate invalid data type for query param" do
	query_params = %{"age" => "asdf"}
	assert {:error, [error]} = do_index_cast(query_params)
	assert %Error{} = error
	assert error.reason == :invalid_type
	assert error.type == :integer
	assert error.value == "asdf"
	end

	test "validate missing required query param" do
	parameter =
	Operation.parameter(:name, :query, :string, "Filter by user name", required: true)

	operation = %{OperationFixtures.user_index() \| parameters: [parameter]}

	assert {:error, [error]} = do_index_cast(%{}, operation: operation)
	assert %Error{} = error
	assert error.reason == :missing_field
	assert error.name == :name
	end

	test "validate missing content-type header for required requestBody" do
	conn = :post \|> Plug.Test.conn("/api/users/") \|> Plug.Conn.fetch_query_params()
	operation = OperationFixtures.create_user()
	- assert {:error, [%Error{reason: :missing_header, name: "content-type"}]} = Operation2.cast(
	- operation,
	- conn,
	- nil,
	- SchemaFixtures.schemas()
	- )
	+
	+ assert {:error, [%Error{reason: :missing_header, name: "content-type"}]} =
	+ Operation2.cast(
	+ operation,
	+ conn,
	+ nil,
	+ SpecModule.spec().components
	+ )
	end

	test "validate invalid content-type header for required requestBody" do
	conn =
	create_conn(%{})
	\|> Plug.Conn.put_req_header("content-type", "text/html")

	operation = OperationFixtures.create_user()
	- assert {:error, [%Error{reason: :invalid_header, name: "content-type"}]} = Operation2.cast(
	- operation,
	- conn,
	- "text/html",
	- SchemaFixtures.schemas()
	- )
	+
	+ assert {:error, [%Error{reason: :invalid_header, name: "content-type"}]} =
	+ Operation2.cast(
	+ operation,
	+ conn,
	+ "text/html",
	+ SpecModule.spec().components
	+ )
	end

	test "validate invalid value for integer range" do
	parameter =
	Operation.parameter(
	:age,
	:query,
	%Schema{type: :integer, minimum: 1, maximum: 99},
	"Filter by user age",
	required: true
	)

	operation = %{OperationFixtures.user_index() \| parameters: [parameter]}

	assert {:error, [error]} = do_index_cast(%{"age" => 100}, operation: operation)
	assert %Error{} = error
	assert error.reason == :maximum

	assert {:error, [error]} = do_index_cast(%{"age" => 0}, operation: operation)
	assert %Error{} = error
	assert error.reason == :minimum
	end

	defp do_index_cast(query_params, opts \\ []) do
	conn =
	:get
	\|> Plug.Test.conn("/api/users?" <> URI.encode_query(query_params))
	\|> Plug.Conn.put_req_header("content-type", "application/json")
	\|> Plug.Conn.fetch_query_params()
	\|> build_params()

	operation = opts[:operation] \|\| OperationFixtures.user_index()

	Operation2.cast(
	operation,
	conn,
	"application/json",
	- SchemaFixtures.schemas()
	+ SpecModule.spec().components
	)
	end

	defp create_conn(body_params) do
	:post
	\|> Plug.Test.conn("/api/users")
	\|> Plug.Conn.put_req_header("content-type", "application/json")
	\|> Plug.Conn.fetch_query_params()
	\|> Map.put(:body_params, body_params)
	\|> build_params()
	end

	defp build_params(conn) do
	params =
	conn.path_params
	\|> Map.merge(conn.query_params)
	\|> Map.merge(conn.body_params)

	%{conn \| params: params}
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Thu, Nov 28, 5:46 AM (1 d, 17 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 40900
Default Alt Text: (57 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions