json_model_rb 0.1.20 → 0.1.22

data/spec/type_spec/composition_spec.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require('spec_helper')
-
-RSpec.describe(JsonModel::TypeSpec::Composition) do
-  describe('#as_schema') do
-    it('returns schema of complex types') do
-      expect(
-        described_class
-          .new(
-            :allOf,
-            JsonModel::TypeSpec::Primitive::String.new,
-            Class.new do
-              include(JsonModel::Schema)
-
-              property(:foo, type: String)
-            end,
-          )
-          .as_schema,
-      )
-        .to(
-          eq(
-            {
-              allOf: [
-                { type: 'string' },
-                {
-                  type: 'object',
-                  properties: { foo: { type: 'string' } },
-                  required: %i(foo),
-                },
-              ],
-            },
-          ),
-        )
-    end
-
-    it('uses external references') do
-      expect(
-        described_class
-          .new(
-            :allOf,
-            Class.new do
-              include(JsonModel::Schema)
-
-              property(:foo, type: String)
-              schema_id('https://example.com/schemas/foo.json')
-            end,
-          )
-          .as_schema(ref_mode: JsonModel::RefMode::EXTERNAL),
-      )
-        .to(
-          eq(
-            {
-              allOf: [
-                { '$ref': 'https://example.com/schemas/foo.json' },
-              ],
-            },
-          ),
-        )
-    end
-
-    it('uses local references') do
-      expect(
-        described_class
-          .new(
-            :allOf,
-            Class.new do
-              include(JsonModel::Schema)
-
-              property(:foo, type: String)
-
-              def self.name
-                'Foo'
-              end
-            end,
-          )
-          .as_schema(ref_mode: JsonModel::RefMode::LOCAL),
-      )
-        .to(
-          eq(
-            {
-              allOf: [
-                { '$ref': '#/$defs/Foo' },
-              ],
-            },
-          ),
-        )
-    end
-  end
-end

data/spec/type_spec/const_spec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require('spec_helper')
-
-RSpec.describe(JsonModel::TypeSpec::Const) do
-  describe('#as_schema') do
-    it('returns a const schema') do
-      expect(described_class.new('a').as_schema)
-        .to(
-          eq(
-            {
-              const: 'a',
-            },
-          ),
-        )
-    end
-  end
-end

data/spec/type_spec/enum_spec.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-require('spec_helper')
-
-RSpec.describe(JsonModel::TypeSpec::Enum) do
-  describe('#as_schema') do
-    it('returns an enum schema') do
-      expect(described_class.new(1, 'a').as_schema)
-        .to(
-          eq(
-            {
-              enum: [1, 'a'],
-            },
-          ),
-        )
-    end
-  end
-
-  describe('.register_validations') do
-    let(:klass) do
-      Class.new do
-        include(ActiveModel::Validations)
-
-        attr_accessor(:foo)
-
-        def initialize(foo:)
-          @foo = foo
-        end
-      end
-    end
-
-    context('for nil values') do
-      it('fails the validation if not allowed') do
-        described_class
-          .new(1)
-          .register_validations(:foo, klass)
-        instance = klass.new(foo: 2)
-
-        expect(instance.valid?)
-          .to(be(false))
-        expect(instance.errors.map(&:type))
-          .to(eq(%i(inclusion)))
-      end
-
-      it('succeeds the validation if allowed') do
-        described_class
-          .new(nil)
-          .register_validations(:foo, klass)
-        instance = klass.new(foo: nil)
-
-        expect(instance.valid?)
-          .to(be(true))
-        expect(instance.errors)
-          .to(be_empty)
-      end
-    end
-
-    context('for non-nil values') do
-      before do
-        described_class
-          .new(1, 'a')
-          .register_validations(:foo, klass)
-      end
-
-      it('fails the validation if not allowed') do
-        instance = klass.new(foo: 0)
-
-        expect(instance.valid?)
-          .to(be(false))
-        expect(instance.errors.map(&:type))
-          .to(eq(%i(inclusion)))
-      end
-
-      it('succeeds the validation if allowed') do
-        instance = klass.new(foo: 'a')
-
-        expect(instance.valid?)
-          .to(be(true))
-        expect(instance.errors)
-          .to(be_empty)
-      end
-    end
-  end
-end

