json_model_rb 0.1.1

data/spec/properties_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require('spec_helper')
+
+RSpec.describe(JsonModel::Properties) do
+  describe('.property') do
+    let(:klass) do
+      Class.new do
+        include(JsonModel::Properties)
+      end
+    end
+
+    it('has no default properties') do
+      expect(klass.properties)
+        .to(eq({}))
+    end
+
+    it('adds a property by name') do
+      klass.property(:foo, type: String)
+
+      expect(klass.properties.keys)
+        .to(eq(%i(foo)))
+      expect(klass.properties[:foo])
+        .to(be_a(JsonModel::Property))
+    end
+  end
+
+  describe('getter and setter') do
+    let(:klass) do
+      Class.new do
+        include(JsonModel::Properties)
+
+        property(:foo, type: String)
+      end
+    end
+
+    it('responds to the getter') do
+      expect(klass.new)
+        .to(respond_to(:foo))
+    end
+
+    it('responds to the setter') do
+      expect(klass.new)
+        .to(respond_to(:foo=))
+    end
+
+    it('allows updating the property') do
+      instance = klass.new
+
+      expect(instance.foo)
+        .to(be_nil)
+
+      instance.foo = 'bar'
+
+      expect(instance.foo)
+        .to(eq('bar'))
+    end
+
+    context('with a default value') do
+      before { klass.property(:foo, type: String, default: 'bar') }
+
+      it('returns the default value') do
+        expect(klass.new.foo)
+          .to(eq('bar'))
+      end
+
+      it('returns the updated value') do
+        instance = klass.new
+        instance.foo = 'foo'
+
+        expect(instance.foo)
+          .to(eq('foo'))
+      end
+    end
+  end
+end

data/spec/property_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require('spec_helper')
+
+RSpec.describe(JsonModel::Property) do
+  describe('.register_validations') do
+    let(:klass) do
+      Class.new do
+        include(ActiveModel::Validations)
+
+        attr_accessor(:foo)
+      end
+    end
+
+    context('for an optional property') do
+      before do
+        described_class
+          .new(:foo, type: JsonModel::TypeSpec::Primitive::String.new, optional: true)
+          .register_validations(klass)
+      end
+
+      it('does not fail the validation for missing values') do
+        instance = klass.new
+
+        expect(instance.valid?)
+          .to(be(true))
+        expect(instance.errors)
+          .to(be_empty)
+      end
+
+      it('does not fail the validation for present values') do
+        instance = klass.new.tap { |obj| obj.foo = 'bar' }
+
+        expect(instance.valid?)
+          .to(be(true))
+        expect(instance.errors)
+          .to(be_empty)
+      end
+    end
+
+    context('for a non-optional property') do
+      before do
+        described_class
+          .new(:foo, type: JsonModel::TypeSpec::Primitive::String.new)
+          .register_validations(klass)
+      end
+
+      it('fails the validation for missing values') do
+        instance = klass.new
+
+        expect(instance.valid?)
+          .to(be(false))
+        expect(instance.errors.map(&:type))
+          .to(eq(%i(blank)))
+      end
+
+      it('does not fail the validation for present values') do
+        instance = klass.new.tap { |obj| obj.foo = 'bar' }
+
+        expect(instance.valid?)
+          .to(be(true))
+        expect(instance.errors)
+          .to(be_empty)
+      end
+    end
+  end
+
+  describe('#as_schema') do
+    it('renders the property as a schema') do
+      expect(described_class.new(:foo, type: JsonModel::TypeSpec::Primitive::String.new).as_schema)
+        .to(eq({ foo: { type: 'string' } }))
+    end
+
+    it('respects the "as" option') do
+      expect(described_class.new(:foo, type: JsonModel::TypeSpec::Primitive::String.new, as: :bar).as_schema)
+        .to(eq({ bar: { type: 'string' } }))
+    end
+
+    it('falls back to the configured naming strategy') do
+      JsonModel.configure { |config| config.property_naming_strategy = :camel_case }
+
+      expect(described_class.new(:foo_bar, type: JsonModel::TypeSpec::Primitive::String.new).as_schema)
+        .to(eq({ fooBar: { type: 'string' } }))
+    end
+  end
+end

