granite-form 0.1.0

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

@@ -0,0 +1,337 @@
+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/lib/granite/form/model/conventions_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Granite::Form::Model::Conventions do
+  let(:model) { stub_model }
+
+  specify { expect([model].flatten).to eq([model]) }
+  specify { expect(model.i18n_scope).to eq(:granite) }
+  specify { expect(model.new).not_to be_persisted }
+  specify { expect(model.new).to be_new_record }
+  specify { expect(model.new).to be_new_object }
+end

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

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Granite::Form::Model::Dirty do
+  before do
+    stub_class(:author, ActiveRecord::Base) {}
+    stub_model :premodel do
+      include Granite::Form::Model::Persistence
+      include Granite::Form::Model::Localization
+      include Granite::Form::Model::Associations
+
+      attribute :age, Integer, default: 33
+      alias_attribute :a, :age
+    end
+    stub_model :model, Premodel do
+      include Granite::Form::Model::Dirty
+
+      references_one :author
+      references_many :authors
+      embeds_one :something do
+        attribute :value, String
+      end
+      attribute :name, String
+      alias_attribute :n, :name
+      collection :numbers, Integer
+      localized :title, String
+    end
+  end
+
+  let(:author) { Author.create!(name: 'Name') }
+  let(:other_author) { Author.create!(name: 'Other') }
+
+  specify { expect(Model.new.changes).to eq({}) }
+  specify { expect(Model.new.tap { |m| m.create_something(value: 'Value') }.changes).to eq({}) }
+
+  specify { expect(Model.new(author: author).changes).to eq('author_id' => [nil, author.id]) }
+  specify { expect(Model.new(author_id: author.id).changes).to eq('author_id' => [nil, author.id]) }
+  specify { expect(Model.new(authors: [author]).changes).to eq('author_ids' => [[], [author.id]]) }
+  specify { expect(Model.new(author_ids: [author.id]).changes).to eq('author_ids' => [[], [author.id]]) }
+
+  specify do
+    expect(Model.new(author: author, name: 'Name2').changes)
+      .to eq('author_id' => [nil, author.id], 'name' => [nil, 'Name2'])
+  end
+
+  specify do
+    expect(Model.instantiate(author_id: other_author.id)
+    .tap { |m| m.update(author_id: author.id) }.changes)
+      .to eq('author_id' => [other_author.id, author.id])
+  end
+  specify do
+    expect(Model.instantiate(author_id: other_author.id)
+    .tap { |m| m.update(author: author) }.changes)
+      .to eq('author_id' => [other_author.id, author.id])
+  end
+  specify do
+    expect(Model.instantiate(author_ids: [other_author.id])
+    .tap { |m| m.update(author_ids: [author.id]) }.changes)
+      .to eq('author_ids' => [[other_author.id], [author.id]])
+  end
+  specify do
+    expect(Model.instantiate(author_ids: [other_author.id])
+    .tap { |m| m.update(authors: [author]) }.changes)
+      .to eq('author_ids' => [[other_author.id], [author.id]])
+  end
+
+  specify { expect(Model.new(a: 'blabla').changes).to eq('age' => [33, nil]) }
+  specify { expect(Model.new(a: '42').changes).to eq('age' => [33, 42]) }
+  specify { expect(Model.instantiate(age: '42').changes).to eq({}) }
+  specify { expect(Model.instantiate(age: '42').tap { |m| m.update(a: '43') }.changes).to eq('age' => [42, 43]) }
+  specify { expect(Model.new(a: '42').tap { |m| m.update(a: '43') }.changes).to eq('age' => [33, 43]) }
+  specify { expect(Model.new(numbers: '42').changes).to eq('numbers' => [[], [42]]) }
+
+  # Have no idea how should it work right now
+  specify { expect(Model.new(title: 'Hello').changes).to eq('title' => [nil, 'Hello']) }
+  specify { expect(Model.new(title_translations: {en: 'Hello'}).changes).to eq('title' => [nil, 'Hello']) }
+
+  specify { expect(Model.new).not_to respond_to :something_changed? }
+  specify { expect(Model.new).to respond_to :n_changed? }
+
+  specify { expect(Model.new(a: '42')).to be_age_changed }
+  specify { expect(Model.new(a: '42')).to be_a_changed }
+  specify { expect(Model.new(a: '42').age_change).to eq([33, 42]) }
+  specify { expect(Model.new(a: '42').a_change).to eq([33, 42]) }
+end