data/spec/type_spec/primitive/boolean_spec.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require('spec_helper')
-
-RSpec.describe(JsonModel::TypeSpec::Primitive::Boolean) do
-  describe('#as_schema') do
-    it('returns a boolean schema') do
-      expect(subject.as_schema)
-        .to(eq({ type: 'boolean' }))
-    end
-  end
-end

data/spec/type_spec/primitive/integer_spec.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require('spec_helper')
-
-RSpec.describe(JsonModel::TypeSpec::Primitive::Integer) do
-  describe('#as_schema') do
-    it('returns an integer schema') do
-      expect(subject.as_schema)
-        .to(eq({ type: 'integer' }))
-    end
-
-    it('includes the multipleOf attribute') do
-      expect(described_class.new(multiple_of: 5).as_schema)
-        .to(eq({ type: 'integer', multipleOf: 5 }))
-    end
-  end
-
-  describe('.register_validations') do
-    let(:klass) do
-      Class.new do
-        include(ActiveModel::Validations)
-
-        attr_accessor(:foo)
-
-        def initialize(foo:)
-          @foo = foo
-        end
-      end
-    end
-
-    context('for integer-ness') do
-      before do
-        described_class
-          .new
-          .register_validations(:foo, klass)
-      end
-
-      it('fails the validation for floats') do
-        instance = klass.new(foo: 1.234)
-
-        expect(instance.valid?)
-          .to(be(false))
-        expect(instance.errors.map(&:type))
-          .to(eq(%i(not_an_integer)))
-      end
-
-      it('succeeds the validation for integers') do
-        instance = klass.new(foo: 1234)
-
-        expect(instance.valid?)
-          .to(be(true))
-        expect(instance.errors)
-          .to(be_empty)
-      end
-    end
-  end
-end

data/spec/type_spec/primitive/null_spec.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require('spec_helper')
-
-RSpec.describe(JsonModel::TypeSpec::Primitive::Null) do
-  describe('#as_schema') do
-    it('returns a null schema') do
-      expect(subject.as_schema)
-        .to(eq({ type: 'null' }))
-    end
-  end
-end

data/spec/type_spec/primitive/number_spec.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require('spec_helper')
-
-RSpec.describe(JsonModel::TypeSpec::Primitive::Number) do
-  describe('#as_schema') do
-    it('returns a number schema') do
-      expect(subject.as_schema)
-        .to(eq({ type: 'number' }))
-    end
-  end
-end

data/spec/type_spec/primitive/numeric_spec.rb