data/spec/schema_meta_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require('spec_helper')
+
+RSpec.describe(JsonModel::SchemaMeta) do
+  describe('.schema_id') do
+    let(:klass) do
+      Class.new do
+        include(JsonModel::SchemaMeta)
+      end
+    end
+
+    it('is nil by default') do
+      expect(klass.schema_id)
+        .to(be_nil)
+    end
+
+    it('can be changed') do
+      klass.schema_id('foo')
+
+      expect(klass.schema_id)
+        .to(eq('foo'))
+    end
+
+    it('respects the schema_id_base_uri') do
+      JsonModel.configure { |config| config.schema_id_base_uri = 'http://example.com/schemas/' }
+      klass.schema_id('foo')
+
+      expect(klass.schema_id)
+        .to(eq('http://example.com/schemas/foo'))
+    end
+
+    it('raises an error if the schema id is invalid') do
+      expect { klass.schema_id('http://example .com') }
+        .to(raise_error(URI::InvalidURIError))
+    end
+  end
+
+  describe('.schema_version') do
+    let(:klass) do
+      Class.new do
+        include(JsonModel::SchemaMeta)
+      end
+    end
+
+    it('is nil by default') do
+      expect(klass.schema_version)
+        .to(be_nil)
+    end
+
+    it('can be changed') do
+      klass.schema_version(:draft202012)
+
+      expect(klass.schema_version)
+        .to(eq('https://json-schema.org/draft/2020-12/schema'))
+    end
+  end
+
+  describe('.additional_properties') do
+    let(:klass) do
+      Class.new do
+        include(JsonModel::SchemaMeta)
+      end
+    end
+
+    it('is missing by default') do
+      expect(klass.meta_attributes)
+        .to(eq({}))
+    end
+
+    it('can be changed') do
+      klass.additional_properties(true)
+
+      expect(klass.meta_attributes)
+        .to(eq({ additionalProperties: true }))
+    end
+  end
+end

