nested_record 0.1.0

data/spec/nested_record/base_spec.rb

@@ -0,0 +1,181 @@
+require 'spec_helper'
+
+RSpec.describe NestedRecord::Base do
+  nested_model(:Foo) do
+    attribute :x, :string
+    attribute :y, :integer
+    attribute :z, :boolean
+  end
+
+  describe '.deep_inherited?' do
+    subject { Foo.deep_inherited? }
+
+    context 'when subclassing from NestedRecord::Base' do
+      nested_model(:Foo, NestedRecord::Base)
+
+      it { is_expected.to be false }
+    end
+
+    context 'when subclassing from NestedRecord::Base' do
+      nested_model(:Bar, NestedRecord::Base)
+      nested_model(:Foo, :Bar)
+
+      it { is_expected.to be true }
+    end
+  end
+
+  describe '.collection_class' do
+    subject { Foo.collection_class }
+
+    it 'is a subclass of NestedRecord::Collection' do
+      is_expected.to be < NestedRecord::Collection
+    end
+
+    it 'holds a reference to record_class' do
+      is_expected.to have_attributes(record_class: Foo)
+    end
+
+    context 'with .collection_methods' do
+      before do
+        Foo.collection_methods do
+          def filter_by_something; end
+        end
+      end
+
+      it 'has collection methods defined' do
+        expect(Foo.collection_class.method_defined?(:filter_by_something)).to be true
+      end
+    end
+
+    context 'when inherited' do
+      nested_model(:Bar)
+      nested_model(:Foo, :Bar)
+
+      it 'uses ancestor collection class as a subclass' do
+        is_expected.to be < Bar.collection_class
+      end
+    end
+  end
+
+  describe '.new' do
+    context 'with inheritance' do
+      nested_model(:Bar)
+      nested_model(:Foo, :Bar)
+      nested_model(:Baz)
+
+      it 'returns an instance of subclass' do
+        expect(Bar.new).to be_an_instance_of(Bar)
+        expect(Bar.new(type: 'Foo')).to be_an_instance_of(Foo)
+      end
+
+      it 'sets a type attribute' do
+        expect(Foo.new.type).to eq 'Foo'
+      end
+
+      it 'raises error when type is not a subclass' do
+        expect { Bar.new(type: 'Baz') }.to raise_error(NestedRecord::InvalidTypeError)
+      end
+
+      it 'raises error when type is invalid' do
+        expect { Bar.new(type: 'Buzz') }.to raise_error(NestedRecord::InvalidTypeError)
+      end
+
+      context 'with namespaced models and inherited_types full: true' do
+        nested_model('A::Bar') do
+          inherited_types full: true
+        end
+        nested_model('A::Foo', 'A::Bar')
+
+        it 'looks up for a subclass globally' do
+          expect(A::Bar.new(type: 'A::Foo')).to be_an_instance_of(A::Foo)
+          expect { A::Bar.new(type: 'Foo') }.to raise_error(NestedRecord::InvalidTypeError)
+        end
+      end
+
+      context 'with namespaced models and inherited_types full: false' do
+        nested_model('A::Bar') do
+          inherited_types full: false
+        end
+        nested_model('A::Foo', 'A::Bar')
+
+        it 'looks up for a subclass through all namespaces' do
+          expect(A::Bar.new(type: 'A::Foo')).to be_an_instance_of(A::Foo)
+          expect(A::Bar.new(type: 'Foo')).to be_an_instance_of(A::Foo)
+        end
+      end
+
+      context 'with inherited_types :namespace option' do
+        nested_model('A::Bar') do
+          inherited_types namespace: 'A::Bars'
+        end
+        nested_model('A::Bars::Foo', 'A::Bar')
+        nested_model('A::Foo', 'A::Bar')
+
+        it 'looks up for a subclass through a specific namespace' do
+          expect(A::Bar.new(type: 'Foo')).to be_an_instance_of(A::Bars::Foo)
+        end
+
+        it 'sets a shortened :type attribute' do
+          expect(A::Bars::Foo.new.type).to eq 'Foo'
+        end
+
+        it 'keeps full class type for records outside namespace' do
+          expect(A::Bar.new(type: 'A::Foo').type).to eq 'A::Foo'
+        end
+      end
+
+      context 'with inherited_types underscored: true' do
+        nested_model('A::Bar') do
+          inherited_types underscored: true, full: false
+        end
+        nested_model('A::Bar::Foo', 'A::Bar')
+
+        it 'looks up for a subclass through a specific namespace' do
+          expect(A::Bar.new(type: 'bar/foo')).to be_an_instance_of(A::Bar::Foo)
+        end
+
+        it 'sets a shortened :type attribute' do
+          expect(A::Bar::Foo.new.type).to eq 'a/bar/foo'
+        end
+      end
+    end
+  end
+
+  describe '#as_json' do
+    it 'serializes as a hash of attributes' do
+      foo = Foo.new(x: 'aa', y: 123, z: true)
+      expect(foo.as_json).to eq('x' => 'aa', 'y' => 123, 'z' => true)
+    end
+  end
+
+  describe '#read_attribute' do
+    it 'reads attribute value' do
+      foo = Foo.new(x: 'aa')
+      expect(foo.read_attribute(:x)).to eq 'aa'
+    end
+
+    it 'returns nil for unknown attributes' do
+      foo = Foo.new(x: 'aa')
+      expect(foo.read_attribute(:lol)).to be nil
+    end
+  end
+
+  describe '#match?' do
+    let(:record) { Foo.new(x: 'aa', y: 123, z: true) }
+
+    it 'matches by a single value' do
+      expect(record.match?(x: 'aa')).to be true
+      expect(record.match?(x: 'ab')).to be false
+    end
+
+    it 'matches by a set of values' do
+      expect(record.match?(x: 'aa', y: 123)).to be true
+      expect(record.match?(x: 'aa', y: 111)).to be false
+    end
+
+    it 'matches by a range of values' do
+      expect(record.match?(x: ['aa', 'bb'])).to be true
+      expect(record.match?(x: ['bb', 'cc'])).to be false
+    end
+  end
+end

