schemacop 2.4.7 → 3.0.0.rc4

data/test/unit/schemacop/v3/object_node_test.rb

@@ -0,0 +1,170 @@
+require 'test_helper'
+
+module Schemacop
+  module V3
+    class ObjectNodeTest < V3Test
+      def test_basic
+        schema :object
+
+        assert_validation nil
+        assert_validation true
+        assert_validation false
+        assert_validation Object.new
+        assert_validation 'foo'
+
+        assert_json({})
+      end
+
+      def test_required_with_no_types
+        schema :object, required: true
+
+        assert_validation nil do
+          error '/', 'Value must be given.'
+        end
+      end
+
+      def test_with_classes
+        schema :object, classes: [String, Date]
+        assert_validation 'foo'
+        assert_validation Date.today
+        assert_validation({}.with_indifferent_access) do
+          error '/', 'Invalid type, expected "Date" or "String".'
+        end
+        assert_validation DateTime.now do
+          error '/', 'Invalid type, expected "Date" or "String".'
+        end
+      end
+
+      def test_non_strict
+        schema :object, classes: [String, Date, Hash], strict: false
+        assert_validation 'foo'
+        assert_validation 'foo'.html_safe
+        assert_validation Date.today
+        assert_validation nil
+        assert_validation DateTime.now
+        assert_validation({}.with_indifferent_access)
+        assert_validation Time.now do
+          error '/', 'Invalid type, expected "Date" or "Hash" or "String".'
+        end
+      end
+
+      def test_required
+        schema :object, required: true
+
+        assert_validation true
+        assert_validation false
+        assert_validation nil do
+          error '/', 'Value must be given.'
+        end
+      end
+
+      def test_hash
+        schema { obj! :myobj, String }
+        assert_json(
+          type:                 :object,
+          properties:           {
+            myobj: {}
+          },
+          required:             %i[myobj],
+          additionalProperties: false
+        )
+        assert_validation myobj: ''
+        assert_validation myobj: '42'
+        assert_validation myobj: Date.today do
+          error '/myobj', 'Invalid type, expected "String".'
+        end
+        assert_validation({}) do
+          error '/myobj', 'Value must be given.'
+        end
+      end
+
+      def test_enum_schema
+        schema :object, enum: [true, 'foo', :baz, [], { qux: '123' }]
+
+        # Can't represent a Ruby Object as a JSON value
+        assert_json({})
+
+        # As we didn't provide any classes, any object (i.e. everything) will
+        # be validated. However, only those elements we put into the enum list
+        # will be allowed
+        assert_validation(nil)
+        assert_validation(true)
+        assert_validation('foo')
+        assert_validation(:baz)
+        assert_validation([])
+        assert_validation({ qux: '123' })
+
+        # These will fail, as we didn't put them into the enum list
+        assert_validation(1) do
+          error '/', 'Value not included in enum [true, "foo", :baz, [], {:qux=>"123"}].'
+        end
+        assert_validation(:bar) do
+          error '/', 'Value not included in enum [true, "foo", :baz, [], {:qux=>"123"}].'
+        end
+        assert_validation({ qux: 42 }) do
+          error '/', 'Value not included in enum [true, "foo", :baz, [], {:qux=>"123"}].'
+        end
+      end
+
+      def test_enum_schema_with_classes
+        schema :object, classes: [String, Symbol, TrueClass], enum: [true, 'foo', :baz, [], { qux: '123' }, false]
+
+        # Can't represent a Ruby Object as a JSON value
+        assert_json({})
+
+        # Values need to be one of the classed we defined above, as well as in the
+        # enum list for the validation to pass
+        assert_validation(nil)
+        assert_validation(true)
+        assert_validation('foo')
+        assert_validation(:baz)
+
+        # These will fail, as they aren't of one of the classed we defined above
+        assert_validation([]) do
+          error '/', 'Invalid type, expected "String" or "Symbol" or "TrueClass".'
+        end
+        assert_validation({ qux: '123' }) do
+          error '/', 'Invalid type, expected "String" or "Symbol" or "TrueClass".'
+        end
+        assert_validation(false) do
+          error '/', 'Invalid type, expected "String" or "Symbol" or "TrueClass".'
+        end
+      end
+
+      def test_with_generic_keywords
+        schema :object, enum:        [1, 'foo'],
+                        title:       'Object schema',
+                        description: 'Object schema holding generic keywords',
+                        examples:    [
+                          'foo'
+                        ]
+
+        assert_json({})
+      end
+
+      def test_validate_self
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Option "strict" must be a "boolean".' do
+          schema :object, strict: 'false'
+        end
+
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Option "strict" must be a "boolean".' do
+          schema :object, strict: 123
+        end
+
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Option "strict" must be a "boolean".' do
+          schema :object, strict: [1, 2, 3]
+        end
+
+        # rubocop:disable Lint/BooleanSymbol
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Option "strict" must be a "boolean".' do
+          schema :object, strict: :false
+        end
+        # rubocop:enable Lint/BooleanSymbol
+      end
+    end
+  end
+end