data/spec/schema_spec.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require('spec_helper')
+
+RSpec.describe(JsonModel::Schema) do
+  describe('.initialize') do
+    let(:klass) do
+      Class.new do
+        include(JsonModel::Schema)
+
+        property(:foo, type: String, optional: true)
+
+        def self.name
+          'Foo'
+        end
+      end
+    end
+
+    it('succeeds without providing attributes') do
+      expect { klass.new }.not_to(raise_error)
+    end
+
+    it('sets attribute values') do
+      instance = klass.new(foo: 'bar')
+
+      expect(instance.foo)
+        .to(eq('bar'))
+    end
+
+    it('raises an error for unknown attributes when additional properties are not allowed') do
+      expect { klass.new(bar: 'baz') }
+        .to(raise_error(JsonModel::Errors::UnknownAttributeError))
+    end
+
+    it('does not raise an error for unknown attributes when additional properties are allowed') do
+      klass.additional_properties(true)
+
+      klass.new(bar: 'baz')
+    end
+  end
+
+  describe('#valid?') do
+    let(:klass) do
+      Class.new do
+        include(JsonModel::Schema)
+
+        property(:foo, type: String, min_length: 3)
+      end
+    end
+
+    before do
+      JsonModel.configure { |config| config.validate_after_instantiation = false }
+    end
+
+    it('returns false for invalid values') do
+      expect(klass.new(foo: 'ba').valid?)
+        .to(be(false))
+    end
+
+    it('returns true for valid values') do
+      expect(klass.new(foo: 'bar').valid?)
+        .to(be(true))
+    end
+  end
+
+  describe('.as_schema') do
+    let(:klass) do
+      Class.new do
+        include(JsonModel::Schema)
+      end
+    end
+
+    it('returns an empty schema') do
+      expect(klass.as_schema)
+        .to(eq({ type: 'object' }))
+    end
+
+    it('includes the schema id') do
+      klass.schema_id('https://example.com/schemas/example.json')
+
+      expect(klass.as_schema)
+        .to(
+          eq(
+            {
+              '$id': 'https://example.com/schemas/example.json',
+              type: 'object',
+            },
+          ),
+        )
+    end
+
+    it('returns properties as schema') do
+      klass.schema_id('https://example.com/schemas/example.json')
+      klass.property(:foo, type: String)
+      klass.property(:bar, type: Float, optional: true)
+      klass.property(:baz, type: T::Enum[1, 'a', nil])
+      klass.property(:bam, type: T::Array[T::AllOf[String, Float]])
+      klass.property(:bal, type: klass, ref_mode: JsonModel::RefMode::EXTERNAL, optional: true)
+
+      expect(klass.as_schema)
+        .to(
+          eq(
+            {
+              '$id': 'https://example.com/schemas/example.json',
+              type: 'object',
+              properties: {
+                bal: { '$ref': 'https://example.com/schemas/example.json' },
+                bam: {
+                  type: 'array',
+                  items: {
+                    allOf: [{ type: 'string' }, { type: 'number' }],
+                  },
+                },
+                bar: { type: 'number' },
+                baz: { enum: [1, 'a', nil] },
+                foo: { type: 'string' },
+              },
+              required: %i(bam baz foo),
+            },
+          ),
+        )
+    end
+
+    it('collects local references in $defs') do
+      klass.property(
+        :foo,
+        type: Class.new do
+          include(JsonModel::Schema)
+
+          property(:foo, type: String)
+        end,
+      )
+      klass.property(
+        :bam,
+        type: Class.new do
+          include(JsonModel::Schema)
+
+          property(:bam, type: String)
+          schema_id('https://example.com/schemas/bam.json')
+        end,
+        ref_mode: JsonModel::RefMode::EXTERNAL,
+      )
+      klass.property(
+        :bar,
+        type: T::Array[
+          T::Array[
+            Class.new do
+              include(JsonModel::Schema)
+
+              property(:bar, type: String)
+
+              def self.name
+                'Bar'
+              end
+            end,
+          ],
+        ],
+        ref_mode: JsonModel::RefMode::LOCAL,
+      )
+
+      expect(klass.as_schema)
+        .to(
+          eq(
+            {
+              type: 'object',
+              properties: {
+                bam: { '$ref': 'https://example.com/schemas/bam.json' },
+                bar: {
+                  type: 'array',
+                  items: {
+                    type: 'array',
+                    items: { '$ref': '#/$defs/Bar' },
+                  },
+                },
+                foo: {
+                  type: 'object',
+                  properties: { foo: { type: 'string' } },
+                  required: %i(foo),
+                },
+              },
+              '$defs': {
+                Bar: {
+                  type: 'object',
+                  properties: { bar: { type: 'string' } },
+                  required: %i(bar),
+                },
+              },
+              required: %i(bam bar foo),
+            },
+          ),
+        )
+    end
+
+    context('inheritance') do
+      let(:child) do
+        Class.new(klass) do
+          schema_id('https://example.com/schemas/child.json')
+        end
+      end
+
+      it('uses $ref for inherited schemas if they have a schema id') do
+        klass.schema_id('https://example.com/schemas/example.json')
+        klass.property(:foo, type: String)
+
+        expect(child.as_schema)
+          .to(
+            eq(
+              {
+                '$id': 'https://example.com/schemas/child.json',
+                '$ref': 'https://example.com/schemas/example.json',
+                type: 'object',
+              },
+            ),
+          )
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require('bundler/setup')
+require('json_model')
+
+RSpec.configure do |config|
+  config.disable_monkey_patching!
+  config.after do
+    JsonModel.configure do |json_model_config|
+      JsonModel.config.defaults.each { |key, value| json_model_config.send("#{key}=", value) }
+    end
+  end
+end

