No OneTemporary
Actions

Size

63 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/README.md b/README.md
	index bab7e7b..c55cb12 100644
	--- a/README.md
	+++ b/README.md
	@@ -1,305 +1,328 @@
	# Open API Spex
	[![Build Status](https://travis-ci.com/open-api-spex/open_api_spex.svg?branch=master)](https://travis-ci.com/open-api-spex/open_api_spex)
	[![Hex.pm](https://img.shields.io/hexpm/v/open_api_spex.svg)](https://hex.pm/packages/open_api_spex)


	Leverage Open Api Specification 3 (swagger) to document, test, validate and explore your Plug and Phoenix APIs.

	- Generate and serve a JSON Open Api Spec document from your code
	- Use the spec to cast request params to well defined schema structs
	- Validate params against schemas, eliminate bad requests before they hit your controllers
	- Validate responses against schemas in tests, ensuring your docs are accurate and reliable
	- Explore the API interactively with with [SwaggerUI](https://swagger.io/swagger-ui/)

	Full documentation available on [hexdocs](https://hexdocs.pm/open_api_spex/)

	## Installation

	The package can be installed by adding `open_api_spex` to your list of dependencies in `mix.exs`:

	```elixir
	def deps do
	[
	{:open_api_spex, "~> 3.4"}
	]
	end
	```

	## Generate Spec

	Start by adding an `ApiSpec` module to your application to populate an `OpenApiSpex.OpenApi` struct.

	```elixir
	-defmodule MyApp.ApiSpec do
	+defmodule MyAppWeb.ApiSpec do
	alias OpenApiSpex.{OpenApi, Server, Info, Paths}
	+ alias MyAppWeb.{Endpoint, Router}
	@behaviour OpenApi

	@impl OpenApi
	def spec do
	%OpenApi{
	servers: [
	# Populate the Server info from a phoenix endpoint
	- Server.from_endpoint(MyAppWeb.Endpoint, otp_app: :my_app)
	+ Server.from_endpoint(Endpoint)
	],
	info: %Info{
	title: "My App",
	version: "1.0"
	},
	# populate the paths from a phoenix router
	- paths: Paths.from_router(MyAppWeb.Router)
	+ paths: Paths.from_router(Router)
	}
	\|> OpenApiSpex.resolve_schema_modules() # discover request/response schemas from path specs
	end
	end
	```

	For each plug (controller) that will handle api requests, add an `open_api_operation` callback.
	It will be passed the plug opts that were declared in the router, this will be the action for a phoenix controller. The callback populates an `OpenApiSpex.Operation` struct describing the plug/action.

	```elixir
	-defmodule MyApp.UserController do
	+defmodule MyAppWeb.UserController do
	alias OpenApiSpex.Operation
	- alias MyApp.Schemas.UserResponse
	+ alias MyAppWeb.Schemas.UserResponse

	- @spec open_api_operation(any) :: Operation.t
	+ @spec open_api_operation(atom) :: Operation.t()
	def open_api_operation(action) do
	operation = String.to_existing_atom("#{action}_operation")
	apply(__MODULE__, operation, [])
	end

	- @spec show_operation() :: Operation.t
	+ @spec show_operation() :: Operation.t()
	def show_operation() do
	-
	%Operation{
	tags: ["users"],
	summary: "Show user",
	description: "Show a user by ID",
	operationId: "UserController.show",
	parameters: [
	- Operation.parameter(:id, :path, :integer, "User ID", example: 123)
	+ Operation.parameter(:id, :path, :integer, "User ID", example: 123, required: true)
	],
	responses: %{
	200 => Operation.response("User", "application/json", UserResponse)
	}
	}
	end
	- def show(conn, %{"id" => id}) do
	+
	+ # Controller's `show` action
	+ def show(conn, %{id: id}) do
	{:ok, user} = MyApp.Users.find_by_id(id)
	json(conn, 200, user)
	end
	+
	+ # For examples of other action operations, see
	+ # https://github.com/open-api-spex/open_api_spex/blob/master/examples/phoenix_app/lib/phoenix_app_web/controllers/user_controller.ex
	end
	```

	Declare the JSON schemas for request/response bodies in a `Schemas` module:
	Each module should implement the `OpenApiSpex.Schema` behaviour.
	The only callback is `schema/0`, which should return an `OpenApiSpex.Schema` struct.
	You may optionally declare a struct, linked to the JSON schema through the `x-struct` extension property.
	See `OpenApiSpex.schema/1` macro for a convenient way to reduce some boilerplate.

	```elixir
	-defmodule MyApp.Schemas do
	+defmodule MyAppWeb.Schemas do
	alias OpenApiSpex.Schema

	defmodule User do
	- @behaviour OpenApiSpex.Schema
	- @derive [Jason.Encoder]
	- @schema %Schema{
	+ 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"},
	+ 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},
	birthday: %Schema{type: :string, description: "Birth date", format: :date},
	- inserted_at: %Schema{type: :string, description: "Creation timestamp", format: :datetime},
	- updated_at: %Schema{type: :string, description: "Update timestamp", format: :datetime}
	+ 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",
	- "email" => "joe@gmail.com"
	- },
	- "x-struct": __MODULE__
	- }
	-
	- def schema, do: @schema
	- defstruct Map.keys(@schema.properties)
	+ "name" => "Joe User",
	+ "email" => "joe@gmail.com",
	+ "birthday" => "1970-01-01T12:34:55Z",
	+ "inserted_at" => "2017-09-12T12:34:55Z",
	+ "updated_at" => "2017-09-13T10:11:12Z"
	+ }
	+ })
	end

	defmodule UserResponse do
	require OpenApiSpex

	- # OpenApiSpex.schema/1 macro can be optionally used to reduce boilerplate code
	- OpenApiSpex.schema %{
	+ OpenApiSpex.schema(%{
	title: "UserResponse",
	description: "Response schema for single user",
	type: :object,
	properties: %{
	data: User
	+ },
	+ example: %{
	+ "data" => %{
	+ "id" => 123,
	+ "name" => "Joe User",
	+ "email" => "joe@gmail.com",
	+ "birthday" => "1970-01-01T12:34:55Z",
	+ "inserted_at" => "2017-09-12T12:34:55Z",
	+ "updated_at" => "2017-09-13T10:11:12Z"
	+ }
	}
	- }
	+ })
	end
	end
	```

	+For more examples of schema definitions, see the [sample Phoenix app](https://github.com/open-api-spex/open_api_spex/blob/master/examples/phoenix_app/lib/phoenix_app_web/schemas.ex)
	+
	Now you can create a mix task to write the swagger file to disk:

	```elixir
	defmodule Mix.Tasks.MyApp.OpenApiSpec do
	def run([output_file]) do
	json =
	- MyApp.ApiSpec.spec()
	+ MyAppWeb.ApiSpec.spec()
	\|> Jason.encode!(pretty: true)

	:ok = File.write!(output_file, json)
	end
	end
	```

	Generate the file with: `mix myapp.openapispec spec.json`

	## Serve Spec

	To serve the API spec from your application, first add the `OpenApiSpex.Plug.PutApiSpec` plug somewhere in the pipeline.

	```elixir
	pipeline :api do
	- plug OpenApiSpex.Plug.PutApiSpec, module: MyApp.ApiSpec
	+ plug OpenApiSpex.Plug.PutApiSpec, module: MyAppWeb.ApiSpec
	end
	```

	Now the spec will be available for use in downstream plugs.
	The `OpenApiSpex.Plug.RenderSpec` plug will render the spec as JSON:

	```elixir
	scope "/api" do
	pipe_through :api
	- resources "/users", MyApp.UserController, only: [:create, :index, :show]
	+ resources "/users", MyAppWeb.UserController, only: [:create, :index, :show]
	get "/openapi", OpenApiSpex.Plug.RenderSpec, []
	end
	```

	## Serve Swagger UI

	Once your API spec is available through a route, the `OpenApiSpex.Plug.SwaggerUI` plug can be used to serve a SwaggerUI interface. The `path:` plug option must be supplied to give the path to the API spec.

	All JavaScript and CSS assets are sourced from cdnjs.cloudflare.com, rather than vendoring into this package.

	```elixir
	scope "/" do
	pipe_through :browser # Use the default browser stack

	get "/", MyAppWeb.PageController, :index
	get "/swaggerui", OpenApiSpex.Plug.SwaggerUI, path: "/api/openapi"
	end

	scope "/api" do
	pipe_through :api

	resources "/users", MyAppWeb.UserController, only: [:create, :index, :show]
	get "/openapi", OpenApiSpex.Plug.RenderSpec, []
	end
	```

	## Validating and Casting Params

	+OpenApiSpex can automatically validate requests before they reach the controller action function. Or if you prefer,
	+you can explicitly call on OpenApiSpex to cast and validate the params within the controller action. This section
	+describes the former.
	+
	+First, the `plug OpenApiSpex.Plug.PutApiSpec` needs to be called in the Router, as described above.
	+
	Add the `OpenApiSpex.Plug.CastAndValidate` plug to a controller to validate request parameters, and to cast to Elixir types defined by the operation schema.

	```elixir
	-plug OpenApiSpex.Plug.CastAndValidate, operation_id: "UserController.show"
	+plug OpenApiSpex.Plug.CastAndValidate
	```

	The `operation_id` can be inferred when used from a Phoenix controller from the contents of `conn.private`.

	```elixir
	-defmodule MyApp.UserController do
	+defmodule MyAppWeb.UserController do
	use MyAppWeb, :controller
	alias OpenApiSpex.Operation
	- alias MyApp.Schemas.{User, UserRequest, UserResponse}
	+ alias MyAppWeb.Schemas.{User, UserRequest, UserResponse}

	plug OpenApiSpex.Plug.CastAndValidate

	def open_api_operation(action) do
	apply(__MODULE__, :"#{action}_operation", [])
	end

	def create_operation do
	import Operation
	%Operation{
	tags: ["users"],
	summary: "Create user",
	description: "Create a user",
	operationId: "UserController.create",
	parameters: [
	parameter(:id, :query, :integer, "user ID")
	],
	requestBody: request_body("The user attributes", "application/json", UserRequest),
	responses: %{
	201 => response("User", "application/json", UserResponse)
	}
	}
	end

	def create(conn = %{body_params: %UserRequest{user: %User{name: name, email: email, birthday: birthday = %Date{}}}}, %{id: id}) do
	# conn.body_params cast to UserRequest struct
	# conn.params.id cast to integer
	end
	end
	```

	Now the client will receive a 422 response whenever the request fails to meet the validation rules from the api spec.

	The response body will include the validation error message:

	```json
	{
	"errors": [
	{
	"message": "Invalid format. Expected :date",
	"source": {
	"pointer": "/data/birthday"
	},
	"title": "Invalid value"
	}
	]
	}
	```

	See also `OpenApiSpex.cast_and_validate/3` and `OpenApiSpex.Cast.cast/3` for more examples outside of a `plug` pipeline.

	## Validate Examples

	As schemas evolve, you may want to confirm that the examples given match the schemas.
	Use the `OpenApiSpex.Test.Assertions` module to assert on schema validations.

	```elixir
	use ExUnit.Case
	import OpenApiSpex.Test.Assertions

	test "UsersResponse example matches schema" do
	- api_spec = MyApp.ApiSpec.spec()
	- schema = MyApp.Schemas.UsersResponse.schema()
	+ api_spec = MyAppWeb.ApiSpec.spec()
	+ schema = MyAppWeb.Schemas.UsersResponse.schema()
	assert_schema(schema.example, "UsersResponse", api_spec)
	end
	```

	## Validate Responses

	API responses can be tested against schemas using `OpenApiSpex.Test.Assertions` also:

	```elixir
	-use MyApp.ConnCase
	+use MyAppWeb.ConnCase
	import OpenApiSpex.Test.Assertions

	test "UserController produces a UsersResponse", %{conn: conn} do
	- api_spec = MyApp.ApiSpec.spec()
	+ api_spec = MyAppWeb.ApiSpec.spec()
	json =
	conn
	\|> get(user_path(conn, :index))
	\|> json_response(200)

	assert_schema(json, "UsersResponse", api_spec)
	end
	```
	diff --git a/examples/phoenix_app/lib/phoenix_app_web/controllers/user_controller.ex b/examples/phoenix_app/lib/phoenix_app_web/controllers/user_controller.ex
	index a5da601..ee5a49f 100644
	--- a/examples/phoenix_app/lib/phoenix_app_web/controllers/user_controller.ex
	+++ b/examples/phoenix_app/lib/phoenix_app_web/controllers/user_controller.ex
	@@ -1,82 +1,84 @@
	defmodule PhoenixAppWeb.UserController do
	use PhoenixAppWeb, :controller
	import OpenApiSpex.Operation, only: [parameter: 5, request_body: 4, response: 3]
	alias OpenApiSpex.Operation
	alias PhoenixApp.{Accounts, Accounts.User}
	alias PhoenixAppWeb.Schemas

	plug(OpenApiSpex.Plug.Cast)
	plug(OpenApiSpex.Plug.Validate)

	def open_api_operation(action) do
	apply(__MODULE__, :"#{action}_operation", [])
	end

	def index_operation() do
	%Operation{
	tags: ["users"],
	summary: "List users",
	description: "List all useres",
	operationId: "UserController.index",
	responses: %{
	200 => response("User List Response", "application/json", Schemas.UsersResponse)
	}
	}
	end

	def index(conn, _params) do
	users = Accounts.list_users()
	render(conn, "index.json", users: users)
	end

	def create_operation() do
	%Operation{
	tags: ["users"],
	summary: "Create user",
	description: "Create a user",
	operationId: "UserController.create",
	parameters: [
	Operation.parameter(:group_id, :path, :integer, "Group ID", example: 1)
	],
	requestBody:
	request_body("The user attributes", "application/json", Schemas.UserRequest,
	required: true
	),
	responses: %{
	201 => response("User", "application/json", Schemas.UserResponse)
	}
	}
	end

	- def create(conn = %{body_params: %Schemas.UserRequest{user: user_params}}, %{group_id: _group_id}) do
	+ def create(conn = %{body_params: %Schemas.UserRequest{user: user_params}}, %{
	+ group_id: _group_id
	+ }) do
	with {:ok, %User{} = user} <- Accounts.create_user(user_params) do
	conn
	\|> put_status(:created)
	\|> put_resp_header("location", user_path(conn, :show, user))
	\|> render("show.json", user: user)
	end
	end

	@doc """
	API Spec for :show action
	"""
	def show_operation() do
	%Operation{
	tags: ["users"],
	summary: "Show user",
	description: "Show a user by ID",
	operationId: "UserController.show",
	parameters: [
	- parameter(:id, :path, :integer, "User ID", example: 123, minimum: 1)
	+ parameter(:id, :path, :integer, "User ID", example: 123, minimum: 1, required: true)
	],
	responses: %{
	200 => response("User", "application/json", Schemas.UserResponse)
	}
	}
	end

	def show(conn, %{id: id}) do
	user = Accounts.get_user!(id)
	render(conn, "show.json", user: user)
	end
	end
	diff --git a/examples/phoenix_app/lib/phoenix_app_web/schemas.ex b/examples/phoenix_app/lib/phoenix_app_web/schemas.ex
	index 66832b1..6d1af52 100644
	--- a/examples/phoenix_app/lib/phoenix_app_web/schemas.ex
	+++ b/examples/phoenix_app/lib/phoenix_app_web/schemas.ex
	@@ -1,91 +1,96 @@
	defmodule PhoenixAppWeb.Schemas do
	require OpenApiSpex
	alias OpenApiSpex.Schema

	defmodule User do
	- OpenApiSpex.schema %{
	+ 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_]+/},
	+ 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'}
	+ birthday: %Schema{type: :string, description: "Birth date", format: :date},
	+ 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

	defmodule UserRequest do
	- OpenApiSpex.schema %{
	+ OpenApiSpex.schema(%{
	title: "UserRequest",
	description: "POST body for creating a user",
	type: :object,
	properties: %{
	user: %Schema{anyOf: [User]}
	},
	required: [:user],
	example: %{
	"user" => %{
	"name" => "Joe User",
	"email" => "joe@gmail.com"
	}
	}
	- }
	+ })
	end

	defmodule UserResponse do
	- OpenApiSpex.schema %{
	+ OpenApiSpex.schema(%{
	title: "UserResponse",
	description: "Response schema for single user",
	type: :object,
	properties: %{
	data: User
	},
	example: %{
	"data" => %{
	"id" => 123,
	"name" => "Joe User",
	"email" => "joe@gmail.com",
	"inserted_at" => "2017-09-12T12:34:55Z",
	"updated_at" => "2017-09-13T10:11:12Z"
	}
	},
	"x-struct": __MODULE__
	- }
	+ })
	end

	defmodule UsersResponse do
	- OpenApiSpex.schema %{
	+ OpenApiSpex.schema(%{
	title: "UsersResponse",
	description: "Response schema for multiple users",
	type: :object,
	properties: %{
	data: %Schema{description: "The users details", type: :array, items: User}
	},
	example: %{
	"data" => [
	%{
	"id" => 123,
	"name" => "Joe User",
	"email" => "joe@gmail.com"
	},
	%{
	"id" => 456,
	"name" => "Jay Consumer",
	"email" => "jay@yahoo.com"
	}
	]
	}
	- }
	+ })
	end
	end
	diff --git a/lib/open_api_spex/cast/string.ex b/lib/open_api_spex/cast/string.ex
	index 723cf9c..b39d015 100644
	--- a/lib/open_api_spex/cast/string.ex
	+++ b/lib/open_api_spex/cast/string.ex
	@@ -1,87 +1,87 @@
	defmodule OpenApiSpex.Cast.String do
	@moduledoc """

	This module will cast a binary to either an Elixir DateTime or Date. Otherwise it will
	validate a binary based on maxLength, minLength, or a Regex pattern passed through the
	schema struct.

	"""
	alias OpenApiSpex.{Cast, Cast.Error}

	@schema_fields [:maxLength, :minLength, :pattern]

	def cast(%{value: value, schema: %{format: :date}} = ctx) when is_binary(value) do
	case Date.from_iso8601(value) do
	{:ok, %Date{} = date} ->
	{:ok, date}

	_ ->
	Cast.error(ctx, {:invalid_format, :date})
	end
	end

	def cast(%{value: value, schema: %{format: :"date-time"}} = ctx) when is_binary(value) do
	case DateTime.from_iso8601(value) do
	- {:ok, %DateTime{} = datetime, _offset} ->
	- {:ok, datetime}
	+ {:ok, %DateTime{} = date_time, _offset} ->
	+ {:ok, date_time}

	_ ->
	Cast.error(ctx, {:invalid_format, :"date-time"})
	end
	end

	def cast(%{value: value} = ctx) when is_binary(value) do
	apply_validation(ctx, @schema_fields)
	end

	def cast(ctx) do
	Cast.error(ctx, {:invalid_type, :string})
	end

	## Private functions

	defp apply_validation(%{value: value, schema: %{maxLength: max_length}} = ctx, [
	:maxLength \| fields
	])
	when is_integer(max_length) do
	if String.length(value) > max_length do
	ctx
	\|> apply_error({:max_length, max_length})
	\|> apply_validation(fields)
	else
	apply_validation(ctx, fields)
	end
	end

	defp apply_validation(%{value: value, schema: %{minLength: min_length}} = ctx, [
	:minLength \| fields
	])
	when is_integer(min_length) do
	if String.length(value) < min_length do
	ctx
	\|> apply_error({:min_length, min_length})
	\|> apply_validation(fields)
	else
	apply_validation(ctx, fields)
	end
	end

	defp apply_validation(%{value: value, schema: %{pattern: pattern}} = ctx, [:pattern \| fields])
	when not is_nil(pattern) do
	if Regex.match?(pattern, value) do
	apply_validation(ctx, fields)
	else
	ctx
	\|> apply_error({:invalid_format, pattern})
	\|> apply_validation(fields)
	end
	end

	defp apply_validation(ctx, [_field \| fields]), do: apply_validation(ctx, fields)
	defp apply_validation(%{value: value, errors: []}, []), do: {:ok, value}
	defp apply_validation(%{errors: errors}, []) when length(errors) > 0, do: {:error, errors}

	defp apply_error(%{errors: errors} = ctx, error_args) do
	Map.put(ctx, :errors, [Error.new(ctx, error_args) \| errors])
	end
	end
	diff --git a/lib/open_api_spex/schema.ex b/lib/open_api_spex/schema.ex
	index 28c27f4..d47d5f6 100644
	--- a/lib/open_api_spex/schema.ex
	+++ b/lib/open_api_spex/schema.ex
	@@ -1,860 +1,860 @@
	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"},
	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, datetime = %DateTime{}, _offset} -> {:ok, datetime}
	+ {: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}, 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: 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/schema_test.exs b/test/schema_test.exs
	index d6ce9b1..965b8aa 100644
	--- a/test/schema_test.exs
	+++ b/test/schema_test.exs
	@@ -1,460 +1,460 @@
	defmodule OpenApiSpex.SchemaTest do
	use ExUnit.Case
	alias OpenApiSpex.Schema
	alias OpenApiSpexTest.{ApiSpec, Schemas}
	import OpenApiSpex.Test.Assertions

	doctest Schema

	describe "schema/1" do
	test "EntityWithDict Schema example matches schema" do
	api_spec = ApiSpec.spec()
	assert_schema(Schemas.EntityWithDict.schema().example, "EntityWithDict", api_spec)
	end

	test "User Schema example matches schema" do
	spec = ApiSpec.spec()

	assert_schema(Schemas.User.schema().example, "User", spec)
	assert_schema(Schemas.UserRequest.schema().example, "UserRequest", spec)
	assert_schema(Schemas.UserResponse.schema().example, "UserResponse", spec)
	assert_schema(Schemas.UsersResponse.schema().example, "UsersResponse", spec)
	end
	end

	describe "cast/3" do
	test "cast request schema" do
	api_spec = ApiSpec.spec()
	schemas = api_spec.components.schemas
	user_request_schema = schemas["UserRequest"]

	input = %{
	"user" => %{
	"id" => 123,
	"name" => "asdf",
	"email" => "foo@bar.com",
	"updated_at" => "2017-09-12T14:44:55Z"
	}
	}

	{:ok, output} = Schema.cast(user_request_schema, input, schemas)

	assert output == %OpenApiSpexTest.Schemas.UserRequest{
	user: %OpenApiSpexTest.Schemas.User{
	id: 123,
	name: "asdf",
	email: "foo@bar.com",
	updated_at: DateTime.from_naive!(~N[2017-09-12T14:44:55], "Etc/UTC")
	}
	}
	end

	test "cast request schema with unexpected fields returns error" do
	api_spec = ApiSpec.spec()
	schemas = api_spec.components.schemas
	user_request_schema = schemas["UserRequest"]

	input = %{
	"user" => %{
	"id" => 123,
	"name" => "asdf",
	"email" => "foo@bar.com",
	"updated_at" => "2017-09-12T14:44:55Z",
	"unexpected_field" => "unexpected value"
	}
	}

	assert {:error, _} = Schema.cast(user_request_schema, input, schemas)
	end

	test "Cast Cat from Pet schema" do
	api_spec = ApiSpec.spec()
	schemas = api_spec.components.schemas
	pet_schema = schemas["Pet"]

	input = %{
	"pet_type" => "Cat",
	"meow" => "meow"
	}

	assert {:ok, %Schemas.Cat{meow: "meow", pet_type: "Cat"}} =
	Schema.cast(pet_schema, input, schemas)
	end

	test "Cast Dog from oneOf [cat, dog] schema" do
	api_spec = ApiSpec.spec()
	schemas = api_spec.components.schemas
	cat_or_dog = Map.fetch!(schemas, "CatOrDog")

	input = %{
	"pet_type" => "Cat",
	"meow" => "meow"
	}

	assert {:ok, %Schemas.Cat{meow: "meow", pet_type: "Cat"}} =
	Schema.cast(cat_or_dog, input, schemas)
	end

	test "Cast number to string or number" do
	schema = %Schema{
	oneOf: [
	%Schema{type: :number},
	%Schema{type: :string}
	]
	}

	result = Schema.cast(schema, "123", %{})

	assert {:ok, 123.0} = result
	end

	test "Cast integer to float" do
	schema = %Schema{type: :number}

	assert Schema.cast(schema, 123, %{}) === {:ok, 123.0}
	end

	- test "Cast string to oneOf number or datetime" do
	+ test "Cast string to oneOf number or date-time" do
	schema = %Schema{
	oneOf: [
	%Schema{type: :number},
	%Schema{type: :string, format: :"date-time"}
	]
	}

	assert {:ok, %DateTime{}} = Schema.cast(schema, "2018-04-01T12:34:56Z", %{})
	end

	- test "Cast string to anyOf number or datetime" do
	+ test "Cast string to anyOf number or date-time" do
	schema = %Schema{
	oneOf: [
	%Schema{type: :number},
	%Schema{type: :string, format: :"date-time"}
	]
	}

	assert {:ok, %DateTime{}} = Schema.cast(schema, "2018-04-01T12:34:56Z", %{})
	end
	end

	describe "Integer validation" do
	test "Validate schema type integer when value is object" do
	schema = %Schema{
	type: :integer
	}

	assert {:error, _} = Schema.validate(schema, %{}, %{})
	end
	end

	describe "Number validation" do
	test "Validate schema type number when value is object" do
	schema = %Schema{
	type: :integer
	}

	assert {:error, _} = Schema.validate(schema, %{}, %{})
	end

	test "Validate schema type number when value is exclusive" do
	schema = %Schema{
	type: :integer,
	minimum: -1,
	maximum: 1,
	exclusiveMinimum: true,
	exclusiveMaximum: true
	}

	assert {:error, _} = Schema.validate(schema, 1, %{})
	assert {:error, _} = Schema.validate(schema, -1, %{})
	end
	end

	describe "String validation" do
	test "Validate schema type string when value is object" do
	schema = %Schema{
	type: :string
	}

	assert {:error, _} = Schema.validate(schema, %{}, %{})
	end

	test "Validate schema type string when value is DateTime" do
	schema = %Schema{
	type: :string
	}

	assert {:error, _} = Schema.validate(schema, DateTime.utc_now(), %{})
	end

	test "Validate non-empty string with expected value" do
	schema = %Schema{type: :string, minLength: 1}
	assert :ok = Schema.validate(schema, "BLIP", %{})
	end
	end

	describe "DateTime validation" do
	test "Validate schema type string with format date-time when value is DateTime" do
	schema = %Schema{
	type: :string,
	format: :"date-time"
	}

	assert :ok = Schema.validate(schema, DateTime.utc_now(), %{})
	end
	end

	describe "Date Validation" do
	test "Validate schema type string with format date when value is Date" do
	schema = %Schema{
	type: :string,
	format: :date
	}

	assert :ok = Schema.validate(schema, Date.utc_today(), %{})
	end
	end

	describe "Enum validation" do
	test "Validate string enum with unexpected value" do
	schema = %Schema{
	type: :string,
	enum: ["foo", "bar"]
	}

	assert {:error, _} = Schema.validate(schema, "baz", %{})
	end

	test "Validate string enum with expected value" do
	schema = %Schema{
	type: :string,
	enum: ["foo", "bar"]
	}

	assert :ok = Schema.validate(schema, "bar", %{})
	end
	end

	describe "Object validation" do
	test "Validate schema type object when value is array" do
	schema = %Schema{
	type: :object
	}

	assert {:error, _} = Schema.validate(schema, [], %{})
	end

	test "Validate schema type object when value is DateTime" do
	schema = %Schema{
	type: :object
	}

	assert {:error, _} = Schema.validate(schema, DateTime.utc_now(), %{})
	end
	end

	describe "Array validation" do
	test "Validate schema type array when value is object" do
	schema = %Schema{
	type: :array
	}

	assert {:error, _} = Schema.validate(schema, %{}, %{})
	end
	end

	describe "Boolean validation" do
	test "Validate schema type boolean when value is object" do
	schema = %Schema{
	type: :boolean
	}

	assert {:error, _} = Schema.validate(schema, %{}, %{})
	end
	end

	describe "AnyOf validation" do
	test "Validate anyOf schema with valid value" do
	schema = %Schema{
	anyOf: [
	%Schema{type: :array},
	%Schema{type: :string}
	]
	}

	assert :ok = Schema.validate(schema, "a string", %{})
	end

	test "Validate anyOf with value matching more than one schema" do
	schema = %Schema{
	anyOf: [
	%Schema{type: :number},
	%Schema{type: :integer}
	]
	}

	assert :ok = Schema.validate(schema, 42, %{})
	end

	test "Validate anyOf schema with invalid value" do
	schema = %Schema{
	anyOf: [
	%Schema{type: :string},
	%Schema{type: :array}
	]
	}

	assert {:error, _} = Schema.validate(schema, 3.14159, %{})
	end
	end

	describe "OneOf validation" do
	test "Validate oneOf schema with valid value" do
	schema = %Schema{
	oneOf: [
	%Schema{type: :string},
	%Schema{type: :array}
	]
	}

	assert :ok = Schema.validate(schema, [1, 2, 3], %{})
	end

	test "Validate oneOf schema with invalid value" do
	schema = %Schema{
	oneOf: [
	%Schema{type: :string},
	%Schema{type: :array}
	]
	}

	assert {:error, _} = Schema.validate(schema, 3.14159, %{})
	end

	test "Validate oneOf schema when matching multiple schemas" do
	schema = %Schema{
	oneOf: [
	%Schema{type: :object, properties: %{a: %Schema{type: :string}}},
	%Schema{type: :object, properties: %{b: %Schema{type: :string}}}
	]
	}

	assert {:error, _} = Schema.validate(schema, %{a: "a", b: "b"}, %{})
	end
	end

	describe "AllOf validation" do
	test "Validate allOf schema with valid value" do
	schema = %Schema{
	allOf: [
	%Schema{type: :object, properties: %{a: %Schema{type: :string}}},
	%Schema{type: :object, properties: %{b: %Schema{type: :string}}}
	]
	}

	assert :ok = Schema.validate(schema, %{a: "a", b: "b"}, %{})
	end

	test "Validate allOf schema with invalid value" do
	schema = %Schema{
	allOf: [
	%Schema{type: :object, properties: %{a: %Schema{type: :string}}},
	%Schema{type: :object, properties: %{b: %Schema{type: :string}}}
	]
	}

	assert {:error, msg} = Schema.validate(schema, %{a: 1, b: 2}, %{})
	assert msg =~ "#/a"
	assert msg =~ "#/b"
	end

	test "Validate allOf with value matching not all schemas" do
	schema = %Schema{
	allOf: [
	%Schema{
	type: :integer,
	minimum: 5
	},
	%Schema{
	type: :integer,
	maximum: 40
	}
	]
	}

	assert {:error, _} = Schema.validate(schema, 42, %{})
	end
	end

	describe "Not validation" do
	test "Validate not schema with valid value" do
	schema = %Schema{
	not: %Schema{type: :object}
	}

	assert :ok = Schema.validate(schema, 1, %{})
	end

	test "Validate not schema with invalid value" do
	schema = %Schema{
	not: %Schema{type: :object}
	}

	assert {:error, _} = Schema.validate(schema, %{a: 1}, %{})
	end

	test "Verify 'not' validation" do
	schema = %Schema{not: %Schema{type: :boolean}}
	assert :ok = Schema.validate(schema, 42, %{})
	assert :ok = Schema.validate(schema, "42", %{})
	assert :ok = Schema.validate(schema, nil, %{})
	assert :ok = Schema.validate(schema, 4.2, %{})
	assert :ok = Schema.validate(schema, [4], %{})
	assert :ok = Schema.validate(schema, %{}, %{})
	assert {:error, _} = Schema.validate(schema, true, %{})
	assert {:error, _} = Schema.validate(schema, false, %{})
	end
	end

	describe "Nullable validation" do
	test "Validate nullable-ified with expected value" do
	schema = %Schema{
	nullable: true,
	type: :string,
	minLength: 1
	}

	assert :ok = Schema.validate(schema, "BLIP", %{})
	end

	test "Validate nullable with expected value" do
	schema = %Schema{type: :string, nullable: true}
	assert :ok = Schema.validate(schema, nil, %{})
	end

	test "Validate nullable with unexpected value" do
	schema = %Schema{type: :string, nullable: true}
	assert :ok = Schema.validate(schema, "bla", %{})
	end
	end

	describe "Default property value" do
	test "Available in structure" do
	size = %Schemas.Size{}
	assert "cm" == size.unit
	assert 100 == size.value
	end

	test "Available after cast" do
	api_spec = ApiSpec.spec()
	schemas = api_spec.components.schemas
	size = Map.fetch!(schemas, "Size")

	assert {:ok, %Schemas.Size{value: 100, unit: "cm"}} ==
	Schema.cast(size, %{}, schemas)

	assert {:ok, %Schemas.Size{value: 110, unit: "cm"}} ==
	Schema.cast(size, %{value: 110}, schemas)
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Thu, Nov 28, 11:43 PM (1 d, 11 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 41115
Default Alt Text: (63 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions