schemacop 2.4.7 → 3.0.0.rc0

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)
+        )
+        assert_cast(
+          { created_at: '2020-01-01T17:38:20' },
+          created_at: DateTime.new(2020, 1, 1, 17, 38, 20)
+        )
+      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 }
+        )
+
+        assert_cast(
+          { foo: { baz: nil } },
+          foo: { baz: 'Baz' }
+        )
+
+        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) }
+        )
+
+        assert_cast(
+          { foo: { bar: '1990-01-13T10:00:00Z' } },
+          foo: { bar: DateTime.new(1990, 1, 13, 10, 0, 0) }
+        )
+      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,351 @@
+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_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_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
+      # end
+
+      # def test_defaults
+      #   schema do
+      #     scm :Person do
+      #       str? :foo, default: 'bar'
+      #     end
+      #     ref? :person, :Person, default: {}
+      #   end
+
+      #   assert_cast({}, person: { foo: 'bar' })
+      # 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) })
+      # end
+    end
+  end
+end