No OneTemporary
Actions

Size

26 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/open_api_spex/test/test_assertions.ex b/lib/open_api_spex/test/test_assertions.ex
	index cb728cb..ae591bd 100644
	--- a/lib/open_api_spex/test/test_assertions.ex
	+++ b/lib/open_api_spex/test/test_assertions.ex
	@@ -1,42 +1,42 @@
	defmodule OpenApiSpex.TestAssertions do
	@moduledoc """
	Defines helpers for testing API responses and examples against API spec schemas.
	"""
	import ExUnit.Assertions
	alias OpenApiSpex.OpenApi
	alias OpenApiSpex.Cast.Error

	@dialyzer {:no_match, assert_schema: 3}

	@doc """
	Asserts that `value` conforms to the schema with title `schema_title` in `api_spec`.
	"""
	- @spec assert_schema(map, String.t(), OpenApi.t()) :: map \| no_return
	- def assert_schema(value = %{}, schema_title, api_spec = %OpenApi{}) do
	+ @spec assert_schema(term, String.t(), OpenApi.t()) :: term \| no_return
	+ def assert_schema(value, schema_title, api_spec = %OpenApi{}) do
	schemas = api_spec.components.schemas
	schema = schemas[schema_title]

	if !schema do
	flunk("Schema: #{schema_title} not found in #{inspect(Map.keys(schemas))}")
	end

	case OpenApiSpex.cast_value(value, schema, api_spec) do
	{:ok, data} ->
	data

	{:error, errors} ->
	errors =
	Enum.map(errors, fn error ->
	message = Error.message(error)
	path = Error.path_to_string(error)
	"#{message} at #{path}"
	end)

	flunk(
	"Value does not conform to schema #{schema_title}: #{Enum.join(errors, "\n")}\n#{
	inspect(value)
	}"
	)
	end
	end
	end
	diff --git a/test/schema_test.exs b/test/schema_test.exs
	index 65182b3..9d63bee 100644
	--- a/test/schema_test.exs
	+++ b/test/schema_test.exs
	@@ -1,477 +1,487 @@
	defmodule OpenApiSpex.SchemaTest do
	use ExUnit.Case
	alias OpenApiSpex.Schema
	alias OpenApiSpexTest.{ApiSpec, Schemas}
	import OpenApiSpex.TestAssertions

	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
	+
	+ test "Array Schema example matches schema" do
	+ api_spec = ApiSpec.spec()
	+ assert_schema(Schemas.Array.schema().example, "Array", api_spec)
	+ end
	+
	+ test "Primitive Schema example matches schema" do
	+ api_spec = ApiSpec.spec()
	+ assert_schema(Schemas.Primitive.schema().example, "Primitive", api_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" => "Dog",
	"bark" => "bowow"
	}

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

	test "Cast Cat 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}
	]
	}

	# The following object is valid against both schemas, so it will result in an error
	# – it should be valid against only one of the schemas, since we are using the oneOf keyword.
	# @see https://swagger.io/docs/specification/data-models/oneof-anyof-allof-not/#oneof
	result = Schema.cast(schema, "123", %{})

	assert {:error, _} = 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 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 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
	diff --git a/test/support/api_spec.ex b/test/support/api_spec.ex
	index d2b36af..ec9ef9c 100644
	--- a/test/support/api_spec.ex
	+++ b/test/support/api_spec.ex
	@@ -1,44 +1,46 @@
	defmodule OpenApiSpexTest.ApiSpec do
	alias OpenApiSpex.{OpenApi, Contact, License, Paths, Server, Info, Components}
	alias OpenApiSpexTest.{Router, Schemas}
	@behaviour OpenApi

	@impl OpenApi
	def spec() do
	%OpenApi{
	servers: [
	%Server{url: "http://example.com"}
	],
	info: %Info{
	title: "A",
	version: "3.0",
	contact: %Contact{
	name: "joe",
	email: "Joe@gmail.com",
	url: "https://help.joe.com"
	},
	license: %License{
	name: "MIT",
	url: "http://mit.edu/license"
	}
	},
	components: %Components{
	schemas:
	for schemaMod <- [
	Schemas.Pet,
	Schemas.PetType,
	Schemas.Cat,
	Schemas.Dog,
	Schemas.CatOrDog,
	- Schemas.Size
	+ Schemas.Size,
	+ Schemas.Array,
	+ Schemas.Primitive
	],
	into: %{} do
	schema = schemaMod.schema()
	{schema.title, schema}
	end
	},
	paths: Paths.from_router(Router)
	}
	\|> OpenApiSpex.resolve_schema_modules()
	end
	end
	diff --git a/test/support/schemas.ex b/test/support/schemas.ex
	index f571e0f..ed2003a 100644
	--- a/test/support/schemas.ex
	+++ b/test/support/schemas.ex
	@@ -1,388 +1,409 @@
	defmodule OpenApiSpexTest.Schemas do
	require OpenApiSpex
	alias OpenApiSpex.Reference
	alias OpenApiSpex.Schema

	defmodule Helper do
	def prepare_struct([%Reference{"$ref": "#/components/schemas/" <> name} \| tail]) do
	schema =
	apply(String.to_existing_atom("Elixir.OpenApiSpexTest.Schemas." <> name), :schema, [])

	prepare_struct([schema \| tail])
	end

	def prepare_struct([%Schema{properties: props} \| tail]) when is_map(props) do
	keys = Map.keys(props)
	keys ++ prepare_struct(tail)
	end

	def prepare_struct([%Schema{allOf: allOf} \| tail]) when is_list(allOf) do
	prepare_struct(allOf ++ tail)
	end

	def prepare_struct([module_name \| tail]) when is_atom(module_name) do
	prepare_struct([module_name.schema() \| tail])
	end

	def prepare_struct([]) do
	[]
	end
	end

	defmodule Size do
	OpenApiSpex.schema(%{
	title: "Size",
	description: "A size of a pet",
	type: :object,
	properties: %{
	unit: %Schema{type: :string, description: "SI unit name", default: "cm"},
	value: %Schema{type: :integer, description: "Size in given unit", default: 100}
	},
	required: [:unit, :value]
	})
	end

	defmodule User do
	OpenApiSpex.schema(%{
	title: "User",
	description: "A user of the app",
	type: :object,
	properties: %{
	id: %Schema{type: :integer, description: "User ID"},
	name: %Schema{type: :string, description: "User name", pattern: ~r/[a-zA-Z][a-zA-Z0-9_]+/},
	email: %Schema{type: :string, description: "Email address", format: :email},
	inserted_at: %Schema{
	type: :string,
	description: "Creation timestamp",
	format: :"date-time"
	},
	updated_at: %Schema{type: :string, description: "Update timestamp", format: :"date-time"}
	},
	required: [:name, :email],
	additionalProperties: false,
	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 ContactInfo do
	OpenApiSpex.schema(%{
	title: "ContactInfo",
	description: "A users contact information",
	type: :object,
	properties: %{
	phone_number: %Schema{type: :string, description: "Phone number"},
	postal_address: %Schema{type: :string, description: "Postal address"}
	},
	required: [:phone_number],
	additionalProperties: false,
	example: %{
	"phone_number" => "555-123-456",
	"postal_address" => "123 Evergreen Tce"
	}
	})
	end

	defmodule CreditCardPaymentDetails do
	OpenApiSpex.schema(%{
	title: "CreditCardPaymentDetails",
	description: "Payment details when using credit-card method",
	type: :object,
	properties: %{
	credit_card_number: %Schema{type: :string, description: "Credit card number"},
	name_on_card: %Schema{type: :string, description: "Name as appears on card"},
	expiry: %Schema{type: :string, description: "4 digit expiry MMYY"}
	},
	required: [:credit_card_number, :name_on_card, :expiry],
	example: %{
	"credit_card_number" => "1234-5678-1234-6789",
	"name_on_card" => "Joe User",
	"expiry" => "1234"
	}
	})
	end

	defmodule DirectDebitPaymentDetails do
	OpenApiSpex.schema(%{
	title: "DirectDebitPaymentDetails",
	description: "Payment details when using direct-debit method",
	type: :object,
	properties: %{
	account_number: %Schema{type: :string, description: "Bank account number"},
	account_name: %Schema{type: :string, description: "Name of account"},
	bsb: %Schema{type: :string, description: "Branch identifier"}
	},
	required: [:account_number, :account_name, :bsb],
	example: %{
	"account_number" => "12349876",
	"account_name" => "Joes Savings Account",
	"bsb" => "123-4567"
	}
	})
	end

	defmodule PaymentDetails do
	OpenApiSpex.schema(%{
	title: "PaymentDetails",
	description: "Abstract Payment details type",
	type: :object,
	oneOf: [
	CreditCardPaymentDetails,
	DirectDebitPaymentDetails
	]
	})
	end

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

	defmodule UserResponse do
	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"
	}
	}
	})
	end

	defmodule UsersResponse do
	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

	defmodule EntityWithDict do
	OpenApiSpex.schema(%{
	title: "EntityWithDict",
	description: "Entity with a dictionary defined via additionalProperties",
	type: :object,
	properties: %{
	id: %Schema{type: :integer, description: "Entity ID"},
	stringDict: %Schema{
	type: :object,
	description: "String valued dict",
	additionalProperties: %Schema{type: :string}
	},
	anyTypeDict: %Schema{
	type: :object,
	description: "Untyped valued dict",
	additionalProperties: true
	}
	},
	example: %{
	"id" => 123,
	"stringDict" => %{"key1" => "value1", "key2" => "value2"},
	"anyTypeDict" => %{"key1" => 42, "key2" => %{"foo" => "bar"}}
	}
	})
	end

	defmodule PetType do
	require OpenApiSpex

	OpenApiSpex.schema(%{
	title: "PetType",
	type: :object,
	required: [:pet_type],
	properties: %{
	pet_type: %Schema{
	type: :string
	}
	}
	})
	end

	defmodule Cat do
	alias OpenApiSpex.Schema

	@behaviour OpenApiSpex.Schema
	@derive [Jason.Encoder]
	@schema %Schema{
	title: "Cat",
	type: :object,
	allOf: [
	PetType,
	%Schema{
	type: :object,
	properties: %{
	meow: %Schema{type: :string}
	},
	required: [:meow]
	}
	],
	"x-struct": __MODULE__
	}

	def schema, do: @schema
	defstruct OpenApiSpexTest.Schemas.Helper.prepare_struct(@schema.allOf)
	end

	defmodule Dog do
	alias OpenApiSpex.Schema

	@behaviour OpenApiSpex.Schema
	@derive [Jason.Encoder]
	@schema %Schema{
	title: "Dog",
	type: :object,
	allOf: [
	PetType,
	%Schema{
	type: :object,
	properties: %{
	bark: %Schema{type: :string}
	},
	required: [:bark]
	}
	],
	"x-struct": __MODULE__
	}

	def schema, do: @schema
	defstruct OpenApiSpexTest.Schemas.Helper.prepare_struct(@schema.allOf)
	end

	defmodule CatOrDog do
	require OpenApiSpex

	OpenApiSpex.schema(%{
	title: "CatOrDog",
	oneOf: [Cat, Dog]
	})
	end

	+ defmodule Array do
	+ require OpenApiSpex
	+
	+ OpenApiSpex.schema(%{
	+ title: "Array",
	+ type: :array,
	+ items: Dog,
	+ example: [%{pet_type: "Dog", bark: "A lot"}]
	+ })
	+ end
	+
	+ defmodule Primitive do
	+ require OpenApiSpex
	+
	+ OpenApiSpex.schema(%{
	+ title: "Primitive",
	+ type: :integer,
	+ example: 1
	+ })
	+ end
	+
	defmodule PrimitiveArray do
	require OpenApiSpex

	OpenApiSpex.schema(%{
	title: "PrimitiveArray",
	type: :array,
	items: %Schema{type: "string"},
	example: ["Foo"]
	})
	end

	defmodule PetResponse do
	OpenApiSpex.schema(%{
	title: "PetResponse",
	description: "Response schema for single pet",
	type: :object,
	properties: %{
	data: OpenApiSpexTest.Schemas.CatOrDog
	},
	example: %{
	"data" => %{
	"pet_type" => "Dog",
	"bark" => "woof"
	}
	}
	})
	end

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

	OpenApiSpex.schema(%{
	title: "Pet",
	type: :object,
	oneOf: [Cat, Dog],
	discriminator: %Discriminator{
	propertyName: "pet_type"
	}
	})
	end

	defmodule PetsResponse do
	OpenApiSpex.schema(%{
	title: "PetsResponse",
	description: "Response schema for multiple pets",
	type: :object,
	properties: %{
	data: %Schema{
	description: "The pets details",
	type: :array,
	items: OpenApiSpexTest.Schemas.CatOrDog
	}
	},
	example: %{
	"data" => [
	%{
	"pet_type" => "Dog",
	"bark" => "woof"
	},
	%{
	"pet_type" => "Cat",
	"meow" => "meow"
	}
	]
	}
	})
	end

	defmodule PetRequest do
	OpenApiSpex.schema(%{
	title: "PetRequest",
	description: "POST body for creating a pet",
	type: :object,
	properties: %{
	pet: CatOrDog
	},
	example: %{
	"pet" => %{
	"pet_type" => "Dog",
	"bark" => "woof"
	}
	}
	})
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Wed, Nov 27, 8:27 AM (1 d, 18 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 40585
Default Alt Text: (26 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions