json_model_rb 0.1.1

data/spec/type_spec/composition/any_of_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require('spec_helper')
+
+RSpec.describe(JsonModel::TypeSpec::Composition::AnyOf) do
+  describe('#as_schema') do
+    it('returns an any of schema') do
+      expect(
+        described_class.new(JsonModel::TypeSpec::Primitive::String.new).as_schema,
+      )
+        .to(
+          eq(
+            {
+              anyOf: [{ type: 'string' }],
+            },
+          ),
+        )
+    end
+  end
+end

data/spec/type_spec/composition/one_of_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require('spec_helper')
+
+RSpec.describe(JsonModel::TypeSpec::Composition::OneOf) do
+  describe('#as_schema') do
+    it('returns a one of schema') do
+      expect(
+        described_class.new(JsonModel::TypeSpec::Primitive::String.new).as_schema,
+      )
+        .to(
+          eq(
+            {
+              oneOf: [{ type: 'string' }],
+            },
+          ),
+        )
+    end
+  end
+end

data/spec/type_spec/composition_spec.rb

@@ -0,0 +1,90 @@
+# 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/enum_spec.rb

@@ -0,0 +1,93 @@
+# 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: nil)
+
+        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 nil') do
+        instance = klass.new(foo: nil)
+
+        expect(instance.valid?)
+          .to(be(false))
+        expect(instance.errors.map(&:type))
+          .to(eq(%i(inclusion)))
+      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

@@ -0,0 +1,12 @@
+# 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

@@ -0,0 +1,57 @@
+# 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

@@ -0,0 +1,12 @@
+# 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

@@ -0,0 +1,12 @@
+# 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

@@ -0,0 +1,176 @@
+# 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('number', multiple_of: 5).as_schema)
+        .to(eq({ type: 'number', multipleOf: 5 }))
+    end
+
+    it('includes the minimum attribute') do
+      expect(described_class.new('number', minimum: 5).as_schema)
+        .to(eq({ type: 'number', minimum: 5 }))
+    end
+
+    it('includes the maximum attribute') do
+      expect(described_class.new('number', maximum: 5).as_schema)
+        .to(eq({ type: 'number', maximum: 5 }))
+    end
+
+    it('includes the exclusiveMinimum attribute') do
+      expect(described_class.new('number', exclusive_minimum: 5).as_schema)
+        .to(eq({ type: 'number', exclusiveMinimum: 5 }))
+    end
+
+    it('includes the exclusiveMaximum attribute') do
+      expect(described_class.new('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('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('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('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('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('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

@@ -0,0 +1,119 @@
+# 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

@@ -0,0 +1,32 @@
+# 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