data/test/unit/schemacop/v3/one_of_node_test.rb

@@ -0,0 +1,187 @@
+require 'test_helper'
+
+module Schemacop
+  module V3
+    class OneOfNodeTest < V3Test
+      def test_optional
+        schema :one_of do
+          num multiple_of: 2
+          num multiple_of: 3
+          str
+        end
+
+        assert_validation(nil)
+        assert_validation(4)
+        assert_validation(9)
+        assert_validation('foo')
+        assert_validation(12) do
+          error '/', 'Matches 2 definitions but should match exactly 1.'
+        end
+        assert_validation(1) do
+          error '/', 'Matches 0 definitions but should match exactly 1.'
+        end
+        assert_validation(:foo) do
+          error '/', 'Matches 0 definitions but should match exactly 1.'
+        end
+      end
+
+      def test_required
+        schema :one_of, required: true do
+          num multiple_of: 2
+          num multiple_of: 3
+          str
+        end
+
+        assert_validation(8)
+        assert_validation(9)
+
+        assert_validation(nil) do
+          error '/', 'Value must be given.'
+        end
+      end
+
+      def test_nested
+        schema :one_of do
+          hsh do
+            one_of! :foo do
+              num multiple_of: 2
+              num multiple_of: 3
+            end
+          end
+          hsh do
+            num? :foo, multiple_of: 7
+          end
+        end
+
+        assert_validation(foo: 2)
+        assert_validation(foo: 9)
+        assert_validation(foo: 7)
+        assert_validation(foo: 14) do
+          error '/', 'Matches 2 definitions but should match exactly 1.'
+        end
+        assert_validation(foo: 12) do
+          error '/', 'Matches 0 definitions but should match exactly 1.'
+        end
+
+        assert_json(
+          oneOf: [
+            {
+              type:                 :object,
+              properties:           {
+                foo: {
+                  oneOf: [
+                    { type: :number, multipleOf: 2 },
+                    { type: :number, multipleOf: 3 }
+                  ]
+                }
+              },
+              required:             %i[foo],
+              additionalProperties: false
+            },
+            {
+              type:                 :object,
+              properties:           {
+                foo: { type: :number, multipleOf: 7 }
+              },
+              additionalProperties: false
+            }
+          ]
+        )
+      end
+
+      def test_casting
+        schema do
+          one_of! :created_at do
+            str format: :date
+            str format: :date_time
+          end
+        end
+
+        assert_validation(created_at: '2020-01-01')
+        assert_validation(created_at: '2020-01-01T17:38:20')
+
+        assert_cast(
+          { created_at: '2020-01-01' },
+          { created_at: Date.new(2020, 1, 1) }.with_indifferent_access
+        )
+        assert_cast(
+          { created_at: '2020-01-01T17:38:20' },
+          { created_at: DateTime.new(2020, 1, 1, 17, 38, 20) }.with_indifferent_access
+        )
+      end
+
+      def test_defaults
+        schema do
+          one_of! :foo do
+            hsh { str? :bar }
+            hsh { str? :baz, default: 'Baz' }
+          end
+        end
+
+        assert_validation(foo: { bar: 'Bar' })
+        assert_validation(foo: { baz: 'Baz' })
+
+        assert_validation(foo: { xyz: 'Baz' }) do
+          error '/foo', 'Matches 0 definitions but should match exactly 1.'
+        end
+
+        assert_cast(
+          { foo: { bar: nil } },
+          { foo: { bar: nil } }.with_indifferent_access
+        )
+
+        assert_cast(
+          { foo: { baz: nil } },
+          { foo: { baz: 'Baz' } }.with_indifferent_access
+        )
+
+        schema do
+          one_of! :foo do
+            hsh { str? :bar, format: :date }
+            hsh { str? :bar, default: 'Baz', format: :date_time }
+          end
+        end
+
+        assert_cast(
+          { foo: { bar: '1990-01-13' } },
+          { foo: { bar: Date.new(1990, 1, 13) } }.with_indifferent_access
+        )
+
+        assert_cast(
+          { foo: { bar: '1990-01-13T10:00:00Z' } },
+          { foo: { bar: DateTime.new(1990, 1, 13, 10, 0, 0) } }.with_indifferent_access
+        )
+      end
+
+      def test_with_generic_keywords
+        schema :one_of, title:       'oneOf schema',
+                        description: 'oneOf schema holding generic keywords',
+                        examples:    [
+                          'foo'
+                        ] do
+                          str
+                          int
+                        end
+
+        assert_json({
+                      oneOf:       [
+                        { type: :string },
+                        { type: :integer }
+                      ],
+                      title:       'oneOf schema',
+                      description: 'oneOf schema holding generic keywords',
+                      examples:    [
+                        'foo'
+                      ]
+                    })
+      end
+
+      def test_invalid_schema
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Node "one_of" makes only sense with at least 2 items.' do
+          schema :one_of
+        end
+      end
+    end
+  end
+end

