acts-as-approvable 0.6.1

data/test/acts_as_approvable_model_test.rb

@@ -0,0 +1,428 @@
+require 'test_helper'
+
+class ActsAsApprovableModelTest < Test::Unit::TestCase
+  load_schema
+
+  def teardown
+    truncate
+  end
+
+  context 'A record with update only approval' do
+    context 'and ignored fields' do
+      setup { @project = Project.create }
+
+      should 'have no approvals' do
+        assert @project.approvals.empty?
+      end
+
+      context 'which updates an ignored column' do
+        setup { @project.update_attribute(:title, 'Ignore Me') }
+
+        should 'not have an approval' do
+          assert @project.approvals.empty?
+        end
+      end
+
+      context 'which updates an ignore column and a non-ignored column' do
+        setup { @project.update_attributes(:title => 'Ignore Me', :description => 'Must Review') }
+
+        should 'have one approval' do
+          assert_equal 1, @project.approvals.size
+        end
+
+        should 'not update the records ignored column' do
+          assert_equal nil, @project.description
+        end
+
+        should 'update the records non-ignored columns' do
+          assert_equal 'Ignore Me', @project.title
+        end
+
+        should 'have the description on the approval' do
+          assert @project.approvals.last.object.key?('description')
+          assert_equal 'Must Review', @project.approvals.last.object['description']
+        end
+      end
+
+      context 'that is altered using #without_approval' do
+        should 'not have an approval object' do
+          @project.without_approval { |i| i.update_attribute(:description, 'updated') }
+          assert @project.approvals.empty?
+        end
+
+        should 'correctly restore approval queue state' do
+          assert @project.approvals_on?
+          @project.approvals_off
+          assert !@project.approvals_on?
+          @project.without_approval { |i| i.update_attribute(:description, 'updated') }
+          assert !@project.approvals_on?
+        end
+      end
+    end
+
+    context 'and "only" fields' do
+      setup { @game = Game.create }
+
+      should 'have no approvals' do
+        assert @game.approvals.empty?
+      end
+
+      context 'which updates an only column' do
+        setup { @game.update_attribute(:title, 'review') }
+
+        should 'have an approval' do
+          assert_equal 1, @game.approvals.size
+        end
+
+        should 'have pending changes' do
+          assert @game.pending_changes?
+        end
+      end
+
+      context 'which updates an only column and another column' do
+        setup { @game.update_attributes(:title => 'review', :description => 'no review') }
+
+        should 'have one approval' do
+          assert_equal 1, @game.approvals.size
+        end
+
+        should 'not update the records only column' do
+          assert_equal nil, @game.title
+        end
+
+        should 'update the records other fields' do
+          assert_equal 'no review', @game.description
+        end
+
+        should 'have the title on the approval' do
+          assert @game.approvals.last.object.key?('title')
+          assert_equal 'review', @game.approvals.last.object['title']
+        end
+      end
+
+      context 'that is altered using #without_approval' do
+        setup { @game.without_approval { |i| i.update_attribute(:title, 'updated') } }
+
+        should 'not have an approval object' do
+          assert @game.approvals.empty?
+        end
+      end
+
+      context 'with approval queue disabled' do
+        context 'at the record level' do
+          setup do
+            @game.approvals_off
+            @game.update_attributes(:title => 'review')
+          end
+
+          teardown { @game.approvals_on }
+
+          should 'have approvals off' do
+            assert @game.approvals_disabled?
+          end
+
+          should 'not have an approval object' do
+            assert @game.approvals.empty?
+          end
+        end
+
+        context 'at the model level' do
+          setup do
+            Game.approvals_off
+            @game.update_attributes(:title => 'review')
+          end
+
+          teardown { Game.approvals_on }
+
+          should 'have approvals off' do
+            assert @game.approvals_disabled?
+          end
+
+          should 'not have an approval object' do
+            assert @game.approvals.empty?
+          end
+        end
+
+        context 'at the global level' do
+          setup do
+            ActsAsApprovable.disable
+            @game.update_attributes(:title => 'review')
+          end
+
+          teardown { ActsAsApprovable.enable }
+
+          should 'have approvals off' do
+            assert @game.approvals_disabled?
+          end
+
+          should 'not have an approval object' do
+            assert @game.approvals.empty?
+          end
+        end
+      end
+    end
+  end
+
+  context 'An approval record' do
+    setup do
+      @project = Project.create
+      @project.update_attribute(:description, 'review')
+      @approval = @project.approvals.last
+    end
+
+    should 'not be locked by default' do
+      assert @approval.unlocked?
+      assert !@approval.locked?
+    end
+
+    should 'be pending' do
+      assert @approval.pending?
+      assert !@approval.approved?
+      assert !@approval.rejected?
+    end
+
+    should 'check attributes in object' do
+      @approval.object['foo'] = 'bar'
+      @approval.approve!
+      assert_equal @approval.object['description'], @approval.item.description
+    end
+
+    context 'that is accepted' do
+      setup { @approval.approve! }
+
+      should 'be locked' do
+        assert @approval.locked?
+        assert !@approval.unlocked?
+      end
+
+      should 'be approved' do
+        assert @approval.approved?
+        assert !@approval.rejected?
+        assert !@approval.pending?
+      end
+
+      should 'update the target item' do
+        assert_equal @approval.object['description'], @approval.item.description
+      end
+
+      should 'raise an error if approved again' do
+        assert_raise(ActsAsApprovable::Error::Locked) { @approval.approve! }
+      end
+
+      should 'raise an error if rejected' do
+        assert_raise(ActsAsApprovable::Error::Locked) { @approval.reject! }
+      end
+    end
+
+    context 'that is rejected' do
+      setup { @approval.reject! }
+
+      should 'be locked' do
+        assert @approval.locked?
+        assert !@approval.unlocked?
+      end
+
+      should 'be rejected' do
+        assert @approval.rejected?
+        assert !@approval.approved?
+        assert !@approval.pending?
+      end
+
+      should 'not update the target item' do
+        assert_equal nil, @approval.item.description
+      end
+
+      should 'raise an error if approved' do
+        assert_raise(ActsAsApprovable::Error::Locked) { @approval.approve! }
+      end
+
+      should 'raise an error if rejected again' do
+        assert_raise(ActsAsApprovable::Error::Locked) { @approval.reject! }
+      end
+    end
+
+    context 'that is stale' do
+      setup { @approval.update_attributes(:created_at => 10.days.ago) }
+
+      should 'be stale' do
+        assert @approval.stale?
+        assert !@approval.fresh?
+      end
+
+      should 'raise an error if approved' do
+        assert_raise(ActsAsApprovable::Error::Stale) { @approval.approve! }
+        assert @approval.pending?
+      end
+
+      should 'not raise an error if rejected' do
+        assert_nothing_raised { @approval.reject! }
+        assert @approval.rejected?
+      end
+
+      should 'allow approval when forced' do
+        assert_nothing_raised { @approval.approve!(true) }
+        assert @approval.approved?
+      end
+    end
+  end
+
+  context 'A record with create only approval' do
+    setup { @user = User.create }
+
+    should 'be pending by default' do
+      assert @user.pending?
+      assert !@user.approved?
+      assert !@user.rejected?
+    end
+
+    should 'have an approval object' do
+      assert_equal 1, @user.approvals.size
+    end
+
+    should 'set the local state' do
+      assert_equal 'pending', @user.state
+    end
+
+    context 'when approved' do
+      setup do
+        @user.approve!
+        @user.reload
+      end
+
+      should 'be approved' do
+        assert @user.approved?
+        assert !@user.rejected?
+        assert !@user.pending?
+      end
+
+      should 'update the local state' do
+        assert_equal 'approved', @user.state
+      end
+    end
+
+    context 'when rejected' do
+      setup do
+        @user.reject!
+        @user.reload
+      end
+
+      should 'be rejected' do
+        assert @user.rejected?
+        assert !@user.approved?
+        assert !@user.pending?
+      end
+
+      should 'update the local state' do
+        assert_equal 'rejected', @user.state
+      end
+    end
+
+    context '.without_approval' do
+      should 'disable approvals for the given block' do
+        @user = User.without_approval { |m| m.create }
+        assert @user.approval.nil?
+      end
+    end
+  end
+
+  context 'A record with default settings' do
+    setup { @employee = Employee.create }
+
+    should 'be pending by default' do
+      assert @employee.pending?
+      assert !@employee.approved?
+      assert !@employee.rejected?
+    end
+
+    should 'get the state from the approval record' do
+      assert_equal @employee.approval_state, @employee.approval.state
+    end
+
+    context 'when updated' do
+      setup { @employee.update_attributes(:name => 'John Doe') }
+
+      should 'not update the attribute' do
+        assert_equal nil, @employee.name
+      end
+
+      should 'create an approval record' do
+        assert_equal 1, @employee.update_approvals.size
+      end
+    end
+
+    context 'when approving' do
+      setup { @approval = @employee.approval }
+
+      should 'call before_approve hook' do
+        @approval.item.expects(:before_approve).once
+        @approval.approve!
+      end
+
+      should 'call after_approve hook' do
+        @approval.item.expects(:after_approve).once
+        @approval.approve!
+      end
+
+      should 'halt if before_approve returns false' do
+        @approval.item.stubs(:before_approve).returns(false)
+        @approval.approve!
+        assert @approval.item.pending?
+      end
+    end
+
+    context 'when rejecting' do
+      setup { @approval = @employee.approval }
+
+      should 'call before_reject hook' do
+        @approval.item.expects(:before_reject).once
+        @approval.reject!
+      end
+
+      should 'call after_reject hook' do
+        @approval.item.expects(:after_reject).once
+        @approval.reject!
+      end
+
+      should 'halt if before_reject returns false' do
+        @approval.item.stubs(:before_reject).returns(false)
+        @approval.reject!
+        assert @approval.item.pending?
+      end
+    end
+  end
+
+  context '.options_for_state' do
+    should 'return an array' do
+      assert_kind_of Array, Approval.options_for_state
+    end
+
+    should 'contain our states' do
+      assert Approval.options_for_state.include?(['All', -1])
+      assert Approval.options_for_state.include?(['Pending', 0])
+      assert Approval.options_for_state.include?(['Approved', 1])
+      assert Approval.options_for_state.include?(['Rejected', 2])
+    end
+  end
+
+  context '.options_for_type' do
+    context 'without approval records' do
+      should 'be empty' do
+        assert Approval.options_for_type.empty?
+      end
+    end
+
+    context 'with approval records' do
+      setup do
+        Project.create.update_attributes(:description => 'review')
+        Game.create.update_attributes(:title => 'review')
+        User.create
+      end
+
+      should 'contain all types with approvals' do
+        assert Approval.options_for_type.include?('Project')
+        assert Approval.options_for_type.include?('Game')
+        assert Approval.options_for_type.include?('User')
+      end
+    end
+  end
+end