@@ -1,176 +0,0 @@
-# frozen_string_literal: true
-
-require('spec_helper')
-
-RSpec.describe(JsonModel::TypeSpec::Primitive::Numeric) do
-  describe('#as_schema') do
-    it('includes the multipleOf attribute') do
-      expect(described_class.new(types: [Integer, Float], schema_type: 'number', multiple_of: 5).as_schema)
-        .to(eq({ type: 'number', multipleOf: 5 }))
-    end
-
-    it('includes the minimum attribute') do
-      expect(described_class.new(types: [Integer, Float], schema_type: 'number', minimum: 5).as_schema)
-        .to(eq({ type: 'number', minimum: 5 }))
-    end
-
-    it('includes the maximum attribute') do
-      expect(described_class.new(types: [Integer, Float], schema_type: 'number', maximum: 5).as_schema)
-        .to(eq({ type: 'number', maximum: 5 }))
-    end
-
-    it('includes the exclusiveMinimum attribute') do
-      expect(described_class.new(types: [Integer, Float], schema_type: 'number', exclusive_minimum: 5).as_schema)
-        .to(eq({ type: 'number', exclusiveMinimum: 5 }))
-    end
-
-    it('includes the exclusiveMaximum attribute') do
-      expect(described_class.new(types: [Integer, Float], schema_type: 'number', exclusive_maximum: 5).as_schema)
-        .to(eq({ type: 'number', exclusiveMaximum: 5 }))
-    end
-  end
-
-  describe('.register_validations') do
-    let(:klass) do
-      Class.new do
-        include(ActiveModel::Validations)
-
-        attr_accessor(:foo)
-
-        def initialize(foo:)
-          @foo = foo
-        end
-      end
-    end
-
-    context('for multiple of') do
-      before do
-        described_class
-          .new(types: [Integer, Float], schema_type: 'number', multiple_of: 5)
-          .register_validations(:foo, klass)
-      end
-
-      it('fails the validation for non-multiples') do
-        instance = klass.new(foo: 1234)
-
-        expect(instance.valid?)
-          .to(be(false))
-        expect(instance.errors.map(&:type))
-          .to(eq(%i(multiple_of)))
-      end
-
-      it('succeeds the validation for integers') do
-        instance = klass.new(foo: 12_345)
-
-        expect(instance.valid?)
-          .to(be(true))
-        expect(instance.errors)
-          .to(be_empty)
-      end
-    end
-
-    context('for minimum') do
-      before do
-        described_class
-          .new(types: [Integer, Float], schema_type: 'number', minimum: 5)
-          .register_validations(:foo, klass)
-      end
-
-      it('fails the validation for invalid values') do
-        instance = klass.new(foo: 4)
-
-        expect(instance.valid?)
-          .to(be(false))
-        expect(instance.errors.map(&:type))
-          .to(eq(%i(greater_than_or_equal_to)))
-      end
-
-      it('succeeds the validation for valid values') do
-        instance = klass.new(foo: 5)
-
-        expect(instance.valid?)
-          .to(be(true))
-        expect(instance.errors)
-          .to(be_empty)
-      end
-    end
-
-    context('for maximum') do
-      before do
-        described_class
-          .new(types: [Integer, Float], schema_type: 'number', maximum: 5)
-          .register_validations(:foo, klass)
-      end
-
-      it('fails the validation for invalid values') do
-        instance = klass.new(foo: 6)
-
-        expect(instance.valid?)
-          .to(be(false))
-        expect(instance.errors.map(&:type))
-          .to(eq(%i(less_than_or_equal_to)))
-      end
-
-      it('succeeds the validation for valid values') do
-        instance = klass.new(foo: 5)
-
-        expect(instance.valid?)
-          .to(be(true))
-        expect(instance.errors)
-          .to(be_empty)
-      end
-    end
-
-    context('for exclusive_minimum') do
-      before do
-        described_class
-          .new(types: [Integer, Float], schema_type: 'number', exclusive_minimum: 5)
-          .register_validations(:foo, klass)
-      end
-
-      it('fails the validation for invalid values') do
-        instance = klass.new(foo: 5)
-
-        expect(instance.valid?)
-          .to(be(false))
-        expect(instance.errors.map(&:type))
-          .to(eq(%i(greater_than)))
-      end
-
-      it('succeeds the validation for valid values') do
-        instance = klass.new(foo: 6)
-
-        expect(instance.valid?)
-          .to(be(true))
-        expect(instance.errors)
-          .to(be_empty)
-      end
-    end
-
-    context('for exclusive_maximum') do
-      before do
-        described_class
-          .new(types: [Integer, Float], schema_type: 'number', exclusive_maximum: 5)
-          .register_validations(:foo, klass)
-      end
-
-      it('fails the validation for invalid values') do
-        instance = klass.new(foo: 5)
-
-        expect(instance.valid?)
-          .to(be(false))
-        expect(instance.errors.map(&:type))
-          .to(eq(%i(less_than)))
-      end
-
-      it('succeeds the validation for valid values') do
-        instance = klass.new(foo: 4)
-
-        expect(instance.valid?)
-          .to(be(true))
-        expect(instance.errors)
-          .to(be_empty)
-      end
-    end
-  end
-end

