acts-as-approvable 0.6.7 → 0.6.8.1

data/lib/acts_as_approvable/model/update_instance_methods.rb

@@ -0,0 +1,61 @@
+module ActsAsApprovable
+  module Model
+    ##
+    # Instance methods that apply to the :update event specifically.
+    module UpdateInstanceMethods
+      ##
+      # Retrieve all approval records for `:update` events.
+      def update_approvals(all = true)
+        all ? approvals.find_all_by_event('update') : approvals.find_all_by_event_and_state('update', 0)
+      end
+
+      ##
+      # Returns true if the record has any `#update_approvals` that are pending
+      # approval.
+      def pending_changes?
+        !update_approvals(false).empty?
+      end
+
+      ##
+      # Returns true if any notable (eg. not ignored) fields have been changed.
+      def changed_notably?
+        notably_changed.any?
+      end
+
+      ##
+      # Returns an array of any notable (eg. not ignored) fields that have not
+      # been changed.
+      #
+      # @return [Array] a list of changed fields.
+      def notably_changed
+        approvable_fields.select { |field| changed.include?(field) }
+      end
+
+      ##
+      # Returns a list of fields that require approval.
+      def approvable_fields
+        self.class.approvable_fields
+      end
+
+      private
+      def approvable_update?
+        approvals_enabled? and approvable_on?(:update) and changed_notably?
+      end
+
+      def approvable_update
+        changed = {}
+        originals = {}
+
+        notably_changed.each do |attr|
+          original, changed_to = changes[attr]
+
+          write_attribute(attr.to_s, original)
+          changed[attr] = changed_to
+          originals[attr] = original
+        end
+
+        @approval = approvals.build(:event => 'update', :state => 'pending', :object => changed, :original => originals)
+      end
+    end
+  end
+end

data/lib/acts_as_approvable/railtie.rb

@@ -1,7 +1,7 @@
 module ActsAsApprovable
   class Railtie < Rails::Railtie
     initializer 'acts_as_approvable.configure_rails_initialization' do |app|
-      ActiveRecord::Base.send :include, ActsAsApprovable::Model
+      ActiveRecord::Base.send :extend, ActsAsApprovable::Model
     end
   end
 end

data/lib/generators/acts_as_approvable/templates/create_approvals.rb

@@ -1,13 +1,14 @@
 class CreateApprovals < ActiveRecord::Migration
   def self.up
     create_table :approvals do |t|
-      t.string   :item_type, :null => false
-      t.integer  :item_id,   :null => false
-      t.string   :event,     :null => false
-      t.integer  :state,     :null => false, :default => 0
-<% if options[:owner] %>      t.integer  :owner_id
-<% end %>      t.text     :object
-      t.text     :reason
+      t.string  :item_type, :null => false
+      t.integer :item_id,   :null => false
+      t.string  :event,     :null => false
+      t.integer :state,     :null => false, :default => 0
+<% if options[:owner] %>      t.integer :owner_id
+<% end %>      t.text    :object,    :limit => 16777216
+      t.text    :original,  :limit => 16777216
+      t.text    :reason
 
       t.timestamps
     end

data/spec/acts_as_approvable/approval_spec.rb