data/test/acts_as_approvable_ownership_test.rb

@@ -0,0 +1,132 @@
+require 'test_helper'
+
+class ActsAsApprovableOwnershipTest < Test::Unit::TestCase
+  load_schema
+
+  def teardown
+    truncate
+  end
+
+  context 'with default configuration' do
+    setup do
+      # Reset from test below
+      ActsAsApprovable::Ownership.configure do
+        def self.available_owners
+          owner_class.all
+        end
+      end
+    end
+
+    should 'respond to .owner_class' do
+      assert_respond_to Approval, :owner_class
+    end
+
+    should 'respond to .available_owners' do
+      assert_respond_to Approval, :available_owners
+    end
+
+    should 'respond to .options_for_available_owners' do
+      assert_respond_to Approval, :options_for_available_owners
+    end
+
+    should 'respond to .assigned_owners' do
+      assert_respond_to Approval, :assigned_owners
+    end
+
+    should 'respond to .options_for_assigned_owners' do
+      assert_respond_to Approval, :options_for_assigned_owners
+    end
+
+    context 'and some objects' do
+      setup do
+        @employee = Employee.create
+        @approval = @employee.approval
+
+        @user1, @user2 = User.without_approval { |m| [m.create, m.create] }
+      end
+
+      context '#assign' do
+        should 'raise an error when the record is not assignable' do
+          assert_raise(ActsAsApprovable::Error::InvalidOwner) { @approval.assign(@employee) }
+        end
+
+        should 'allow assignment of a valid record' do
+          assert_nothing_raised { @approval.assign(@user1) }
+          assert_equal @approval.owner, @user1
+        end
+      end
+
+      context '#unassign' do
+        setup do
+          @approval.owner = @user1
+          @approval.unassign
+        end
+
+        should 'nullify the owner' do
+          assert @approval.owner.nil?
+        end
+      end
+
+      context '.available_owners' do
+        should 'contain all available owners' do
+          assert_equal [@user1, @user2], Approval.available_owners
+        end
+      end
+
+      context '.options_for_available_owners' do
+        should 'format all available owners for a #options_for_select' do
+          assert_equal Approval.options_for_available_owners, [
+            [@user1.to_str, @user1.id],
+            [@user2.to_str, @user2.id]
+          ]
+        end
+
+        should 'insert a prompt if requested' do
+          assert_equal ['(none)', nil], Approval.options_for_available_owners(true).first
+        end
+      end
+
+      context 'with some assigned owners' do
+        setup do
+          @user3 = User.without_approval { |m| m.create }
+
+          @approval.assign(@user1)
+          Employee.create.approval.assign(@user3)
+        end
+
+        context '.assigned_owners' do
+          should 'contain all assigned owners' do
+            assert_equal [@user1, @user3], Approval.assigned_owners
+          end
+        end
+
+        context '.options_for_assigned_owners' do
+          should 'format all assigned owners for #options_for_select' do
+            assert_equal Approval.options_for_assigned_owners, [
+              [@user1.to_str, @user1.id],
+              [@user3.to_str, @user3.id]
+            ]
+          end
+
+          should 'insert a prompt if requested' do
+            assert_equal ['All Users', nil], Approval.options_for_assigned_owners(true).first
+          end
+        end
+      end
+    end
+  end
+
+  context 'given a block' do
+    setup do
+      ActsAsApprovable::Ownership.configure do
+        def self.available_owners
+          [1, 2, 3]
+        end
+      end
+    end
+
+    should 'allow overriding methods' do
+      assert_equal [1, 2, 3], Approval.available_owners
+    end
+  end
+end

