Handle "true" or "false" for schema type defined as boolean

[KevinOl]

Hi,

I've got a schema definition as follow,

OpenApiSpex.schema(%{
...
   should_be_a_boolean: %Schema{
           type: :boolean,
           description: "some description"
         },
...
})

In my test, when 'should_be_a_boolean' is "some_string" it fails because it should be a boolean. This is fine.

However, when 'should_be_a_boolean' is "true" or "false" then I would like it to also fails but it does not.

Is there a way to prevent this?

[moxley]

@KevinOl: Do you mean you want it to fail if the input value is a string representation of a boolean, like "true" or "false"?

[moxley]

OpenAPI is designed to work with data from different data sources-- not just JSON. JSON has a built-in boolean type, but OpenAPI also addresses data encoded as XML, URI-encoded query params, and HTTP header values. None of those encodings has a built-in boolean type. Therefore, OpenApiSpex isn't picky about whether an input value for a boolean schema is a "true" string or a true boolean value.

[mbuhot]

Given JSON is such a commonly used format, maybe we could support a strict mode for request bodies?

@KevinOl if you feel like contributing support, you could pass a flag from cast_request_body/4 into Cast.cast

The strict flag would be stored in the Cast.t struct, and passed in to the primitive cast which would then handle the case when the input wasn't already a boolean/integer/number by returning an error.

I'm just not sure how we indicate that an application/json or application/vnd.api+json or other custom defined content-type should use strict mode for body conversion.

[KevinOl]

@KevinOl: Do you mean you want it to fail if the input value is a string representation of a boolean, like "true" or "false"?

yep, maybe I will check how to do a custom validation.

[KevinOl]

Given JSON is such a commonly used format, maybe we could support a strict mode for request bodies?

@KevinOl if you feel like contributing support, you could pass a flag from cast_request_body/4 into Cast.cast

The strict flag would be stored in the Cast.t struct, and passed in to the primitive cast which would then handle the case when the input wasn't already a boolean/integer/number by returning an error.

I'm just not sure how we indicate that an application/json or application/vnd.api+json or other custom defined content-type should use strict mode for body conversion.

My case is probably so specific that it would be overkill to do that (?)
I will check about custom validation maybe I can do something otherwise I will leave as it is ("true" or "false").

Thanks both for your feedback! Appreciate.

[norpan]

I ran into this as well. I used the assert_schema to test responses, but it missed one place when an integer was being sent as a string (even though the schema specified that it should be integer).

I think it's mostly fine to cast input parameters, but the assertions should not accept strings when the schema says integer.

[moxley]

@norpan In OpenApiSpex 3.7.0, custom validators were introduced. If you want to enforce strict integers, a custom validator can be created to do that:

    test "cast schema error with custom validator" do
      defmodule StrictInt do
        require OpenApiSpex

        alias OpenApiSpex.Cast

        OpenApiSpex.schema(%{
          description: "Strictly an integer",
          type: :integer,
          "x-validate": __MODULE__
        })

        def cast(context = %Cast{value: value}) when is_integer(value),
          do: Cast.ok(context)

        def cast(context),
          do: Cast.error(context, {:invalid_type, :strict_integer})
      end

      schema = %Schema{
        type: :object,
        properties: %{age: StrictInt.schema()}
      }

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

Or if you want to enforce strict booleans:

    test "cast schema error with custom validator to enforce strict booleans" do
      defmodule StrictBoolean do
        require OpenApiSpex

        alias OpenApiSpex.Cast

        OpenApiSpex.schema(%{
          description: "Strictly a boolean",
          type: :boolean,
          "x-validate": __MODULE__
        })

        def cast(context = %Cast{value: value}) when is_boolean(value),
          do: Cast.ok(context)

        def cast(context),
          do: Cast.error(context, {:invalid_type, :strict_boolean})
      end

      schema = %Schema{
        type: :object,
        properties: %{active: StrictBoolean.schema()}
      }

      assert {:error, errors} = cast(value: %{"active" => "true"}, schema: schema)
      assert [error] = errors
      assert %Error{} = error
      assert error.reason == :invalid_type
      assert error.path == [:active]
      assert Error.message_with_path(error) == "#/active: Invalid strict_boolean. Got: string"
    end