@@ -0,0 +1,475 @@
+require 'spec_helper'
+
+describe Approval do
+  before(:each) do
+    subject.stub(:save! => true, :save => true)
+  end
+
+  it 'should serialize :object' do
+    described_class.serialized_attributes.keys.should include('object')
+  end
+
+  describe '.associations' do
+    it { should belong_to(:item) }
+  end
+
+  describe '.validates' do
+    it { should validate_presence_of(:item) }
+    it { should validate_inclusion_of(:event).in(%w(create update)) }
+    it { should validate_numericality_of(:state) }
+    it { should ensure_inclusion_of(:state).in_range(0..(described_class::STATES.length - 1)).with_low_message(/greater than/).with_high_message(/less than/)}
+  end
+
+  describe '.enumerate_state' do
+    it 'enumerates "pending" to 0' do
+      described_class.enumerate_state('pending').should be(0)
+    end
+
+    it 'enumerates "approved" to 1' do
+      described_class.enumerate_state('approved').should be(1)
+    end
+
+    it 'enumerates "rejected" to 2' do
+      described_class.enumerate_state('rejected').should be(2)
+    end
+
+    it 'enumerates other values to nil' do
+      described_class.enumerate_state('not_a_state').should_not be
+    end
+  end
+
+  describe '.enumerate_states' do
+    it 'enumerates many states at once' do
+      described_class.enumerate_states('pending', 'approved', 'rejected').should == [0, 1, 2]
+    end
+
+    it 'ignores states it does not know' do
+      described_class.enumerate_states('pending', 'not_a_state', 'rejected').should == [0, 2]
+    end
+  end
+
+  describe '.options_for_state' do
+    it 'returns an array usable by #options_for_select' do
+      described_class.options_for_state.should be_an_options_array
+    end
+
+    it 'includes an "all" option' do
+      described_class.options_for_state.should include(['All', -1])
+    end
+
+    it 'includes the pending state' do
+      described_class.options_for_state.should include(['Pending', 0])
+    end
+
+    it 'includes the approved state' do
+      described_class.options_for_state.should include(['Approved', 1])
+    end
+
+    it 'includes the rejected state' do
+      described_class.options_for_state.should include(['Rejected', 2])
+    end
+  end
+
+  describe '.options_for_type' do
+    before(:each) do
+      @default = DefaultApprovable.create
+      @creates = CreatesApprovable.create
+      @updates = UpdatesApprovable.create
+    end
+
+    it 'returns an array usable by #options_for_select' do
+      described_class.options_for_type.should be_an_options_array
+    end
+
+    it 'includes all types with approvals' do
+      described_class.options_for_type.should include('DefaultApprovable')
+      described_class.options_for_type.should include('CreatesApprovable')
+    end
+
+    it 'does not include types without approvals' do
+      described_class.options_for_type.should_not include('UpdatesApprovable')
+    end
+
+    it 'includes a prompt if requested' do
+      described_class.options_for_type(true).should include(['All Types', nil])
+    end
+
+    it 'does not includes a prompt by default' do
+      described_class.options_for_type.should_not include(['All Types', nil])
+    end
+  end
+
+  describe '#state' do
+    it 'returns the state as a string' do
+      subject.state.should be_a(String)
+    end
+
+    it 'attempts to read the state attribute' do
+      subject.should_receive(:read_attribute).with(:state)
+      subject.state
+    end
+  end
+
+  describe '#state_was' do
+    it 'returns the state as a string' do
+      subject.state_was.should be_a(String)
+    end
+
+    it 'attempts to read the changed state attribute' do
+      subject.should_receive(:changed_attributes).and_return({:state => 1})
+      subject.state_was.should == 'approved'
+    end
+  end
+
+  describe '#state=' do
+    it 'writes the attribute value' do
+      subject.should_receive(:write_attribute)
+      subject.send(:state=, 'pending')
+    end
+
+    it 'enumerates the given state' do
+      subject.should_receive(:write_attribute).with(:state, 0)
+      subject.send(:state=, 'pending')
+    end
+
+    it 'skips enumeration for numeric values' do
+      subject.should_receive(:write_attribute).with(:state, 10)
+      subject.send(:state=, 10)
+    end
+  end
+
+  context 'when the state is pending' do
+    before(:each) do
+      subject.stub(:state => 'pending')
+    end
+
+    it { should be_pending }
+    it { should_not be_approved }
+    it { should_not be_rejected }
+    it { should_not be_locked }
+    it { should be_unlocked }
+  end
+
+  context 'when the state is approved' do
+    before(:each) do
+      subject.stub(:state => 'approved')
+    end
+
+    it { should_not be_pending }
+    it { should be_approved }
+    it { should_not be_rejected }
+    it { should be_locked }
+    it { should_not be_unlocked }
+  end
+
+  context 'when the state is rejected' do
+    before(:each) do
+      subject.stub(:state => 'rejected')
+    end
+
+    it { should_not be_pending }
+    it { should_not be_approved }
+    it { should be_rejected }
+    it { should be_locked }
+    it { should_not be_unlocked }
+  end
+
+  context 'when the event is :update' do
+    before(:each) do
+      subject.stub(:event => 'update')
+    end
+
+    it { should be_update }
+    it { should_not be_create }
+  end
+
+  context 'when the event is :create' do
+    before(:each) do
+      subject.stub(:event => 'create')
+    end
+
+    it { should_not be_update }
+    it { should be_create }
+  end
+
+  context 'when the approval is unlocked' do
+    before(:each) do
+      @item = DefaultApprovable.without_approval { |m| m.create }
+      subject.stub(:locked? => false, :created_at => Time.now, :item => @item)
+      @item.stub(:updated_at => Time.now)
+    end
+
+    describe '#able_to_save?' do
+      it { should be_able_to_save }
+
+      it 'does not check the what the state was' do
+        subject.should_not_receive(:state_was)
+        subject.able_to_save?
+      end
+    end
+
+    describe '#stale?' do
+      it 'checks when the item was changed' do
+        @item.should_receive(:has_attribute?).with(:updated_at).and_return(true)
+        subject.stale?
+      end
+    end
+
+    describe '#fresh?' do
+      it 'checks when the item was changed' do
+        @item.should_receive(:has_attribute?).with(:updated_at).and_return(true)
+        subject.fresh?
+      end
+    end
+
+    context 'when the approval is newer than the last update' do
+      before(:each) do
+        subject.stub(:created_at => @item.updated_at + 60)
+      end
+
+      it { should_not be_stale }
+      it { should be_fresh }
+    end
+
+    context 'when the approval is older than the last update' do
+      before(:each) do
+        subject.stub(:created_at => @item.updated_at - 60)
+      end
+
+      it { should be_stale }
+      it { should_not be_fresh }
+    end
+  end
+
+  context 'when the approval is locked' do
+    before(:each) do
+      subject.stub(:locked? => true)
+    end
+
+    it { should_not be_stale }
+    it { should be_fresh }
+
+    describe '#able_to_save?' do
+      it 'checks the what the state was' do
+        subject.should_receive(:state_was)
+        subject.able_to_save?
+      end
+    end
+
+    describe '#stale?' do
+      it 'does not check when the item was changed' do
+        subject.should_not_receive(:item)
+        subject.stale?
+      end
+    end
+
+    describe '#fresh?' do
+      it 'does not check when the item was changed' do
+        subject.should_not_receive(:item)
+        subject.fresh?
+      end
+    end
+
+    describe '#approve!' do
+      it 'raises a Locked exception' do
+        expect { subject.approve! }.to raise_error(ActsAsApprovable::Error::Locked)
+      end
+
+      it 'leaves the approval in a pending state' do
+        begin; subject.approve!; rescue ActsAsApprovable::Error::Locked; end
+        subject.should be_pending
+      end
+    end
+
+    describe '#reject!' do
+      it 'raises a Locked exception' do
+        expect { subject.reject! }.to raise_error(ActsAsApprovable::Error::Locked)
+      end
+
+      it 'leaves the approval in a pending state' do
+        begin; subject.reject!; rescue ActsAsApprovable::Error::Locked; end
+        subject.should be_pending
+      end
+    end
+
+    context 'and the state is pending' do
+      before(:each) do
+        subject.stub(:state_was => 'pending')
+      end
+
+      it { should be_able_to_save }
+    end
+
+    context 'and the state is approved' do
+      before(:each) do
+        subject.stub(:state_was => 'approved')
+      end
+
+      it { should_not be_able_to_save }
+    end
+
+    context 'and the state is rejected' do
+      before(:each) do
+        subject.stub(:state_was => 'rejected')
+      end
+
+      it { should_not be_able_to_save }
+    end
+  end
+
+  context 'when the approval is stale' do
+    before(:each) do
+      @item = DefaultApprovable.without_approval { |m| m.create }
+      subject.stub(:stale? => true, :item => @item)
+    end
+
+    it { should be_stale }
+    it { should_not be_fresh }
+
+    describe '#approve!' do
+      it 'raises a Stale exception' do
+        expect { subject.approve! }.to raise_error(ActsAsApprovable::Error::Stale)
+      end
+
+      it 'leaves the approval in a pending state' do
+        begin; subject.approve!; rescue ActsAsApprovable::Error::Stale; end
+        subject.should be_pending
+      end
+
+      context 'when approval is forced' do
+        it 'does not raise a Stale exception' do
+          expect { subject.approve!(true) }.to_not raise_error(ActsAsApprovable::Error::Stale)
+        end
+
+        it 'leaves the approval in a pending state' do
+          subject.approve!(true)
+          subject.should be_approved
+        end
+      end
+    end
+
+    describe '#reject!' do
+      it 'does not raise a Stale exception' do
+        expect { subject.reject! }.to_not raise_error(ActsAsApprovable::Error::Stale)
+      end
+
+      it 'moves the approval to a rejected state' do
+        subject.reject!
+        subject.should be_rejected
+      end
+    end
+  end
+
+  context 'when the approval is unlocked and fresh' do
+    before(:each) do
+      @item = DefaultApprovable.without_approval { |m| m.create }
+      subject.stub(:locked? => false, :stale? => false, :item => @item, :object => {})
+    end
+
+    it { should_not be_stale }
+    it { should be_fresh }
+
+    describe '#approve!' do
+      it 'does not raise an exception' do
+        expect { subject.approve! }.to_not raise_error
+      end
+
+      it 'moves the approval to an approved state' do
+        subject.approve!
+        subject.should be_approved
+      end
+
+      it 'calls the before and after callbacks' do
+        subject.should_receive(:run_item_callback).with(:before_approve).once.and_return(true)
+        subject.should_receive(:run_item_callback).with(:after_approve).once
+        subject.approve!
+      end
+
+      context 'when the event is :update' do
+        before(:each) do
+          subject.stub(:event => 'update')
+        end
+
+        it 'sets the item attributes' do
+          @item.should_receive(:attributes=)
+          subject.approve!
+        end
+
+        it 'does not set the local item state' do
+          @item.should_not_receive(:set_approval_state)
+          subject.approve!
+        end
+      end
+
+      context 'when the event is :create' do
+        before(:each) do
+          subject.stub(:event => 'create')
+        end
+
+        it 'does not set the item attributes' do
+          @item.should_not_receive(:attributes=)
+          subject.approve!
+        end
+
+        it 'sets the local item state' do
+          @item.should_receive(:set_approval_state).with('approved')
+          subject.approve!
+        end
+      end
+    end
+
+    describe '#reject!' do
+      it 'does not raise an exception' do
+        expect { subject.reject! }.to_not raise_error
+      end
+
+      it 'moves the approval to a rejected state' do
+        subject.reject!
+        subject.should be_rejected
+      end
+
+      it 'sets the reason if given' do
+        subject.reject!('reason')
+        subject.reason.should == 'reason'
+      end
+
+      it 'calls the before and after callbacks' do
+        subject.should_receive(:run_item_callback).with(:before_reject).once.and_return(true)
+        subject.should_receive(:run_item_callback).with(:after_reject).once
+        subject.reject!
+      end
+
+      context 'when the event is :update' do
+        before(:each) do
+          subject.stub(:event => 'update')
+        end
+
+        it 'does not set the item attributes' do
+          @item.should_not_receive(:attributes=)
+          subject.reject!
+        end
+
+        it 'does not set the local item state' do
+          @item.should_not_receive(:set_approval_state)
+          subject.reject!
+        end
+      end
+
+      context 'when the event is :create' do
+        before(:each) do
+          subject.stub(:event => 'create')
+        end
+
+        it 'does not set the item attributes' do
+          @item.should_not_receive(:attributes=)
+          subject.reject!
+        end
+
+        it 'sets the local item state' do
+          @item.should_receive(:set_approval_state).with('rejected')
+          subject.reject!
+        end
+      end
+    end
+  end
+end