granite-form 0.1.0

data/spec/lib/granite/form/model/lifecycle_spec.rb

@@ -0,0 +1,356 @@
+require 'spec_helper'
+
+describe Granite::Form::Model::Lifecycle do
+  context do
+    before do
+      stub_model(:user) do
+        include Granite::Form::Model::Lifecycle
+      end
+    end
+
+    subject { User.new }
+
+    %i[save create update destroy].each do |action|
+      specify { expect { subject.public_send "_#{action}_performer=", '' }.to raise_error NoMethodError }
+    end
+
+    context 'performer execution' do
+      let(:foo) { true }
+
+      specify { expect { subject.save { foo } }.to raise_error NameError }
+      specify { expect { subject.save { |_| attributes } }.to raise_error NameError }
+      specify { expect(subject.save { attributes }).to eq(true) }
+      specify { expect(subject.save { |_| foo }).to eq(true) }
+    end
+
+    context 'save' do
+      specify { expect { subject.save }.to raise_error Granite::Form::UnsavableObject }
+      specify { expect { subject.save! }.to raise_error Granite::Form::UnsavableObject }
+
+      specify { expect(subject.save { true }).to eq(true) }
+      specify { expect(subject.save! { true }).to eq(true) }
+
+      context 'instance performer' do
+        before { subject.define_save { false } }
+
+        specify { expect(subject.save).to eq(false) }
+        specify { expect { subject.save! }.to raise_error Granite::Form::ObjectNotSaved }
+      end
+
+      context 'create performer' do
+        before { User.define_create { true } }
+
+        specify { expect(subject.save).to eq(true) }
+        specify { expect(subject.save!).to eq(true) }
+
+        context do
+          subject { User.create }
+
+          specify { expect { subject.save }.to raise_error Granite::Form::UnsavableObject }
+          specify { expect { subject.save! }.to raise_error Granite::Form::UnsavableObject }
+        end
+
+        context 'instance performer' do
+          before { subject.define_create { false } }
+
+          specify { expect(subject.save).to eq(false) }
+          specify { expect { subject.save! }.to raise_error Granite::Form::ObjectNotSaved }
+        end
+      end
+
+      context 'update performer' do
+        before { User.define_update { true } }
+
+        specify { expect { subject.save }.to raise_error Granite::Form::UnsavableObject }
+        specify { expect { subject.save! }.to raise_error Granite::Form::UnsavableObject }
+
+        context do
+          subject { User.new.tap { |u| u.save { true } } }
+
+          specify { expect(subject.save).to eq(true) }
+          specify { expect(subject.save!).to eq(true) }
+
+          context 'instance performer' do
+            before { subject.define_update { false } }
+
+            specify { expect(subject.save).to eq(false) }
+            specify { expect { subject.save! }.to raise_error Granite::Form::ObjectNotSaved }
+          end
+        end
+      end
+
+      context 'performers execution' do
+        before do
+          stub_model(:user) do
+            include Granite::Form::Model::Lifecycle
+
+            attribute :actions, Array, default: []
+
+            def append(action)
+              self.actions = actions + [action]
+            end
+
+            define_create { append :create }
+            define_update { append :update }
+            define_destroy { append :destroy }
+          end
+        end
+
+        subject { User.new }
+
+        specify do
+          subject.destroy
+          subject.save
+          subject.save
+          subject.destroy
+          subject.destroy
+          subject.save
+          expect(subject.actions).to eq(%i[destroy create update destroy destroy create])
+        end
+      end
+    end
+
+    context 'destroy' do
+      specify { expect { subject.destroy }.to raise_error Granite::Form::UndestroyableObject }
+      specify { expect { subject.destroy! }.to raise_error Granite::Form::UndestroyableObject }
+
+      specify { expect(subject.destroy { true }).to be_a User }
+      specify { expect(subject.destroy! { true }).to be_a User }
+
+      context 'instance performer' do
+        before { subject.define_save { false } }
+
+        specify { expect(subject.save).to eq(false) }
+        specify { expect { subject.save! }.to raise_error Granite::Form::ObjectNotSaved }
+      end
+    end
+  end
+
+  context do
+    before do
+      stub_class(:storage) do
+        def self.storage
+          @storage ||= {}
+        end
+      end
+    end
+
+    before do
+      stub_model(:user) do
+        include Granite::Form::Model::Lifecycle
+        delegate :generate_id, to: 'self.class'
+
+        attribute :id, Integer, &:generate_id
+        attribute :name, String
+        validates :id, :name, presence: true
+
+        def self.generate_id
+          @id = @id.to_i.next
+        end
+
+        define_save do
+          Storage.storage.merge!(id => attributes.symbolize_keys)
+        end
+
+        define_destroy do
+          Storage.storage.delete(id)
+        end
+      end
+    end
+
+    describe '.create' do
+      subject { User.create(name: 'Jonny') }
+
+      it { is_expected.to be_a User }
+      it { is_expected.to be_valid }
+      it { is_expected.to be_persisted }
+
+      context 'invalid' do
+        subject { User.create }
+
+        it { is_expected.to be_a User }
+        it { is_expected.to be_invalid }
+        it { is_expected.not_to be_persisted }
+      end
+    end
+
+    describe '.create!' do
+      subject { User.create!(name: 'Jonny') }
+
+      it { is_expected.to be_a User }
+      it { is_expected.to be_valid }
+      it { is_expected.to be_persisted }
+
+      context 'invalid' do
+        subject { User.create! }
+
+        specify { expect { subject }.to raise_error Granite::Form::ValidationError }
+      end
+    end
+
+    describe '#update, #update!' do
+      subject { User.new }
+
+      specify { expect { subject.update(name: 'Jonny') }.to change { subject.persisted? }.from(false).to(true) }
+      specify { expect { subject.update!(name: 'Jonny') }.to change { subject.persisted? }.from(false).to(true) }
+
+      specify { expect { subject.update({}) }.not_to change { subject.persisted? } }
+      specify { expect { subject.update!({}) }.to raise_error Granite::Form::ValidationError }
+
+      specify do
+        expect { subject.update(name: 'Jonny') }
+          .to change { Storage.storage.keys }.from([]).to([subject.id])
+      end
+      specify do
+        expect { subject.update!(name: 'Jonny') }
+          .to change { Storage.storage.keys }.from([]).to([subject.id])
+      end
+    end
+
+    describe '#update_attributes, #update_attributes!' do
+      subject { User.new }
+
+      specify { expect { subject.update_attributes(name: 'Jonny') }.to change { subject.persisted? }.from(false).to(true) }
+      specify { expect { subject.update_attributes!(name: 'Jonny') }.to change { subject.persisted? }.from(false).to(true) }
+
+      specify { expect { subject.update_attributes({}) }.not_to change { subject.persisted? } }
+      specify { expect { subject.update_attributes!({}) }.to raise_error Granite::Form::ValidationError }
+
+      specify do
+        expect { subject.update_attributes(name: 'Jonny') }
+          .to change { Storage.storage.keys }.from([]).to([subject.id])
+      end
+      specify do
+        expect { subject.update_attributes!(name: 'Jonny') }
+          .to change { Storage.storage.keys }.from([]).to([subject.id])
+      end
+    end
+
+    describe '#save, #save!' do
+      context 'invalid' do
+        subject { User.new }
+
+        it { is_expected.to be_invalid }
+        it { is_expected.not_to be_persisted }
+
+        specify { expect(subject.save).to eq(false) }
+        specify { expect { subject.save! }.to raise_error Granite::Form::ValidationError }
+
+        specify { expect { subject.save }.not_to change { subject.persisted? } }
+        specify do
+          expect { muffle(Granite::Form::ValidationError) { subject.save! } }
+            .not_to change { subject.persisted? }
+        end
+      end
+
+      context 'create' do
+        subject { User.new(name: 'Jonny') }
+
+        it { is_expected.to be_valid }
+        it { is_expected.not_to be_persisted }
+
+        specify { expect(subject.save).to eq(true) }
+        specify { expect(subject.save!).to eq(true) }
+
+        specify { expect { subject.save }.to change { subject.persisted? }.from(false).to(true) }
+        specify { expect { subject.save! }.to change { subject.persisted? }.from(false).to(true) }
+
+        specify { expect { subject.save }.to change { Storage.storage.keys }.from([]).to([subject.id]) }
+        specify { expect { subject.save! }.to change { Storage.storage.keys }.from([]).to([subject.id]) }
+
+        context 'save failed' do
+          before { User.define_save { false } }
+
+          it { is_expected.not_to be_persisted }
+
+          specify { expect(subject.save).to eq(false) }
+          specify { expect { subject.save! }.to raise_error Granite::Form::ObjectNotSaved }
+
+          specify { expect { subject.save }.not_to change { subject.persisted? } }
+          specify do
+            expect { muffle(Granite::Form::ObjectNotSaved) { subject.save! } }
+              .not_to change { subject.persisted? }
+          end
+        end
+      end
+
+      context 'update' do
+        subject! { User.new(name: 'Jonny').tap(&:save).tap { |u| u.name = 'Jimmy' } }
+
+        it { is_expected.to be_valid }
+        it { is_expected.to be_persisted }
+
+        specify { expect(subject.save).to eq(true) }
+        specify { expect(subject.save!).to eq(true) }
+
+        specify { expect { subject.save }.not_to change { subject.persisted? } }
+        specify { expect { subject.save! }.not_to change { subject.persisted? } }
+
+        specify do
+          expect { subject.save }.to change { Storage.storage[subject.id] }
+            .from(hash_including(name: 'Jonny')).to(hash_including(name: 'Jimmy'))
+        end
+        specify do
+          expect { subject.save! }.to change { Storage.storage[subject.id] }
+            .from(hash_including(name: 'Jonny')).to(hash_including(name: 'Jimmy'))
+        end
+
+        context 'save failed' do
+          before { User.define_save { false } }
+
+          it { is_expected.to be_persisted }
+
+          specify { expect(subject.save).to eq(false) }
+          specify { expect { subject.save! }.to raise_error Granite::Form::ObjectNotSaved }
+
+          specify { expect { subject.save }.not_to change { subject.persisted? } }
+          specify do
+            expect { muffle(Granite::Form::ObjectNotSaved) { subject.save! } }
+              .not_to change { subject.persisted? }
+          end
+        end
+      end
+    end
+
+    describe '#destroy, #destroy!' do
+      subject { User.create(name: 'Jonny') }
+
+      it { is_expected.to be_valid }
+      it { is_expected.to be_persisted }
+      it { is_expected.not_to be_destroyed }
+
+      specify { expect(subject.destroy).to eq(subject) }
+      specify { expect(subject.destroy!).to eq(subject) }
+
+      specify { expect { subject.destroy }.to change { subject.persisted? }.from(true).to(false) }
+      specify { expect { subject.destroy! }.to change { subject.persisted? }.from(true).to(false) }
+
+      specify { expect { subject.destroy }.to change { subject.destroyed? }.from(false).to(true) }
+      specify { expect { subject.destroy! }.to change { subject.destroyed? }.from(false).to(true) }
+
+      specify { expect { subject.destroy }.to change { Storage.storage.keys }.from([subject.id]).to([]) }
+      specify { expect { subject.destroy! }.to change { Storage.storage.keys }.from([subject.id]).to([]) }
+
+      context 'save failed' do
+        before { User.define_destroy { false } }
+
+        it { is_expected.to be_persisted }
+
+        specify { expect(subject.destroy).to eq(subject) }
+        specify { expect { subject.destroy! }.to raise_error Granite::Form::ObjectNotDestroyed }
+
+        specify { expect { subject.destroy }.not_to change { subject.persisted? } }
+        specify do
+          expect { muffle(Granite::Form::ObjectNotDestroyed) { subject.destroy! } }
+            .not_to change { subject.persisted? }
+        end
+
+        specify { expect { subject.destroy }.not_to change { subject.destroyed? } }
+        specify do
+          expect { muffle(Granite::Form::ObjectNotDestroyed) { subject.destroy! } }
+            .not_to change { subject.destroyed? }
+        end
+      end
+    end
+  end
+end