data/spec/type_spec/primitive/string_spec.rb

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-require('spec_helper')
-
-RSpec.describe(JsonModel::TypeSpec::Primitive::String) do
-  describe('#as_schema') do
-    it('returns a string schema') do
-      expect(subject.as_schema)
-        .to(eq({ type: 'string' }))
-    end
-
-    it('includes the minLength attribute') do
-      expect(described_class.new(min_length: 10).as_schema)
-        .to(eq({ type: 'string', minLength: 10 }))
-    end
-
-    it('includes the maxLength attribute') do
-      expect(described_class.new(max_length: 10).as_schema)
-        .to(eq({ type: 'string', maxLength: 10 }))
-    end
-
-    it('includes the pattern attribute') do
-      expect(described_class.new(pattern: /\A\w+\z/).as_schema)
-        .to(eq({ type: 'string', pattern: '\\A\\w+\\z' }))
-    end
-  end
-
-  describe('.register_validations') do
-    let(:klass) do
-      Class.new do
-        include(ActiveModel::Validations)
-
-        attr_accessor(:foo)
-
-        def initialize(foo:)
-          @foo = foo
-        end
-      end
-    end
-
-    context('for min length') do
-      before do
-        described_class
-          .new(min_length: 3)
-          .register_validations(:foo, klass)
-      end
-
-      it('fails the validation for too short strings') do
-        instance = klass.new(foo: 'ba')
-
-        expect(instance.valid?)
-          .to(be(false))
-        expect(instance.errors.map(&:type))
-          .to(eq(%i(too_short)))
-      end
-
-      it('succeeds the validation for valid strings') do
-        instance = klass.new(foo: 'bar')
-
-        expect(instance.valid?)
-          .to(be(true))
-        expect(instance.errors)
-          .to(be_empty)
-      end
-    end
-
-    context('for max length') do
-      before do
-        described_class
-          .new(max_length: 2)
-          .register_validations(:foo, klass)
-      end
-
-      it('fails the validation for too short strings') do
-        instance = klass.new(foo: 'bar')
-
-        expect(instance.valid?)
-          .to(be(false))
-        expect(instance.errors.map(&:type))
-          .to(eq(%i(too_long)))
-      end
-
-      it('succeeds the validation for valid strings') do
-        instance = klass.new(foo: 'ba')
-
-        expect(instance.valid?)
-          .to(be(true))
-        expect(instance.errors)
-          .to(be_empty)
-      end
-    end
-
-    context('for a pattern') do
-      before do
-        described_class
-          .new(pattern: /\A\w+\z/)
-          .register_validations(:foo, klass)
-      end
-
-      it('fails the validation for an invalid value') do
-        instance = klass.new(foo: ' bar')
-
-        expect(instance.valid?)
-          .to(be(false))
-        expect(instance.errors.map(&:type))
-          .to(eq(%i(invalid)))
-      end
-
-      it('succeeds the validation for valid strings') do
-        instance = klass.new(foo: 'bar')
-
-        expect(instance.valid?)
-          .to(be(true))
-        expect(instance.errors)
-          .to(be_empty)
-      end
-    end
-  end
-end

data/spec/type_spec_spec.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require('spec_helper')
-
-RSpec.describe(JsonModel::TypeSpec) do
-  describe('#resolve') do
-    shared_examples_for('primitive type') do |type:, expected_type:|
-      it("resolves to a primitive type spec for #{type}") do
-        expect(JsonModel::TypeSpec.resolve(type))
-          .to(be_a(expected_type))
-      end
-    end
-
-    shared_examples_for('unsupported type') do |type|
-      it("raises an error for #{type}") do
-        expect { JsonModel::TypeSpec.resolve(type) }
-          .to(raise_error(ArgumentError))
-      end
-    end
-
-    it_behaves_like('primitive type', type: String, expected_type: JsonModel::TypeSpec::Primitive::String)
-    it_behaves_like('primitive type', type: Integer, expected_type: JsonModel::TypeSpec::Primitive::Integer)
-    it_behaves_like('primitive type', type: Float, expected_type: JsonModel::TypeSpec::Primitive::Number)
-    it_behaves_like('primitive type', type: TrueClass, expected_type: JsonModel::TypeSpec::Primitive::Boolean)
-    it_behaves_like('primitive type', type: FalseClass, expected_type: JsonModel::TypeSpec::Primitive::Boolean)
-    it_behaves_like('primitive type', type: JsonModel::TypeSpec::Primitive::String.new, expected_type: JsonModel::TypeSpec::Primitive::String)
-
-    it_behaves_like('unsupported type', Class.new)
-    it_behaves_like('unsupported type', Object.new)
-    it_behaves_like('unsupported type', nil)
-  end
-end