data/spec/nested_record/collection_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+RSpec.describe NestedRecord::Collection do
+  nested_model(:Foo) do
+    attribute :id, :integer
+  end
+  nested_model(:Bar, :Foo)
+
+  let(:collection_class) { Foo.collection_class }
+  let(:collection) { collection_class.new }
+
+  describe '#<<' do
+    it 'adds records to the collection' do
+      expect { collection << Foo.new }.to change(collection, :empty?).from(true).to(false)
+      expect(collection.first).to be_an_instance_of(Foo)
+    end
+
+    it 'refuses to push arbitrary objects' do
+      expect { collection << :foo }.to raise_error(NestedRecord::TypeMismatchError)
+      expect { collection << nil }.to raise_error(NestedRecord::TypeMismatchError)
+    end
+
+    it 'allows to add a record of subtypes' do
+      expect { collection << Bar.new }.not_to raise_error
+    end
+  end
+end

data/spec/nested_record_spec.rb

@@ -0,0 +1,286 @@
+require 'spec_helper'
+
+RSpec.describe NestedRecord do
+  describe 'has_one_nested' do
+    nested_model(:Bar) do
+      attribute :x, :string
+      attribute :y, :integer
+      attribute :z, :boolean
+    end
+
+    active_model(:Foo) do
+      has_one_nested :bar
+    end
+
+    it 'defines a reader method' do
+      expect(Foo.new).to respond_to :bar
+    end
+
+    describe 'initialization' do
+      it 'allows to initialize with instance of a nested record class' do
+        foo = Foo.new(bar: Bar.new)
+        expect(foo.bar).to be_an_instance_of Bar
+      end
+
+      it 'preserves nested attributes' do
+        foo = Foo.new(bar: Bar.new(x: 'xx'))
+        expect(foo.bar.x).to eq 'xx'
+      end
+
+      it 'allows to initialize with a nil value' do
+        foo = Foo.new(bar: nil)
+        expect(foo.bar).to be nil
+      end
+
+      it 'does not allow to initialize with anything else' do
+        expect { Foo.new(bar: :baz) }.to raise_error NestedRecord::TypeMismatchError
+      end
+    end
+
+    describe 'writer' do
+      it 'is defined' do
+        foo = Foo.new
+        expect(foo).to respond_to(:bar=)
+      end
+
+      it 'allows to assign instance of a nested record class' do
+        foo = Foo.new
+        foo.bar = Bar.new
+        expect(foo.bar).to be_an_instance_of Bar
+      end
+
+      it 'preserves nested attributes' do
+        foo = Foo.new
+        foo.bar = Bar.new(x: 'xx')
+        expect(foo.bar.x).to eq 'xx'
+      end
+
+      it 'allows to assign a nil value' do
+        foo = Foo.new
+        foo.bar = nil
+        expect(foo.bar).to be nil
+      end
+
+      it 'does not allow to assign anything else' do
+        foo = Foo.new
+        expect { foo.bar = :baz }.to raise_error NestedRecord::TypeMismatchError
+      end
+    end
+
+    describe 'attributes writer' do
+      it 'is defined' do
+        foo = Foo.new
+        expect(foo).to respond_to(:bar_attributes=)
+      end
+
+      context 'when turned off' do
+        active_model(:Foo) do
+          has_one_nested :bar, attributes_writer: false
+        end
+
+        it 'is not defined' do
+          foo = Foo.new
+          expect(foo).not_to respond_to(:bar_attributes=)
+        end
+      end
+
+      it 'allows initialize with nested attributes' do
+        foo = Foo.new(bar_attributes: { x: 'xx', y: '123', z: '0' })
+        expect(foo.bar).to match an_object_having_attributes(x: 'xx', y: 123, z: false)
+      end
+
+      it 'allows to assign nested attributes' do
+        foo = Foo.new
+        foo.bar_attributes = { x: 'xx', y: '123', z: '0' }
+        expect(foo.bar).to match an_object_having_attributes(x: 'xx', y: 123, z: false)
+      end
+    end
+  end
+
+  describe 'has_many_nested' do
+    nested_model(:Bar) do
+      attribute :x, :string
+      attribute :y, :integer
+      attribute :z, :boolean
+    end
+
+    active_model(:Foo) do
+      has_many_nested :bars
+    end
+
+    it 'defines a reader method' do
+      expect(Foo.new).to respond_to :bars
+    end
+
+    describe 'when used with block' do
+      active_model(:Foo) do
+        has_many_nested :bars do
+          def filter_by_something; end
+        end
+      end
+
+      it 'adds extension method to the collection' do
+        expect(Foo.new.bars).to respond_to(:filter_by_something)
+      end
+    end
+
+    describe 'initialization' do
+      it 'allows to initialize with an array of instances of a nested record class' do
+        foo = Foo.new(bars: [Bar.new, Bar.new])
+        expect(foo.bars).to match [an_instance_of(Bar), an_instance_of(Bar)]
+      end
+
+      it 'preserves nested attributes' do
+        foo = Foo.new(bars: [Bar.new(x: 'xx'), Bar.new(x: 'yy')])
+        expect(foo.bars).to match [
+          an_object_having_attributes(x: 'xx'),
+          an_object_having_attributes(x: 'yy')
+        ]
+      end
+
+      it 'allows to initialize with an empty array' do
+        foo = Foo.new(bars: [])
+        expect(foo.bars).to be_empty
+      end
+    end
+
+    describe 'writer' do
+      it 'is defined' do
+        foo = Foo.new
+        expect(foo).to respond_to(:bars=)
+      end
+
+      it 'allows to assign instance of a nested record class' do
+        foo = Foo.new
+        foo.bars = [Bar.new, Bar.new]
+        expect(foo.bars).to match [
+          an_instance_of(Bar),
+          an_instance_of(Bar)
+        ]
+      end
+
+      it 'preserves nested attributes' do
+        foo = Foo.new
+        foo.bars = [Bar.new(x: 'xx'), Bar.new(x: 'yy')]
+        expect(foo.bars).to match [
+          an_object_having_attributes(x: 'xx'),
+          an_object_having_attributes(x: 'yy')
+        ]
+      end
+
+      it 'allows to assign an empty array' do
+        foo = Foo.new
+        foo.bars = []
+        expect(foo.bars).to be_empty
+      end
+    end
+
+    describe 'attributes writer' do
+      it 'is defined' do
+        foo = Foo.new
+        expect(foo).to respond_to(:bars_attributes=)
+      end
+
+      context 'when turned off' do
+        active_model(:Foo) do
+          has_many_nested :bars, attributes_writer: false
+        end
+
+        it 'is not defined' do
+          foo = Foo.new
+          expect(foo).not_to respond_to(:bars_attributes=)
+        end
+      end
+
+      it 'allows initialize with a collection of attributes' do
+        foo = Foo.new(bars_attributes: [{ x: 'xx' }, { x: 'yy' }])
+        expect(foo.bars).to match [
+          an_object_having_attributes(x: 'xx'),
+          an_object_having_attributes(x: 'yy')
+        ]
+      end
+
+      it 'allows to assign attributes' do
+        foo = Foo.new
+        foo.bars_attributes = [{ x: 'xx' }, { x: 'yy' }]
+        expect(foo.bars).to match [
+          an_object_having_attributes(x: 'xx'),
+          an_object_having_attributes(x: 'yy')
+        ]
+      end
+
+      it 'allows to use a rails form hash' do
+        foo = Foo.new(
+          bars_attributes: {
+            '0' => { 'x' => 'xx' },
+            '1' => { 'x' => 'yy' }
+          }
+        )
+        expect(foo.bars).to match [
+          an_object_having_attributes(x: 'xx'),
+          an_object_having_attributes(x: 'yy')
+        ]
+      end
+
+      context 'with :reject_if option' do
+        active_model(:Foo) do
+          has_many_nested :bars,
+                          attributes_writer: {
+                            reject_if: ->(attributes) { attributes['_destroy'].present? }
+                          }
+        end
+        nested_model(:Bar) do
+          attribute :id, :integer
+          attr_accessor :_destroy
+        end
+
+        it 'filters records' do
+          foo = Foo.new(
+            bars_attributes: [
+              { id: '1', _destroy: '' },
+              { id: '2', _destroy: '1' },
+              { id: '3', _destroy: '' },
+            ]
+          )
+          expect(foo.bars).to match [
+            an_object_having_attributes(id: 1),
+            an_object_having_attributes(id: 3)
+          ]
+        end
+      end
+    end
+  end
+
+  describe 'class_name resolution with namespaced models' do
+    active_model('A::B::Foo') do
+      has_one_nested :bar
+    end
+
+    context 'when nested model is defined in the model namespace' do
+      nested_model('A::B::Foo::Bar')
+
+      it 'locates the nested model' do
+        foo = A::B::Foo.new(bar_attributes: {})
+        expect(foo.bar).to be_an_instance_of(A::B::Foo::Bar)
+      end
+    end
+
+    context 'when nested model is defined in the common namespace' do
+      nested_model('A::B::Bar')
+
+      it 'locates the nested model' do
+        foo = A::B::Foo.new(bar_attributes: {})
+        expect(foo.bar).to be_an_instance_of(A::B::Bar)
+      end
+    end
+
+    context 'when nested model is defined in the upper namespace' do
+      nested_model('A::Bar')
+
+      it 'locates the nested model' do
+        foo = A::B::Foo.new(bar_attributes: {})
+        expect(foo.bar).to be_an_instance_of(A::Bar)
+      end
+    end
+  end
+end