data/spec/lib/granite/form/model/persistence_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Granite::Form::Model::Persistence do
+  let(:model) do
+    stub_model do
+      include Granite::Form::Model::Persistence
+
+      attribute :name
+      attribute :count, default: 0
+    end
+  end
+
+  specify { expect(model.new).not_to be_persisted }
+  specify { expect(model.new).not_to be_destroyed }
+
+  describe '#instantiate' do
+    specify { expect(model.instantiate({})).to be_an_instance_of model }
+    specify { expect(model.instantiate({})).to be_persisted }
+    specify { expect(model.instantiate({})).not_to be_destroyed }
+
+    context do
+      subject(:instance) { model.instantiate(name: 'Hello', foo: 'Bar') }
+
+      specify { expect(subject.instance_variable_get(:@initial_attributes)).to eq({name: 'Hello'}.stringify_keys) }
+    end
+  end
+
+  describe '#instantiate_collection' do
+    context do
+      subject(:instances) { model.instantiate_collection(name: 'Hello', foo: 'Bar') }
+
+      specify { expect(subject).to be_a Array }
+      specify { expect(subject.first.instance_variable_get(:@initial_attributes)).to eq({name: 'Hello'}.stringify_keys) }
+    end
+
+    context do
+      before { model.send(:include, Granite::Form::Model::Scopes) }
+      subject(:instances) { model.instantiate_collection([{name: 'Hello', foo: 'Bar'}, {name: 'World'}]) }
+
+      specify { expect(subject).to be_a Granite::Form::Model::Scopes::ScopeProxy }
+      specify { expect(subject.count).to eq(2) }
+      specify { expect(subject.first.instance_variable_get(:@initial_attributes)).to eq({name: 'Hello'}.stringify_keys) }
+      specify { expect(subject.second.instance_variable_get(:@initial_attributes)).to eq({name: 'World'}.stringify_keys) }
+    end
+  end
+end