data/test/acts_as_approvable_schema_test.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+class ActsAsApprovableSchemaTest < Test::Unit::TestCase
+  def setup
+    load_schema
+  end
+
+  def test_schema_has_loaded_correctly
+    assert_equal [], User.all
+    assert_equal [], Project.all
+    assert_equal [], Approval.all
+  end
+end

data/test/acts_as_approvable_test.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+class ActsAsApprovableTest < Test::Unit::TestCase
+  should 'set VERSION contanst to file contents' do
+    contents = File.read(File.expand_path(File.join(File.dirname(__FILE__), '..', 'VERSION'))).chomp
+    assert_equal ActsAsApprovable::VERSION, contents
+  end
+end

data/test/database.yml

@@ -0,0 +1,7 @@
+sqlite:
+  :adapter: sqlite
+  :database: test/acts_as_approvable_plugin.sqlite.db
+
+sqlite3:
+  :adapter: sqlite3
+  :database: test/acts_as_approvable_plugin.sqlite3.db

data/test/schema.rb

@@ -0,0 +1,44 @@
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :users, :force => true do |t|
+    t.string  :login
+    t.string  :state
+
+    t.timestamps
+  end
+
+  create_table :projects, :force => true do |t|
+    t.string  :title
+    t.text    :description
+
+    t.timestamps
+  end
+
+  create_table :games, :force => true do |t|
+    t.string  :title
+    t.text    :description
+
+    t.timestamps
+  end
+
+  create_table :employees, :force => true do |t|
+    t.string  :name
+
+    t.timestamps
+  end
+
+  create_table :approvals, :force => true 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
+    t.integer  :owner_id
+    t.text     :object
+    t.text     :reason
+
+    t.timestamps
+  end
+
+  add_index :approvals, [:state, :event]
+  add_index :approvals, [:item_type, :item_id]
+  add_index :approvals, [:owner_id]
+end

data/test/support.rb

@@ -0,0 +1,19 @@
+class User < ActiveRecord::Base
+  acts_as_approvable :on => :create, :state_field => :state
+
+  def to_str
+    login || "user-#{id}"
+  end
+end
+
+class Project < ActiveRecord::Base
+  acts_as_approvable :on => :update, :ignore => :title
+end
+
+class Game < ActiveRecord::Base
+  acts_as_approvable :on => :update, :only => :title
+end
+
+class Employee < ActiveRecord::Base
+  acts_as_approvable
+end