No OneTemporary
Actions

Size

24 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/README.md b/README.md
	index 0956b75..4410d95 100644
	--- a/README.md
	+++ b/README.md
	@@ -1,299 +1,290 @@
	# 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.2"}
	]
	end
	```

	## Generate Spec

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

	```elixir
	defmodule MyApp.ApiSpec do
	alias OpenApiSpex.{OpenApi, Server, Info, Paths}

	def spec do
	%OpenApi{
	servers: [
	# Populate the Server info from a phoenix endpoint
	Server.from_endpoint(MyAppWeb.Endpoint, otp_app: :my_app)
	],
	info: %Info{
	title: "My App",
	version: "1.0"
	},
	# populate the paths from a phoenix router
	paths: Paths.from_router(MyAppWeb.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
	alias OpenApiSpex.Operation
	alias MyApp.Schemas.UserResponse

	@spec open_api_operation(any) :: Operation.t
	def open_api_operation(action), do: apply(__MODULE__, :"#{action}_operation", [])

	@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)
	],
	responses: %{
	200 => Operation.response("User", "application/json", UserResponse)
	}
	}
	end
	def show(conn, %{"id" => id}) do
	{:ok, user} = MyApp.Users.find_by_id(id)
	json(conn, 200, user)
	end
	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
	alias OpenApiSpex.Schema

	defmodule User do
	@behaviour OpenApiSpex.Schema
	@derive [Jason.Encoder]
	@schema %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"},
	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}
	},
	required: [:name, :email],
	example: %{
	"id" => 123,
	"name" => "Joe",
	"email" => "joe@gmail.com"
	- }
	+ },
	"x-struct": __MODULE__
	}
	+
	def schema, do: @schema
	defstruct Map.keys(@schema.properties)
	end

	defmodule UserResponse do
	require OpenApiSpex

	# OpenApiSpex.schema/1 macro can be optionally used to reduce boilerplate code
	OpenApiSpex.schema %{
	title: "UserResponse",
	description: "Response schema for single user",
	type: :object,
	properties: %{
	data: User
	}
	}
	end
	end
	```

	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()
	- \|> Poison.encode!(pretty: true)
	+ \|> 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
	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]
	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.
	+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
	```

	-## Cast Params
	+## Validating and Casting Params

	-Add the `OpenApiSpex.Plug.Cast` plug to a controller to cast the request parameters and body to elixir types defined by the operation schema.
	+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.Cast, operation_id: "UserController.show"
	+plug OpenApiSpex.Plug.CastAndValidate, operation_id: "UserController.show"
	```

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

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

	- plug OpenApiSpex.Plug.Cast
	+ 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
	```
	-See also `OpenApiSpex.cast/3` and `OpenApiSpex.Schema.cast/3` for more examples outside of a `plug` pipeline.
	-
	-
	-## Validate Params
	-
	-Add both the `OpenApiSpex.Plug.Cast` and `OpenApiSpex.Plug.Validate` plugs to your controller / plug:
	-
	-```elixir
	-plug OpenApiSpex.Plug.Cast
	-plug OpenApiSpex.Plug.Validate
	-```

	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:

	```
	#/user/name: Value does not match pattern: [a-zA-Z][a-zA-Z0-9_]+
	```

	-See `OpenApiSpex.validate/3` and `OpenApiSpex.Schema.validate/3` for usage outside of a plug pipeline.
	+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()
	assert_schema(schema.example, "UsersResponse", api_spec)
	end
	```

	## Validate Responses

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

	```elixir
	use MyApp.ConnCase
	import OpenApiSpex.Test.Assertions

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

	assert_schema(json, "UsersResponse", api_spec)
	end
	```
	diff --git a/lib/open_api_spex/cast.ex b/lib/open_api_spex/cast.ex
	index 6714acb..ea49b44 100644
	--- a/lib/open_api_spex/cast.ex
	+++ b/lib/open_api_spex/cast.ex
	@@ -1,140 +1,193 @@
	defmodule OpenApiSpex.Cast do
	alias OpenApiSpex.{Reference, Schema}
	alias OpenApiSpex.Reference

	alias OpenApiSpex.Cast.{
	AllOf,
	AnyOf,
	Array,
	Discriminator,
	Error,
	Integer,
	Object,
	OneOf,
	Primitive,
	String
	}

	@type schema_or_reference :: Schema.t() \| Reference.t()
	@type t :: %__MODULE__{
	value: term(),
	schema: schema_or_reference \| nil,
	schemas: map(),
	path: [atom() \| String.t() \| integer()],
	key: atom() \| nil,
	index: integer,
	errors: [Error.t()]
	}

	defstruct value: nil,
	schema: nil,
	schemas: %{},
	path: [],
	key: nil,
	index: 0,
	errors: []

	+ @doc ~S"""
	+ Cast and validate a value against the given schema.
	+
	+ Recognizes all the types defined in Open API (itself a superset of JSON Schema).
	+
	+ JSON Schema types:
	+ https://json-schema.org/latest/json-schema-core.html#rfc.section.4.2.1
	+
	+ Open API primitive types:
	+ https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#data-types
	+
	+ For an `:object` schema type, the cast operation returns a map with atom keys.
	+
	+ ## Examples
	+
	+ iex> alias OpenApiSpex.{Cast, Schema}
	+ iex> schema = %Schema{type: :string}
	+ iex> Cast.cast(schema, "a string")
	+ {:ok, "a string"}
	+ iex> Cast.cast(schema, :not_a_string)
	+ {
	+ :error,
	+ [
	+ %OpenApiSpex.Cast.Error{
	+ reason: :invalid_type,
	+ type: :string,
	+ value: :not_a_string
	+ }
	+ ]
	+ }
	+ iex> schema = %Schema{
	+ ...> type: :object,
	+ ...> properties: %{
	+ ...> name: nil
	+ ...> }
	+ ...> }
	+ iex> Cast.cast(schema, %{"name" => "spex"})
	+ {:ok, %{name: "spex"}}
	+ iex> Cast.cast(schema, %{"bad" => "spex"})
	+ {
	+ :error,
	+ [
	+ %OpenApiSpex.Cast.Error{
	+ name: "bad",
	+ path: ["bad"],
	+ reason: :unexpected_field,
	+ value: %{"bad" => "spex"}
	+ }
	+ ]
	+ }
	+
	+ """
	+
	@spec cast(schema_or_reference \| nil, term(), map()) :: {:ok, term()} \| {:error, [Error.t()]}
	- def cast(schema, value, schemas) do
	+ def cast(schema, value, schemas \\ %{}) do
	ctx = %__MODULE__{schema: schema, value: value, schemas: schemas}
	cast(ctx)
	end

	@spec cast(t()) :: {:ok, term()} \| {:error, [Error.t()]}

	# nil schema
	def cast(%__MODULE__{value: value, schema: nil}),
	do: {:ok, value}

	def cast(%__MODULE__{schema: %Reference{}} = ctx) do
	schema = Reference.resolve_schema(ctx.schema, ctx.schemas)
	cast(%{ctx \| schema: schema})
	end

	# nullable: true
	def cast(%__MODULE__{value: nil, schema: %{nullable: true}}) do
	{:ok, nil}
	end

	# nullable: false
	def cast(%__MODULE__{value: nil} = ctx) do
	error(ctx, {:null_value})
	end

	# Enum
	def cast(%__MODULE__{schema: %{enum: []}} = ctx) do
	cast(%{ctx \| schema: %{ctx.schema \| enum: nil}})
	end

	# Enum
	def cast(%__MODULE__{schema: %{enum: enum}} = ctx) when is_list(enum) do
	with {:ok, value} <- cast(%{ctx \| schema: %{ctx.schema \| enum: nil}}) do
	if value in enum do
	{:ok, value}
	else
	error(ctx, {:invalid_enum})
	end
	end
	end

	## Specific types

	def cast(%__MODULE__{schema: %{type: :object, discriminator: discriminator}} = ctx)
	when is_map(discriminator),
	do: Discriminator.cast(ctx)

	def cast(%__MODULE__{schema: %{type: _, anyOf: schemas}} = ctx) when is_list(schemas),
	do: AnyOf.cast(ctx)

	def cast(%__MODULE__{schema: %{type: _, allOf: schemas}} = ctx) when is_list(schemas),
	do: AllOf.cast(ctx)

	def cast(%__MODULE__{schema: %{type: _, oneOf: schemas}} = ctx) when is_list(schemas),
	do: OneOf.cast(ctx)

	def cast(%__MODULE__{schema: %{type: :object}} = ctx),
	do: Object.cast(ctx)

	def cast(%__MODULE__{schema: %{type: :boolean}} = ctx),
	do: Primitive.cast_boolean(ctx)

	def cast(%__MODULE__{schema: %{type: :integer}} = ctx),
	do: Integer.cast(ctx)

	def cast(%__MODULE__{schema: %{type: :number}} = ctx),
	do: Primitive.cast_number(ctx)

	def cast(%__MODULE__{schema: %{type: :string}} = ctx),
	do: String.cast(ctx)

	def cast(%__MODULE__{schema: %{type: :array}} = ctx),
	do: Array.cast(ctx)

	def cast(%__MODULE__{schema: %{type: _other}} = ctx),
	do: error(ctx, {:invalid_schema_type})

	def cast(%{} = ctx), do: cast(struct(__MODULE__, ctx))
	def cast(ctx) when is_list(ctx), do: cast(struct(__MODULE__, ctx))

	# Add an error
	def error(ctx, error_args) do
	error = Error.new(ctx, error_args)
	{:error, [error \| ctx.errors]}
	end

	def ok(%__MODULE__{value: value}), do: {:ok, value}

	def success(%__MODULE__{schema: schema} = ctx, schema_properties)
	when is_list(schema_properties) do
	schema_without_successful_validation_property =
	Enum.reduce(schema_properties, schema, fn property, schema ->
	%{schema \| property => nil}
	end)

	{:cast, %{ctx \| schema: schema_without_successful_validation_property}}
	end

	def success(%__MODULE__{schema: _schema} = ctx, schema_property) do
	success(ctx, [schema_property])
	end
	end
	diff --git a/lib/open_api_spex/operation2.ex b/lib/open_api_spex/operation2.ex
	index f8cdef6..465b7b8 100644
	--- a/lib/open_api_spex/operation2.ex
	+++ b/lib/open_api_spex/operation2.ex
	@@ -1,38 +1,38 @@
	defmodule OpenApiSpex.Operation2 do
	@moduledoc """
	- Defines the `OpenApiSpex.Operation.t` type.
	+ Casts and validates a request from a Plug conn.
	"""
	alias OpenApiSpex.{
	Cast,
	CastParameters,
	Operation,
	RequestBody,
	Schema
	}

	alias OpenApiSpex.Cast.Error
	alias Plug.Conn

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

	## Private functions

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

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

	defp cast_request_body(%RequestBody{content: content}, params, content_type, schemas) do
	schema = content[content_type].schema
	Cast.cast(schema, params, schemas)
	end
	end
	diff --git a/test/cast_test.exs b/test/cast_test.exs
	index afca598..2d7ecd6 100644
	--- a/test/cast_test.exs
	+++ b/test/cast_test.exs
	@@ -1,231 +1,232 @@
	defmodule OpenApiSpec.CastTest do
	use ExUnit.Case
	alias OpenApiSpex.{Cast, Schema, Reference}
	alias OpenApiSpex.Cast.Error
	+ doctest OpenApiSpex.Cast

	def cast(ctx), do: Cast.cast(ctx)

	describe "cast/1" do
	test "unknown schema type" do
	assert {:error, [error]} = cast(value: "string", schema: %Schema{type: :nope})
	assert error.reason == :invalid_schema_type
	assert error.type == :nope

	assert {:error, [error]} = cast(value: "string", schema: %Schema{type: nil})
	assert error.reason == :invalid_schema_type
	assert error.type == nil
	end

	# Note: full tests for primitives are covered in Cast.PrimitiveTest
	test "primitives" do
	tests = [
	{:string, "1", :ok},
	{:string, "", :ok},
	{:string, true, :invalid},
	{:string, nil, :invalid},
	{:integer, 1, :ok},
	{:integer, "1", :ok},
	{:integer, %{}, :invalid},
	{:integer, nil, :invalid},
	{:array, nil, :invalid},
	{:object, nil, :invalid}
	]

	for {type, input, expected} <- tests do
	case expected do
	:ok -> assert {:ok, _} = cast(value: input, schema: %Schema{type: type})
	:invalid -> assert {:error, _} = cast(value: input, schema: %Schema{type: type})
	end
	end
	end

	test "array type, nullable, given nil" do
	schema = %Schema{type: :array, nullable: true}
	assert {:ok, nil} = cast(value: nil, schema: schema)
	end

	test "array type, given nil" do
	schema = %Schema{type: :array}
	assert {:error, [error]} = cast(value: nil, schema: schema)
	assert error.reason == :null_value
	assert Error.message_with_path(error) == "#: null value where array expected"
	end

	test "array" do
	schema = %Schema{type: :array}
	assert cast(value: [], schema: schema) == {:ok, []}
	assert cast(value: [1, 2, 3], schema: schema) == {:ok, [1, 2, 3]}
	assert cast(value: ["1", "2", "3"], schema: schema) == {:ok, ["1", "2", "3"]}

	assert {:error, [error]} = cast(value: %{}, schema: schema)
	assert %Error{} = error
	assert error.reason == :invalid_type
	assert error.value == %{}
	end

	test "array with items schema" do
	items_schema = %Schema{type: :integer}
	schema = %Schema{type: :array, items: items_schema}
	assert cast(value: [], schema: schema) == {:ok, []}
	assert cast(value: [1, 2, 3], schema: schema) == {:ok, [1, 2, 3]}
	assert cast(value: ["1", "2", "3"], schema: schema) == {:ok, [1, 2, 3]}

	assert {:error, errors} = cast(value: [1, "two"], schema: schema)
	assert [%Error{} = error] = errors
	assert error.reason == :invalid_type
	assert error.value == "two"
	assert error.path == [1]
	end

	# Additional object tests found in Cast.ObjectTest
	test "object with schema properties set, given known input property" do
	schema = %Schema{
	type: :object,
	properties: %{age: nil}
	}

	assert cast(value: %{}, schema: schema) == {:ok, %{}}
	assert cast(value: %{"age" => "hello"}, schema: schema) == {:ok, %{age: "hello"}}
	end

	test "reference" do
	age_schema = %Schema{type: :integer}

	assert cast(
	value: "20",
	schema: %Reference{"$ref": "#/components/schemas/Age"},
	schemas: %{"Age" => age_schema}
	) == {:ok, 20}
	end

	test "reference nested in object" do
	age_schema = %Schema{type: :integer}

	schema = %Schema{
	type: :object,
	properties: %{
	age: %Reference{"$ref": "#/components/schemas/Age"}
	}
	}

	assert cast(
	value: %{"age" => "20"},
	schema: schema,
	schemas: %{"Age" => age_schema}
	) == {:ok, %{age: 20}}
	end

	test "paths" do
	schema = %Schema{
	type: :object,
	properties: %{
	age: %Schema{type: :integer}
	}
	}

	assert {:error, errors} = cast(value: %{"age" => "twenty"}, schema: schema)
	assert [error] = errors
	assert %Error{} = error
	assert error.path == [:age]
	end

	test "nested paths" do
	schema = %Schema{
	type: :object,
	properties: %{
	data: %Schema{
	type: :object,
	properties: %{
	age: %Schema{type: :integer}
	}
	}
	}
	}

	assert {:error, errors} = cast(value: %{"data" => %{"age" => "twenty"}}, schema: schema)
	assert [error] = errors
	assert %Error{} = error
	assert error.path == [:data, :age]
	assert Error.message_with_path(error) == "#/data/age: Invalid integer. Got: string"
	end

	test "paths involving arrays" do
	schema = %Schema{
	type: :object,
	properties: %{
	data: %Schema{
	type: :array,
	items: %Schema{
	type: :object,
	properties: %{
	age: %Schema{type: :integer}
	}
	}
	}
	}
	}

	assert {:error, errors} =
	cast(value: %{"data" => [%{"age" => "20"}, %{"age" => "twenty"}]}, schema: schema)

	assert [error] = errors
	assert %Error{} = error
	assert error.path == [:data, 1, :age]
	assert Error.message_with_path(error) == "#/data/1/age: Invalid integer. Got: string"
	end

	test "multiple errors" do
	schema = %Schema{
	type: :array,
	items: %Schema{type: :integer}
	}

	value = [1, "two", 3, "four"]
	assert {:error, errors} = cast(value: value, schema: schema)
	assert [error, error2] = errors
	assert %Error{} = error
	assert error.reason == :invalid_type
	assert error.path == [1]
	assert Error.message_with_path(error) == "#/1: Invalid integer. Got: string"

	assert Error.message_with_path(error2) == "#/3: Invalid integer. Got: string"
	end

	test "enum - invalid" do
	schema = %Schema{type: :string, enum: ["one"]}
	assert {:error, [error]} = cast(value: "two", schema: schema)

	assert %Error{} = error
	assert error.reason == :invalid_enum
	end

	test "enum - valid" do
	schema = %Schema{type: :string, enum: ["one"]}
	assert {:ok, "one"} = cast(value: "one", schema: schema)
	end
	end

	describe "ok/1" do
	test "basics" do
	assert {:ok, 1} = Cast.ok(%Cast{value: 1})
	end
	end

	describe "success/2" do
	test "nils out property" do
	schema = %Schema{minimum: 1}
	ctx = %Cast{schema: schema}
	expected = {:cast, %Cast{schema: %Schema{minimum: nil}}}

	assert expected == Cast.success(ctx, :minimum)
	end

	test "nils out properties" do
	schema = %Schema{minimum: 1, exclusiveMinimum: true}
	ctx = %Cast{schema: schema}
	expected = {:cast, %Cast{schema: %Schema{minimum: nil, exclusiveMinimum: nil}}}

	assert expected == Cast.success(ctx, [:minimum, :exclusiveMinimum])
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Nov 30, 2:48 AM (1 d, 15 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 41347
Default Alt Text: (24 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions