No OneTemporary
Actions

Size

18 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/open_api_spex/cast/error.ex b/lib/open_api_spex/cast/error.ex
	index 0604070..58c5980 100644
	--- a/lib/open_api_spex/cast/error.ex
	+++ b/lib/open_api_spex/cast/error.ex
	@@ -1,147 +1,154 @@
	defmodule OpenApiSpex.Cast.Error do
	alias OpenApiSpex.TermType

	defstruct reason: nil,
	value: nil,
	format: nil,
	type: nil,
	name: nil,
	path: [],
	length: 0,
	meta: %{}

	def new(ctx, {:invalid_schema_type}) do
	%__MODULE__{reason: :invalid_schema_type, type: ctx.schema.type}
	\|> add_context_fields(ctx)
	end

	def new(ctx, {:null_value}) do
	type = ctx.schema && ctx.schema.type

	%__MODULE__{reason: :null_value, type: type}
	\|> add_context_fields(ctx)
	end

	def new(ctx, {:min_length, length}) do
	%__MODULE__{reason: :min_length, length: length}
	\|> add_context_fields(ctx)
	end

	def new(ctx, {:invalid_type, type}) do
	%__MODULE__{reason: :invalid_type, type: type}
	\|> add_context_fields(ctx)
	end

	def new(ctx, {:invalid_format, format}) do
	%__MODULE__{reason: :invalid_format, format: format}
	\|> add_context_fields(ctx)
	end

	def new(ctx, {:invalid_enum}) do
	%__MODULE__{reason: :invalid_enum}
	\|> add_context_fields(ctx)
	end

	def new(ctx, {:unexpected_field, name}) do
	%__MODULE__{reason: :unexpected_field, name: name}
	\|> add_context_fields(ctx)
	end

	def new(ctx, {:missing_field, name}) do
	%__MODULE__{reason: :missing_field, name: name}
	\|> add_context_fields(ctx)
	end

	def new(ctx, {:max_properties, max_properties, property_count}) do
	%__MODULE__{
	reason: :max_properties,
	meta: %{max_properties: max_properties, property_count: property_count}
	}
	\|> add_context_fields(ctx)
	end

	def message(%{reason: :invalid_schema_type, type: type}) do
	"Invalid schema.type. Got: #{inspect(type)}"
	end

	def message(%{reason: :null_value} = error) do
	case error.type do
	nil -> "null value"
	type -> "null value where #{type} expected"
	end
	end

	def message(%{reason: :min_length, length: length}) do
	"String length is smaller than minLength: #{length}"
	end

	def message(%{reason: :invalid_type, type: type, value: value}) do
	"Invalid #{type}. Got: #{TermType.type(value)}"
	end

	def message(%{reason: :invalid_format, format: format}) do
	"Invalid format. Expected #{inspect(format)}"
	end

	def message(%{reason: :invalid_enum}) do
	"Invalid value for enum"
	end

	def message(%{reason: :polymorphic_failed, type: polymorphic_type}) do
	"Failed to cast to any schema in #{polymorphic_type}"
	end

	def message(%{reason: :unexpected_field, name: name}) do
	"Unexpected field: #{safe_string(name)}"
	end

	def message(%{reason: :no_value_required_for_discriminator, name: field}) do
	"No value for required disciminator property: #{field}"
	end

	def message(%{reason: :unknown_schema, name: name}) do
	"Unknown schema: #{name}"
	end

	def message(%{reason: :missing_field, name: name}) do
	"Missing field: #{name}"
	end

	def message(%{reason: :max_properties, meta: meta}) do
	"Object property count #{meta.property_count} is greater than maxProperties: #{
	meta.max_properties
	}"
	end

	def message_with_path(error) do
	prepend_path(error, message(error))
	end

	def path_to_string(%{path: path} = _error) do
	- "/" <> (path \|> Enum.map(&to_string/1) \|> Path.join())
	+ path =
	+ if path == [] do
	+ ""
	+ else
	+ path \|> Enum.map(&to_string/1) \|> Path.join()
	+ end
	+
	+ "/" <> path
	end

	defp add_context_fields(error, ctx) do
	%{error \| path: Enum.reverse(ctx.path), value: ctx.value}
	end

	defp prepend_path(error, message) do
	path =
	case error.path do
	[] -> "#"
	_ -> "#" <> path_to_string(error)
	end

	path <> ": " <> message
	end

	defp safe_string(string) do
	to_string(string) \|> String.slice(0..39)
	end
	end

	defimpl String.Chars, for: OpenApiSpex.Cast.Error do
	def to_string(error) do
	OpenApiSpex.Cast.Error.message(error)
	end
	end
	diff --git a/lib/open_api_spex/cast/object.ex b/lib/open_api_spex/cast/object.ex
	index 0bbafdf..820ef16 100644
	--- a/lib/open_api_spex/cast/object.ex
	+++ b/lib/open_api_spex/cast/object.ex
	@@ -1,108 +1,109 @@
	defmodule OpenApiSpex.Cast.Object do
	@moduledoc false
	alias OpenApiSpex.Cast
	alias OpenApiSpex.Cast.Error

	def cast(%{value: value} = ctx) when not is_map(value) do
	Cast.error(ctx, {:invalid_type, :object})
	end

	def cast(%{value: value, schema: %{properties: nil}}) do
	{:ok, value}
	end

	def cast(%{value: value, schema: schema} = ctx) do
	schema_properties = schema.properties \|\| %{}

	with :ok <- check_unrecognized_properties(ctx, schema_properties),
	value = cast_atom_keys(value, schema_properties),
	ctx = %{ctx \| value: value},
	:ok <- check_required_fields(ctx, schema),
	:ok <- check_max_properties(ctx),
	{:ok, value} <- cast_properties(%{ctx \| schema: schema_properties}) do
	ctx = to_struct(%{ctx \| value: value})
	{:ok, ctx}
	end
	end

	defp check_unrecognized_properties(%{value: value} = ctx, expected_keys) do
	input_keys = value \|> Map.keys() \|> Enum.map(&to_string/1)
	schema_keys = expected_keys \|> Map.keys() \|> Enum.map(&to_string/1)
	extra_keys = input_keys -- schema_keys

	if extra_keys == [] do
	:ok
	else
	[name \| _] = extra_keys
	+ ctx = %{ctx \| path: [name \| ctx.path]}
	Cast.error(ctx, {:unexpected_field, name})
	end
	end

	defp check_required_fields(%{value: input_map} = ctx, schema) do
	required = schema.required \|\| []
	input_keys = Map.keys(input_map)
	missing_keys = required -- input_keys

	if missing_keys == [] do
	:ok
	else
	errors =
	Enum.map(missing_keys, fn key ->
	ctx = %{ctx \| path: [key \| ctx.path]}
	Error.new(ctx, {:missing_field, key})
	end)

	{:error, ctx.errors ++ errors}
	end
	end

	defp check_max_properties(%{schema: %{maxProperties: max_properties}} = ctx)
	when is_integer(max_properties) do
	count = ctx.value \|> Map.keys() \|> length()

	if count > max_properties do
	Cast.error(ctx, {:max_properties, max_properties, count})
	else
	:ok
	end
	end

	defp check_max_properties(_ctx), do: :ok

	defp cast_atom_keys(input_map, properties) do
	Enum.reduce(properties, %{}, fn {key, _}, output ->
	string_key = to_string(key)

	case input_map do
	%{^key => value} -> Map.put(output, key, value)
	%{^string_key => value} -> Map.put(output, key, value)
	_ -> output
	end
	end)
	end

	defp cast_properties(%{value: object, schema: schema_properties} = ctx) do
	Enum.reduce(object, {:ok, %{}}, fn
	{key, value}, {:ok, output} ->
	cast_property(%{ctx \| key: key, value: value, schema: schema_properties}, output)

	_, error ->
	error
	end)
	end

	defp cast_property(%{key: key, schema: schema_properties} = ctx, output) do
	prop_schema = Map.get(schema_properties, key)
	path = [key \| ctx.path]

	with {:ok, value} <- Cast.cast(%{ctx \| path: path, schema: prop_schema}) do
	{:ok, Map.put(output, key, value)}
	end
	end

	defp to_struct(%{value: value = %_{}}), do: value
	defp to_struct(%{value: value, schema: %{"x-struct": nil}}), do: value

	defp to_struct(%{value: value, schema: %{"x-struct": module}}),
	do: struct(module, value)
	end
	diff --git a/lib/open_api_spex/cast_parameters.ex b/lib/open_api_spex/cast_parameters.ex
	index c93c356..b6587dd 100644
	--- a/lib/open_api_spex/cast_parameters.ex
	+++ b/lib/open_api_spex/cast_parameters.ex
	@@ -1,35 +1,37 @@
	defmodule OpenApiSpex.CastParameters do
	@moduledoc false
	alias OpenApiSpex.{Cast, Operation, Parameter, Schema}
	alias OpenApiSpex.Cast.{Error, Object}
	alias Plug.Conn

	@spec cast(Plug.Conn.t(), Operation.t(), Schema.schemas()) ::
	{:error, [Error.t()]} \| {:ok, Conn.t()}
	def cast(conn, operation, schemas) 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`

	properties =
	operation.parameters
	\|> Enum.map(fn parameter -> {parameter.name, Parameter.schema(parameter)} end)
	\|> Map.new()

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

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

	- ctx = %Cast{value: conn.params, schema: object_schema, schemas: schemas}
	+ params = Map.merge(conn.path_params, conn.query_params)
	+
	+ ctx = %Cast{value: params, schema: object_schema, schemas: schemas}

	with {:ok, params} <- Object.cast(ctx) do
	{:ok, %{conn \| params: params}}
	end
	end
	end
	diff --git a/test/cast/error_test.exs b/test/cast/error_test.exs
	new file mode 100644
	index 0000000..dd49262
	--- /dev/null
	+++ b/test/cast/error_test.exs
	@@ -0,0 +1,11 @@
	+defmodule OpenApiSpex.Cast.ErrorTest do
	+ use ExUnit.Case
	+ alias OpenApiSpex.Cast.Error
	+
	+ describe "path_to_string/1" do
	+ test "with empty path" do
	+ error = %Error{path: []}
	+ Error.path_to_string(error)
	+ end
	+ end
	+end
	diff --git a/test/cast/object_test.exs b/test/cast/object_test.exs
	index 7f89298..d6d01cf 100644
	--- a/test/cast/object_test.exs
	+++ b/test/cast/object_test.exs
	@@ -1,125 +1,137 @@
	defmodule OpenApiSpex.ObjectTest do
	use ExUnit.Case
	alias OpenApiSpex.{Cast, Schema}
	alias OpenApiSpex.Cast.{Object, Error}

	defp cast(ctx), do: Object.cast(struct(Cast, ctx))

	describe "cast/3" do
	test "when input is not an object" do
	schema = %Schema{type: :object}
	assert {:error, [error]} = cast(value: ["hello"], schema: schema)
	assert %Error{} = error
	assert error.reason == :invalid_type
	assert error.value == ["hello"]
	end

	test "input map can have atom keys" do
	schema = %Schema{type: :object}
	assert {:ok, map} = cast(value: %{one: "one"}, schema: schema)
	assert map == %{one: "one"}
	end

	test "converting string keys to atom keys when properties are defined" do
	schema = %Schema{
	type: :object,
	properties: %{
	one: nil
	}
	}

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

	test "properties:nil, given unknown input property" do
	schema = %Schema{type: :object}
	assert cast(value: %{}, schema: schema) == {:ok, %{}}

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

	test "with empty schema properties, given unknown input property" do
	schema = %Schema{type: :object, properties: %{}}
	assert cast(value: %{}, schema: schema) == {:ok, %{}}
	assert {:error, [error]} = cast(value: %{"unknown" => "hello"}, schema: schema)
	assert %Error{} = error
	end

	test "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 "unexpected field" do
	+ schema = %Schema{
	+ type: :object,
	+ properties: %{}
	+ }
	+
	+ assert {:error, [error]} = cast(value: %{foo: "foo"}, schema: schema)
	+ assert %Error{} = error
	+ assert error.reason == :unexpected_field
	+ assert error.path == ["foo"]
	+ end
	+
	test "required fields" do
	schema = %Schema{
	type: :object,
	properties: %{age: nil, name: nil},
	required: [:age, :name]
	}

	assert {:error, [error, error2]} = cast(value: %{}, schema: schema)
	assert %Error{} = error
	assert error.reason == :missing_field
	assert error.name == :age
	assert error.path == [:age]

	assert error2.reason == :missing_field
	assert error2.name == :name
	assert error2.path == [:name]
	end

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

	assert cast(value: %{}, schema: schema) == {:ok, %{}}
	assert {:error, [error]} = cast(value: %{"age" => "hello"}, schema: schema)
	assert %Error{} = error
	assert error.reason == :invalid_type
	assert error.path == [:age]
	end

	defmodule User do
	defstruct [:name]
	end

	test "optionally casts to struct" do
	schema = %Schema{
	type: :object,
	"x-struct": User,
	properties: %{
	name: %Schema{type: :string}
	}
	}

	assert {:ok, user} = cast(value: %{"name" => "Name"}, schema: schema)
	assert user == %User{name: "Name"}
	end

	test "validates maxProperties" do
	schema = %Schema{
	type: :object,
	properties: %{
	one: nil,
	two: nil
	},
	maxProperties: 1
	}

	assert {:error, [error]} = cast(value: %{one: "one", two: "two"}, schema: schema)
	assert %Error{} = error
	assert error.reason == :max_properties

	assert {:ok, _} = cast(value: %{one: "one"}, schema: schema)
	end
	end
	end
	diff --git a/test/operation2_test.exs b/test/operation2_test.exs
	index d56dd40..b8c8ace 100644
	--- a/test/operation2_test.exs
	+++ b/test/operation2_test.exs
	@@ -1,172 +1,187 @@
	defmodule OpenApiSpex.Operation2Test do
	use ExUnit.Case
	alias OpenApiSpex.{Operation, Operation2, Schema}
	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 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")
	],
	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
	def spec do
	paths = %{
	"/users" => %{
	"post" => OperationFixtures.create_user()
	}
	}

	%OpenApiSpex.OpenApi{
	info: nil,
	paths: paths,
	components: %{
	schemas: SchemaFixtures.schemas()
	}
	}
	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()
	)

	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()
	)

	assert [error] = errors
	assert %Error{} = error
	assert error.reason == :invalid_type
	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

	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()
	)
	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: Sat, Nov 30, 2:35 PM (1 d, 16 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 41451
Default Alt Text: (18 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions