granite-form 0.2.0 → 0.3.0

data/spec/granite/form/model/callbacks_spec.rb

@@ -1,337 +0,0 @@
-require 'spec_helper'
-
-describe Granite::Form::Model::Callbacks do
-  before do
-    stub_model(:user) do
-      include Granite::Form::Model::Callbacks
-      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
-
-  describe '.after_initialize' do
-    before do
-      User.after_initialize { append :after_initialize }
-    end
-
-    specify { expect(User.new.actions).to eq([:after_initialize]) }
-    specify { expect(User.create.actions).to eq(%i[after_initialize create]) }
-  end
-
-  describe '.before_save, .after_save' do
-    before do
-      User.before_save { append :before_save }
-      User.after_save { append :after_save }
-    end
-
-    specify { expect(User.create.actions).to eq(%i[before_save create after_save]) }
-    specify { expect(User.new.tap(&:save).actions).to eq(%i[before_save create after_save]) }
-    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq(%i[before_save create after_save]) }
-    specify { expect(User.create.tap(&:save).actions).to eq(%i[before_save create after_save before_save update after_save]) }
-    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq(%i[before_save create after_save before_save update after_save]) }
-
-    specify { expect(User.new.tap { |u| u.save { false } }.actions).to eq([:before_save]) }
-    specify { expect(User.create.tap { |u| u.save { false } }.actions).to eq(%i[before_save create after_save before_save]) }
-  end
-
-  describe '.around_save' do
-    before do
-      User.around_save do |_, block|
-        append :before_around_save
-        block.call
-        append :after_around_save
-      end
-    end
-
-    specify { expect(User.create.actions).to eq(%i[before_around_save create after_around_save]) }
-    specify { expect(User.new.tap(&:save).actions).to eq(%i[before_around_save create after_around_save]) }
-    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq(%i[before_around_save create after_around_save]) }
-    specify { expect(User.create.tap(&:save).actions).to eq(%i[before_around_save create after_around_save before_around_save update after_around_save]) }
-    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq(%i[before_around_save create after_around_save before_around_save update after_around_save]) }
-
-    specify { expect(User.new.tap { |u| u.save { false } }.actions).to eq(%i[before_around_save after_around_save]) }
-    specify { expect(User.create.tap { |u| u.save { false } }.actions).to eq(%i[before_around_save create after_around_save before_around_save after_around_save]) }
-  end
-
-  describe '.before_create, .after_create' do
-    before do
-      User.before_create { append :before_create }
-      User.after_create { append :after_create }
-    end
-
-    specify { expect(User.create.actions).to eq(%i[before_create create after_create]) }
-    specify { expect(User.new.tap(&:save).actions).to eq(%i[before_create create after_create]) }
-    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq(%i[before_create create after_create]) }
-    specify { expect(User.create.tap(&:save).actions).to eq(%i[before_create create after_create update]) }
-    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq(%i[before_create create after_create update]) }
-
-    specify { expect(User.new.tap { |u| u.save { false } }.actions).to eq([:before_create]) }
-  end
-
-  describe '.around_create' do
-    before do
-      User.around_create do |_, block|
-        append :before_around_create
-        block.call
-        append :after_around_create
-      end
-    end
-
-    specify { expect(User.create.actions).to eq(%i[before_around_create create after_around_create]) }
-    specify { expect(User.new.tap(&:save).actions).to eq(%i[before_around_create create after_around_create]) }
-    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq(%i[before_around_create create after_around_create]) }
-    specify { expect(User.create.tap(&:save).actions).to eq(%i[before_around_create create after_around_create update]) }
-    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq(%i[before_around_create create after_around_create update]) }
-
-    specify { expect(User.new.tap { |u| u.save { false } }.actions).to eq(%i[before_around_create after_around_create]) }
-  end
-
-  describe '.before_update, .after_update' do
-    before do
-      User.before_update { append :before_update }
-      User.after_update { append :after_update }
-    end
-
-    specify { expect(User.create.actions).to eq([:create]) }
-    specify { expect(User.new.tap(&:save).actions).to eq([:create]) }
-    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq([:create]) }
-    specify { expect(User.create.tap(&:save).actions).to eq(%i[create before_update update after_update]) }
-    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq(%i[create before_update update after_update]) }
-
-    specify { expect(User.create.tap { |u| u.save { false } }.actions).to eq(%i[create before_update]) }
-  end
-
-  describe '.around_update' do
-    before do
-      User.around_update do |_, block|
-        append :before_around_update
-        block.call
-        append :after_around_update
-      end
-    end
-
-    specify { expect(User.create.actions).to eq([:create]) }
-    specify { expect(User.new.tap(&:save).actions).to eq([:create]) }
-    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq([:create]) }
-    specify { expect(User.create.tap(&:save).actions).to eq(%i[create before_around_update update after_around_update]) }
-    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq(%i[create before_around_update update after_around_update]) }
-
-    specify { expect(User.create.tap { |u| u.save { false } }.actions).to eq(%i[create before_around_update after_around_update]) }
-  end
-
-  describe '.before_validation, .after_validation,
-            .before_save, .after_save, .around_save,
-            .before_create, .after_create, .around_create,
-            .before_update, .after_update, .around_update
-            .before_destroy, .after_destroy, .around_destroy' do
-    before do
-      User.before_validation { append :before_validation }
-      User.after_validation { append :after_validation }
-
-      User.before_save { append :before_save }
-      User.after_save { append :after_save }
-      User.around_save do |_, block|
-        append :before_around_save
-        block.call
-        append :after_around_save
-      end
-
-      User.before_create { append :before_create }
-      User.after_create { append :after_create }
-      User.around_create do |_, block|
-        append :before_around_create
-        block.call
-        append :after_around_create
-      end
-
-      User.before_update { append :before_update }
-      User.after_update { append :after_update }
-      User.around_update do |_, block|
-        append :before_around_update
-        block.call
-        append :after_around_update
-      end
-
-      User.before_destroy { append :before_destroy }
-      User.after_destroy { append :after_destroy }
-      User.around_destroy do |_, block|
-        append :before_around_destroy
-        block.call
-        append :after_around_destroy
-      end
-    end
-
-    specify do
-      expect(User.create.tap(&:save).destroy.actions).to eq(%i[
-        before_validation after_validation
-        before_save before_around_save
-        before_create before_around_create
-        create
-        after_around_create after_create
-        after_around_save after_save
-        before_validation after_validation
-        before_save before_around_save
-        before_update before_around_update
-        update
-        after_around_update after_update
-        after_around_save after_save
-        before_destroy before_around_destroy
-        destroy
-        after_around_destroy after_destroy
-      ])
-    end
-  end
-
-  describe '.before_destroy, .after_destroy' do
-    before do
-      User.before_destroy { append :before_destroy }
-      User.after_destroy { append :after_destroy }
-    end
-
-    specify { expect(User.new.destroy.actions).to eq(%i[before_destroy destroy after_destroy]) }
-    specify { expect(User.create.destroy.actions).to eq(%i[create before_destroy destroy after_destroy]) }
-
-    specify { expect(User.new.destroy { false }.actions).to eq([:before_destroy]) }
-    specify { expect(User.create.destroy { false }.actions).to eq(%i[create before_destroy]) }
-  end
-
-  describe '.around_destroy' do
-    before do
-      User.around_destroy do |_, block|
-        append :before_around_destroy
-        block.call
-        append :after_around_destroy
-      end
-    end
-
-    specify { expect(User.new.destroy.actions).to eq(%i[before_around_destroy destroy after_around_destroy]) }
-    specify { expect(User.create.destroy.actions).to eq(%i[create before_around_destroy destroy after_around_destroy]) }
-
-    specify { expect(User.new.destroy { false }.actions).to eq(%i[before_around_destroy after_around_destroy]) }
-    specify { expect(User.create.destroy { false }.actions).to eq(%i[create before_around_destroy after_around_destroy]) }
-  end
-
-  context 'unsavable, undestroyable' do
-    before do
-      stub_model(:user) do
-        include Granite::Form::Model::Callbacks
-
-        attribute :actions, Array, default: []
-        attribute :validated, Boolean, default: false
-
-        validates :validated, presence: true
-
-        def append(action)
-          self.actions = actions + [action]
-        end
-      end
-    end
-
-    before do
-      User.before_validation { append :before_validation }
-      User.after_validation { append :after_validation }
-
-      User.before_save { append :before_save }
-      User.after_save { append :after_save }
-      User.around_save do |&block|
-        append :before_around_save
-        block.call
-        append :after_around_save
-      end
-
-      User.before_create { append :before_create }
-      User.after_create { append :after_create }
-      User.around_create do |&block|
-        append :before_around_create
-        block.call
-        append :after_around_create
-      end
-
-      User.before_update { append :before_update }
-      User.after_update { append :after_update }
-      User.around_update do |&block|
-        append :before_around_update
-        block.call
-        append :after_around_update
-      end
-
-      User.before_destroy { append :before_destroy }
-      User.after_destroy { append :after_destroy }
-      User.around_destroy do |&block|
-        append :before_around_destroy
-        block.call
-        append :after_around_destroy
-      end
-    end
-
-    let(:user) { User.new }
-
-    specify do
-      begin
-        user.save
-      rescue Granite::Form::UnsavableObject
-        expect(user.actions).to eq([])
-      end
-    end
-
-    specify do
-      begin
-        user.save!
-      rescue Granite::Form::UnsavableObject
-        expect(user.actions).to eq([])
-      end
-    end
-
-    specify do
-      user.save { true }
-      expect(user.actions).to eq(%i[before_validation after_validation])
-    end
-
-    specify do
-      begin
-        user.save! { true }
-      rescue Granite::Form::ValidationError
-        expect(user.actions).to eq(%i[before_validation after_validation])
-      end
-    end
-
-    specify do
-      begin
-        user.update({})
-      rescue Granite::Form::UnsavableObject
-        expect(user.actions).to eq([])
-      end
-    end
-
-    specify do
-      begin
-        user.update!({})
-      rescue Granite::Form::UnsavableObject
-        expect(user.actions).to eq([])
-      end
-    end
-
-    specify do
-      begin
-        user.destroy
-      rescue Granite::Form::UndestroyableObject
-        expect(user.actions).to eq([])
-      end
-    end
-
-    specify do
-      begin
-        user.destroy!
-      rescue Granite::Form::UndestroyableObject
-        expect(user.actions).to eq([])
-      end
-    end
-  end
-end

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

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