data/spec/type_spec/array_spec.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require('spec_helper')
+
+RSpec.describe(JsonModel::TypeSpec::Array) do
+  describe('#as_schema') do
+    it('returns an array schema of primitive types') do
+      expect(
+        described_class.new(JsonModel::TypeSpec::Primitive::String.new).as_schema,
+      )
+        .to(
+          eq(
+            {
+              type: 'array',
+              items: { type: 'string' },
+            },
+          ),
+        )
+    end
+
+    it('returns an array schema of nested array types') do
+      expect(
+        described_class.new(described_class.new(JsonModel::TypeSpec::Primitive::String.new)).as_schema,
+      )
+        .to(
+          eq(
+            {
+              type: 'array',
+              items: { type: 'array', items: { type: 'string' } },
+            },
+          ),
+        )
+    end
+
+    it('includes the minItems attribute') do
+      expect(
+        described_class.new(JsonModel::TypeSpec::Primitive::String.new, min_items: 10).as_schema,
+      )
+        .to(
+          eq(
+            {
+              type: 'array',
+              items: { type: 'string' },
+              minItems: 10,
+            },
+          ),
+        )
+    end
+
+    it('includes the maxItems attribute') do
+      expect(
+        described_class.new(JsonModel::TypeSpec::Primitive::String.new, max_items: 10).as_schema,
+      )
+        .to(
+          eq(
+            {
+              type: 'array',
+              items: { type: 'string' },
+              maxItems: 10,
+            },
+          ),
+        )
+    end
+
+    it('uses external references') do
+      expect(
+        described_class
+          .new(
+            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(
+            {
+              type: 'array',
+              items: { '$ref': 'https://example.com/schemas/foo.json' },
+            },
+          ),
+        )
+    end
+
+    it('uses local references') do
+      expect(
+        described_class
+          .new(
+            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(
+            {
+              type: 'array',
+              items: { '$ref': '#/$defs/Foo' },
+            },
+          ),
+        )
+    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 items') do
+      before do
+        described_class
+          .new(JsonModel::TypeSpec::Primitive::String.new, min_items: 5)
+          .register_validations(:foo, klass)
+      end
+
+      it('fails the validation for invalid values') do
+        instance = klass.new(foo: ['a'] * 4)
+
+        expect(instance.valid?)
+          .to(be(false))
+        expect(instance.errors.map(&:type))
+          .to(eq(%i(too_short)))
+      end
+
+      it('succeeds the validation for valid values') do
+        instance = klass.new(foo: ['a'] * 5)
+
+        expect(instance.valid?)
+          .to(be(true))
+        expect(instance.errors)
+          .to(be_empty)
+      end
+    end
+
+    context('for max items') do
+      before do
+        described_class
+          .new(JsonModel::TypeSpec::Primitive::String.new, max_items: 5)
+          .register_validations(:foo, klass)
+      end
+
+      it('fails the validation for invalid values') do
+        instance = klass.new(foo: ['a'] * 6)
+
+        expect(instance.valid?)
+          .to(be(false))
+        expect(instance.errors.map(&:type))
+          .to(eq(%i(too_long)))
+      end
+
+      it('succeeds the validation for valid values') do
+        instance = klass.new(foo: ['a'] * 5)
+
+        expect(instance.valid?)
+          .to(be(true))
+        expect(instance.errors)
+          .to(be_empty)
+      end
+    end
+
+    context('for unique items') do
+      before do
+        described_class
+          .new(JsonModel::TypeSpec::Primitive::String.new, unique_items: true)
+          .register_validations(:foo, klass)
+      end
+
+      it('fails the validation for invalid values') do
+        instance = klass.new(foo: %w(a b a))
+
+        expect(instance.valid?)
+          .to(be(false))
+        expect(instance.errors.map(&:type))
+          .to(eq(%i(uniqueness)))
+      end
+
+      it('succeeds the validation for valid values') do
+        instance = klass.new(foo: %w(a b c))
+
+        expect(instance.valid?)
+          .to(be(true))
+        expect(instance.errors)
+          .to(be_empty)
+      end
+    end
+  end
+end

data/spec/type_spec/composition/all_of_spec.rb

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