data/spec/lib/granite/form/model/primary_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Granite::Form::Model::Primary do
+  context 'undefined' do
+    let(:model) do
+      stub_model do
+        include Granite::Form::Model::Primary
+
+        attribute :name, String
+      end
+    end
+
+    specify { expect(model.has_primary_attribute?).to eq(false) }
+    specify { expect(model.new.has_primary_attribute?).to eq(false) }
+    specify { expect { model.new.primary_attribute }.to raise_error NoMethodError }
+    specify { expect(model.new(name: 'Hello')).to eq(model.new(name: 'Hello')) }
+    specify { expect(model.new(name: 'Hello')).to eql(model.new(name: 'Hello')) }
+
+    context do
+      let(:object) { model.new(name: 'Hello') }
+      specify { expect(object).not_to eq(object.clone.tap { |o| o.update(name: 'World') }) }
+      specify { expect(object).not_to eql(object.clone.tap { |o| o.update(name: 'World') }) }
+    end
+  end
+
+  context 'defined' do
+    let(:model) do
+      stub_model do
+        include Granite::Form::Model::Primary
+
+        primary_attribute
+        attribute :name, String
+      end
+    end
+
+    specify { expect(model.has_primary_attribute?).to eq(true) }
+    specify { expect(model.new.has_primary_attribute?).to eq(true) }
+    specify { expect(model.new.primary_attribute).to be_a(Granite::Form::UUID) }
+    specify { expect(model.new(name: 'Hello')).not_to eq(model.new(name: 'Hello')) }
+    specify { expect(model.new(name: 'Hello')).not_to eql(model.new(name: 'Hello')) }
+    specify { expect(model.new(id: 0).id).not_to eq(Granite::Form::UUID.parse_int(0)) }
+    specify { expect(model.new.tap { |o| o.id = 0 }.id).to eq(Granite::Form::UUID.parse_int(0)) }
+
+    context do
+      let(:object) { model.new(name: 'Hello') }
+      specify { expect(object).to eq(object.clone.tap { |o| o.update(name: 'World') }) }
+      specify { expect(object).to eql(object.clone.tap { |o| o.update(name: 'World') }) }
+    end
+  end
+
+  context 'defined' do
+    let(:model) do
+      stub_model do
+        include Granite::Form::Model::Primary
+
+        primary_attribute type: Integer
+        attribute :name
+      end
+    end
+
+    specify { expect(model.has_primary_attribute?).to eq(true) }
+    specify { expect(model.new.has_primary_attribute?).to eq(true) }
+    specify { expect(model.new.primary_attribute).to be_nil }
+    specify { expect(model.new(name: 'Hello')).not_to eq(model.new(name: 'Hello')) }
+    specify { expect(model.new(name: 'Hello')).not_to eql(model.new(name: 'Hello')) }
+    specify { expect(model.new(name: 'Hello').tap { |o| o.id = 1 }).not_to eq(model.new(name: 'Hello').tap { |o| o.id = 2 }) }
+    specify { expect(model.new(name: 'Hello').tap { |o| o.id = 1 }).not_to eql(model.new(name: 'Hello').tap { |o| o.id = 2 }) }
+    specify { expect(model.new(id: 1).id).to be_nil }
+    specify { expect(model.new.tap { |o| o.assign_attributes(id: 1) }.id).to be_nil }
+    specify { expect(model.new.tap { |o| o.id = 1 }.id).to eq(1) }
+
+    context do
+      let(:object) { model.new(name: 'Hello').tap { |o| o.id = 1 } }
+      specify { expect(object).to eq(object.clone.tap { |o| o.update(name: 'World') }) }
+      specify { expect(object).to eql(object.clone.tap { |o| o.update(name: 'World') }) }
+    end
+
+    context do
+      let(:object) { model.new(name: 'Hello') }
+      specify { expect(object).to eq(object) }
+      specify { expect(object).to eql(object) }
+    end
+  end
+end