data/test/unit/schemacop/v3/reference_node_test.rb

@@ -0,0 +1,367 @@
+require 'test_helper'
+
+module Schemacop
+  module V3
+    class ReferenceNodeTest < V3Test
+      def test_in_hash
+        context = Context.new
+        context.schema :MyString, :string
+        context.schema :MyInteger, :integer
+
+        Schemacop.with_context context do
+          schema do
+            ref? :foo, :MyString
+            ref? :int, :MyInteger
+            hsh? :bar do
+              ref? :foo, :MyString
+              hsh? :baz do
+                ref! :foo, :MyInteger
+              end
+            end
+          end
+
+          assert_validation({})
+          assert_validation(foo: 'String')
+          assert_validation(bar: { foo: 'String' })
+          assert_validation(bar: { foo: 'String', baz: { foo: 42 } })
+
+          assert_validation(foo: 42) do
+            error '/foo', 'Invalid type, expected "string".'
+          end
+          assert_validation(bar: { foo: 42 }) do
+            error '/bar/foo', 'Invalid type, expected "string".'
+          end
+          assert_validation(bar: { foo: 'String', baz: { foo: '42' } }) do
+            error '/bar/baz/foo', 'Invalid type, expected "integer".'
+          end
+
+          assert_json({
+                        properties:           {
+                          foo: {
+                            '$ref' => '#/definitions/MyString'
+                          },
+                          int: {
+                            '$ref' => '#/definitions/MyInteger'
+                          },
+                          bar: {
+                            properties:           {
+                              foo: {
+                                '$ref' => '#/definitions/MyString'
+                              },
+                              baz: {
+                                properties:           {
+                                  foo: {
+                                    '$ref' => '#/definitions/MyInteger'
+                                  }
+                                },
+                                additionalProperties: false,
+                                required:             ['foo'],
+                                type:                 :object
+                              }
+                            },
+                            additionalProperties: false,
+                            type:                 :object
+                          }
+                        },
+                        additionalProperties: false,
+                        type:                 :object
+                      })
+        end
+      end
+
+      def test_schema_not_found
+        assert_raises_with_message RuntimeError, 'Schema "MyInteger" not found.' do
+          schema do
+            ref? :int, :MyInteger
+          end
+          assert_validation(int: 5)
+        end
+      end
+
+      def test_multiple_schemas
+        schema do
+          scm :Address do
+            str! :street
+            str! :zip_code
+            str! :location
+            str! :country
+          end
+
+          scm :Person do
+            str! :first_name
+            str! :last_name
+            str! :birthday, format: :date
+          end
+
+          ref! :person_info, :Person
+          ref! :shipping_address, :Address
+          ref! :billing_address, :Address
+        end
+
+        assert_json({
+                      definitions:          {
+                        Address: {
+                          properties:           {
+                            street:   {
+                              type: :string
+                            },
+                            zip_code: {
+                              type: :string
+                            },
+                            location: {
+                              type: :string
+                            },
+                            country:  {
+                              type: :string
+                            }
+                          },
+                          additionalProperties: false,
+                          required:             %w[street zip_code location country],
+                          type:                 :object
+                        },
+                        Person:  {
+                          properties:           {
+                            first_name: {
+                              type: :string
+                            },
+                            last_name:  {
+                              type: :string
+                            },
+                            birthday:   {
+                              type:   :string,
+                              format: :date
+                            }
+                          },
+                          additionalProperties: false,
+                          required:             %w[first_name last_name birthday],
+                          type:                 :object
+                        }
+                      },
+                      properties:           {
+                        person_info:      {
+                          '$ref' => '#/definitions/Person'
+                        },
+                        shipping_address: {
+                          '$ref' => '#/definitions/Address'
+                        },
+                        billing_address:  {
+                          '$ref' => '#/definitions/Address'
+                        }
+                      },
+                      type:                 :object,
+                      additionalProperties: false,
+                      required:             %w[
+                        person_info
+                        shipping_address
+                        billing_address
+                      ]
+                    })
+
+        assert_validation(nil)
+        assert_validation({
+                            person_info:      {
+                              first_name: 'Joe',
+                              last_name:  'Doe',
+                              birthday:   '1990-01-01'
+                            },
+                            billing_address:  {
+                              street:   'Badenerstrasse 530',
+                              zip_code: '8048',
+                              location: 'Zürich',
+                              country:  'Switzerland'
+                            },
+                            shipping_address: {
+                              street:   'Badenerstrasse 530',
+                              zip_code: '8048',
+                              location: 'Zürich',
+                              country:  'Switzerland'
+                            }
+                          })
+
+        assert_validation({}) do
+          error '/person_info', 'Value must be given.'
+          error '/shipping_address', 'Value must be given.'
+          error '/billing_address', 'Value must be given.'
+        end
+      end
+
+      def test_nested_schemas
+        schema do
+          scm :User do
+            str! :first_name
+            str! :last_name
+            ary? :groups do
+              list :reference, path: :Group
+            end
+          end
+
+          scm :Group do
+            str! :name
+          end
+        end
+
+        assert_json({
+                      additionalProperties: false,
+                      definitions:          {
+                        User:  {
+                          properties:           {
+                            first_name: {
+                              type: :string
+                            },
+                            last_name:  {
+                              type: :string
+                            },
+                            groups:     {
+                              type:  :array,
+                              items: {
+                                '$ref' => '#/definitions/Group'
+                              }
+                            }
+                          },
+                          additionalProperties: false,
+                          required:             %w[first_name last_name],
+                          type:                 :object
+                        },
+                        Group: {
+                          properties:           {
+                            name: {
+                              type: :string
+                            }
+                          },
+                          additionalProperties: false,
+                          required:             ['name'],
+                          type:                 :object
+                        }
+                      },
+                      type:                 :object
+                    })
+      end
+
+      def test_in_hash_recursion
+        schema do
+          scm :Node do
+            str! :name
+            ary? :children, min_items: 1 do
+              list :reference, path: :Node
+            end
+          end
+
+          ref? :node, :Node
+        end
+
+        assert_equal(@schema.root.used_external_schemas, [])
+
+        assert_validation({})
+        assert_validation(node: { name: '1', children: [{ name: '1' }, { name: '2' }] })
+        assert_validation(
+          node: {
+            name:     '1',
+            children: [
+              { name: '1.1' },
+              {
+                name:     '1.2',
+                children: [
+                  { name: '1.2.1' }
+                ]
+              }
+            ]
+          }
+        )
+
+        assert_validation(
+          node: {
+            name:     '1',
+            children: [
+              { name: '1.1' },
+              {
+                name:     '1.2',
+                children: [
+                  { name: '1.2.1', children: [] }
+                ]
+              },
+              { name: '1.3', foo: :bar }
+            ]
+          }
+        ) do
+          error '/node/children/[1]/children/[0]/children', 'Array has 0 items but needs at least 1.'
+          error '/node/children/[2]', 'Obsolete property "foo".'
+        end
+      end
+
+      def test_external_schemas
+        context = Context.new
+
+        context.schema :Person do
+          str! :first_name
+          str! :last_name
+          ref? :info, :PersonInfo
+        end
+
+        context.schema :PersonInfo do
+          str! :born_at, format: :date
+        end
+
+        schema :reference, path: :Person
+
+        with_context context do
+          assert_validation(first_name: 'John', last_name: 'Doe')
+          assert_validation(first_name: 'John', last_name: 42) do
+            error '/last_name', 'Invalid type, expected "string".'
+          end
+        end
+
+        with_context context do
+          schema do
+            ref! :person, :Person
+          end
+
+          assert_equal(@schema.root.used_external_schemas, %i[Person PersonInfo])
+
+          assert_validation(person: { first_name: 'John', last_name: 'Doe' })
+          assert_validation(person: { first_name: 'John', last_name: 'Doe', info: { born_at: '1990-01-13' } })
+          assert_validation(person: { first_name_x: 'John', last_name: 'Doe' }) do
+            error '/person', 'Obsolete property "first_name_x".'
+            error '/person/first_name', 'Value must be given.'
+          end
+          assert_validation(person: { first_name: 'John', last_name: 'Doe', info: { born_at: 'never' } }) do
+            error '/person/info/born_at', 'String does not match format "date".'
+          end
+        end
+
+        with_context context do
+          schema do
+            scm :PersonNode do
+              ref! :person, :Person
+            end
+
+            ref! :personNode, :PersonNode
+          end
+
+          assert_equal(@schema.root.used_external_schemas, %i[Person PersonInfo])
+        end
+      end
+
+      def test_defaults
+        schema do
+          scm :Person do
+            str? :foo, default: 'bar'
+          end
+          ref? :person, :Person, default: {}
+        end
+
+        assert_cast({}, { person: { foo: 'bar' } }.with_indifferent_access)
+      end
+
+      def test_casting
+        schema do
+          scm :Person do
+            str! :born_at, format: :date
+          end
+          ref? :person, :Person, default: {}
+        end
+
+        assert_cast({ person: { born_at: '1990-01-13' } }, { person: { born_at: Date.new(1990, 1, 13) } }.with_indifferent_access)
+      end
+    end
+  end
+end