data/spec/lib/granite/form/model/representation_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+describe Granite::Form::Model::Representation do
+  context 'integration' do
+    before do
+      stub_model(:author) do
+        attribute :rate, Integer
+      end
+
+      stub_model(:post) do
+        include Granite::Form::Model::Representation
+
+        attribute :author, Object
+        alias_attribute :a, :author
+        represents :rate, of: :a
+        alias_attribute :r, :rate
+      end
+    end
+    let(:author) { Author.new(rate: '42') }
+
+    specify { expect(Post.reflect_on_attribute(:rate).reference).to eq('author') }
+
+    specify { expect(Post.new(author: author).rate).to eq(42) }
+    specify { expect(Post.new(author: author).rate_before_type_cast).to eq('42') }
+    specify { expect(Post.new(rate: '33', author: author).rate).to eq(33) }
+    specify { expect(Post.new(rate: '33', author: author).author.rate).to eq(33) }
+    specify { expect(Post.new(r: '33', author: author).rate).to eq(33) }
+    specify { expect(Post.new(r: '33', author: author).author.rate).to eq(33) }
+    specify { expect(Post.new(author: author).rate?).to eq(true) }
+    specify { expect(Post.new(rate: nil, author: author).rate?).to eq(false) }
+
+    specify { expect(Post.new.rate).to be_nil }
+    specify { expect(Post.new.rate_before_type_cast).to be_nil }
+    specify { expect { Post.new(rate: '33') }.to raise_error(NoMethodError) }
+
+    context 'ActionController::Parameters' do
+      let(:params) { instance_double('ActionController::Parameters', to_unsafe_hash: {rate: '33', author: author}) }
+      specify { expect { Post.new(params) }.not_to raise_error }
+    end
+
+    context 'dirty' do
+      before do
+        Author.include Granite::Form::Model::Dirty
+        Post.include Granite::Form::Model::Dirty
+      end
+
+      specify do
+        expect(Post.new(author: author, rate: '33').changes)
+          .to eq('author' => [nil, author], 'rate' => [42, 33])
+
+        expect(Post.new(author: author, rate: '33').changes)
+          .to eq('author' => [nil, author])
+      end
+    end
+
+    context do
+      before do
+        stub_class(:author, ActiveRecord::Base)
+
+        stub_model(:post) do
+          include Granite::Form::Model::Associations
+          include Granite::Form::Model::Representation
+
+          references_one :author
+          alias_association :a, :author
+          represents :name, of: :a
+        end
+      end
+      let!(:author) { Author.create!(name: 42) }
+
+      specify { expect(Post.reflect_on_attribute(:name).reference).to eq('author') }
+
+      specify { expect(Post.new(name: '33', author: author).name).to eq('33') }
+      specify { expect(Post.new(name: '33', author: author).author.name).to eq('33') }
+    end
+
+    context 'multiple attributes in a single represents definition' do
+      before do
+        stub_model(:author) do
+          attribute :first_name, String
+          attribute :last_name, String
+        end
+
+        stub_model(:post) do
+          include Granite::Form::Model::Representation
+
+          attribute :author, Object
+          represents :first_name, :last_name, of: :author
+        end
+      end
+
+      let(:author) { Author.new(first_name: 'John', last_name: 'Doe') }
+      let(:post) { Post.new }
+
+      specify do
+        expect { post.update(author: author) }
+          .to change { post.first_name }.to('John')
+          .and change { post.last_name }.to('Doe')
+      end
+    end
+  end
+
+  describe '#validate' do
+    before do
+      stub_class(:author, ActiveRecord::Base) do
+        validates :name, presence: true
+
+        # Emulate Active Record association auto save error.
+        def errors
+          super.tap do |errors|
+            errors.add(:'user.email', 'is invalid') if errors[:'user.email'].empty?
+          end
+        end
+      end
+
+      stub_model(:post) do
+        include Granite::Form::Model::Associations
+        include Granite::Form::Model::Representation
+
+        references_one :author
+        represents :name, :email, of: :author
+      end
+    end
+
+    let(:post) { Post.new(author: Author.new) }
+
+    specify do
+      expect { post.validate }.to change { post.errors.messages }
+        .to(hash_including('author.user.email': ['is invalid'], name: ["can't be blank"]))
+    end
+
+    if ActiveModel.version >= Gem::Version.new('6.1.0')
+      specify do
+        expect { post.validate }.to change { post.errors.details }
+          .to(hash_including('author.user.email': [{error: 'is invalid'}], name: [{error: :blank}]))
+      end
+    end
+  end
+end