mongoid_ability 0.3.12 → 0.4.3

data/test/mongoid_ability/ability_test.rb

@@ -5,50 +5,63 @@ module MongoidAbility
     let(:owner) { MyOwner.new }
     let(:ability) { Ability.new(owner) }
 
+    let(:my_subject_default_locks) { [] }
+    let(:my_subject_1_default_locks) { [] }
+    let(:my_subject_2_default_locks) { [] }
+
     it 'exposes owner' do
       ability.owner.must_equal owner
     end
 
     describe 'default locks' do
-      before do
-        # NOTE: we might need to use the .default_lock macro in case we propagate down directly
-        MySubject.default_locks = [MyLock.new(subject_type: MySubject, action: :update, outcome: true)]
-        MySubject1.default_locks = []
-        MySubject2.default_locks = []
-      end
+      # NOTE: we might need to use the .default_lock macro in case we propagate down directly
+      let(:my_subject_default_locks) { [MyLock.new(subject_type: MySubject, action: :update, outcome: true)] }
 
       it 'propagates from superclass to all subclasses' do
-        ability.can?(:update, MySubject).must_equal true
-        ability.can?(:update, MySubject1).must_equal true
-        ability.can?(:update, MySubject2).must_equal true
+        MySubject.stub :default_locks, my_subject_default_locks do
+          MySubject1.stub :default_locks, my_subject_1_default_locks do
+            MySubject2.stub :default_locks, my_subject_2_default_locks do
+              ability.can?(:update, MySubject).must_equal true
+              ability.can?(:update, MySubject1).must_equal true
+              ability.can?(:update, MySubject2).must_equal true
+            end
+          end
+        end
       end
     end
 
     describe 'when defined for all superclasses' do
-      before do
-        MySubject.default_locks = [MyLock.new(subject_type: MySubject, action: :read, outcome: false)]
-        MySubject1.default_locks = [MyLock.new(subject_type: MySubject1, action: :read, outcome: true)]
-        MySubject2.default_locks = [MyLock.new(subject_type: MySubject2, action: :read, outcome: false)]
-      end
+      let(:my_subject_default_locks) { [MyLock.new(subject_type: MySubject, action: :read, outcome: false)] }
+      let(:my_subject_1_default_locks) { [MyLock.new(subject_type: MySubject1, action: :read, outcome: true)] }
+      let(:my_subject_2_default_locks) { [MyLock.new(subject_type: MySubject2, action: :read, outcome: false)] }
 
       it 'respects the definitions' do
-        ability.can?(:read, MySubject).must_equal false
-        ability.can?(:read, MySubject1).must_equal true
-        ability.can?(:read, MySubject2).must_equal false
+        MySubject.stub :default_locks, my_subject_default_locks do
+          MySubject1.stub :default_locks, my_subject_1_default_locks do
+            MySubject2.stub :default_locks, my_subject_2_default_locks do
+              ability.can?(:read, MySubject).must_equal false
+              ability.can?(:read, MySubject1).must_equal true
+              ability.can?(:read, MySubject2).must_equal false
+            end
+          end
+        end
       end
     end
 
     describe 'when defined for some superclasses' do
-      before do
-        MySubject.default_locks = [MyLock.new(subject_type: MySubject, action: :read, outcome: false)]
-        MySubject1.default_locks = []
-        MySubject2.default_locks = [MyLock.new(subject_type: MySubject2, action: :read, outcome: true)]
-      end
+      let(:my_subject_default_locks) { [MyLock.new(subject_type: MySubject, action: :read, outcome: false)] }
+      let(:my_subject_2_default_locks) { [MyLock.new(subject_type: MySubject2, action: :read, outcome: true)] }
 
       it 'propagates default locks to subclasses' do
-        ability.can?(:read, MySubject).must_equal false
-        ability.can?(:read, MySubject1).must_equal false
-        ability.can?(:read, MySubject2).must_equal true
+        MySubject.stub :default_locks, my_subject_default_locks do
+          MySubject1.stub :default_locks, my_subject_1_default_locks do
+            MySubject2.stub :default_locks, my_subject_2_default_locks do
+              ability.can?(:read, MySubject).must_equal false
+              ability.can?(:read, MySubject1).must_equal false
+              ability.can?(:read, MySubject2).must_equal true
+            end
+          end
+        end
       end
     end
 
@@ -56,15 +69,20 @@ module MongoidAbility
 
     describe 'user locks' do
       describe 'when defined for superclass' do
+        let(:my_subject_default_locks) { [MyLock.new(subject_type: MySubject, action: :read, outcome: false)] }
+
         before do
-          MySubject.default_locks = [MyLock.new(subject_type: MySubject, action: :read, outcome: false)]
-          MySubject1.default_locks = []
-          MySubject2.default_locks = []
           owner.my_locks = [MyLock.new(subject_type: MySubject, action: :read, outcome: true)]
         end
 
         it 'applies the superclass lock' do
-          ability.can?(:read, MySubject2).must_equal true
+          MySubject.stub :default_locks, my_subject_default_locks do
+            MySubject1.stub :default_locks, my_subject_1_default_locks do
+              MySubject2.stub :default_locks, my_subject_2_default_locks do
+                ability.can?(:read, MySubject2).must_equal true
+              end
+            end
+          end
         end
       end
     end
@@ -73,8 +91,9 @@ module MongoidAbility
 
     describe 'inherited owner locks' do
       describe 'when multiple inherited owners' do
+        let(:my_subject_default_locks) { [MyLock.new(subject_type: MySubject, action: :read, outcome: false)] }
+
         before do
-          MySubject.default_locks = [MyLock.new(subject_type: MySubject, action: :read, outcome: false)]
           owner.my_roles = [
             MyRole.new(my_locks: [MyLock.new(subject_type: MySubject, action: :read, outcome: true)]),
             MyRole.new(my_locks: [MyLock.new(subject_type: MySubject, action: :read, outcome: false)])
@@ -82,20 +101,31 @@ module MongoidAbility
         end
 
         it 'prefers positive outcome' do
-          ability.can?(:read, MySubject).must_equal true
+          MySubject.stub :default_locks, my_subject_default_locks do
+            MySubject1.stub :default_locks, my_subject_1_default_locks do
+              MySubject2.stub :default_locks, my_subject_2_default_locks do
+                ability.can?(:read, MySubject).must_equal true
+              end
+            end
+          end
         end
       end
 
       describe 'when defined for superclass' do
+        let(:my_subject_default_locks) { [MyLock.new(subject_type: MySubject, action: :read, outcome: false)] }
+
         before do
-          MySubject.default_locks = [MyLock.new(subject_type: MySubject, action: :read, outcome: false)]
-          MySubject1.default_locks = []
-          MySubject2.default_locks = []
           owner.my_roles = [MyRole.new(my_locks: [MyLock.new(subject_type: MySubject, action: :read, outcome: true)])]
         end
 
         it 'applies the superclass lock' do
-          ability.can?(:read, MySubject2).must_equal true
+          MySubject.stub :default_locks, my_subject_default_locks do
+            MySubject1.stub :default_locks, my_subject_1_default_locks do
+              MySubject2.stub :default_locks, my_subject_2_default_locks do
+                ability.can?(:read, MySubject2).must_equal true
+              end
+            end
+          end
         end
       end
     end
@@ -104,25 +134,39 @@ module MongoidAbility
 
     describe 'combined locks' do
       describe 'user and role locks' do
+        let(:my_subject_default_locks) { [MyLock.new(subject_type: MySubject, action: :read, outcome: false)] }
+
         before do
-          MySubject.default_locks = [MyLock.new(subject_type: MySubject, action: :read, outcome: false)]
           owner.my_locks = [MyLock.new(subject_type: MySubject, action: :read, outcome: false)]
           owner.my_roles = [MyRole.new(my_locks: [MyLock.new(subject_type: MySubject, action: :read, outcome: true)])]
         end
 
         it 'prefers user locks' do
-          ability.can?(:read, MySubject).must_equal false
+          MySubject.stub :default_locks, my_subject_default_locks do
+            MySubject1.stub :default_locks, my_subject_1_default_locks do
+              MySubject2.stub :default_locks, my_subject_2_default_locks do
+                ability.can?(:read, MySubject).must_equal false
+              end
+            end
+          end
         end
       end
 
       describe 'roles and default locks' do
+        let(:my_subject_default_locks) { [MyLock.new(subject_type: MySubject, action: :read, outcome: false)] }
+
         before do
-          MySubject.default_locks = [MyLock.new(subject_type: MySubject, action: :read, outcome: false)]
           owner.my_roles = [MyRole.new(my_locks: [MyLock.new(subject_type: MySubject, action: :read, outcome: true)])]
         end
 
         it 'prefers role locks' do
-          ability.can?(:read, MySubject).must_equal true
+          MySubject.stub :default_locks, my_subject_default_locks do
+            MySubject1.stub :default_locks, my_subject_1_default_locks do
+              MySubject2.stub :default_locks, my_subject_2_default_locks do
+                ability.can?(:read, MySubject).must_equal true
+              end
+            end
+          end
         end
       end
     end

data/test/mongoid_ability/accessible_query_builder_test.rb

@@ -8,19 +8,43 @@ module MongoidAbility
     let(:action) { :read }
     let(:options) { Hash.new }
 
-    before do
-      MySubject.default_locks = [MyLock.new(subject_type: MySubject, action: :read, outcome: true)]
-    end
+    let(:my_subject_default_locks) { [MyLock.new(subject_type: MySubject, action: :read, outcome: true)] }
+    let(:my_subject_1_default_locks) { [MyLock.new(subject_type: MySubject1, action: :false, outcome: true)] }
+    let(:my_subject_2_default_locks) { [] }
 
     subject { AccessibleQueryBuilder.call(base_class, ability, action, options) }
 
     it 'returns Mongoid::Criteria' do
-      subject.must_be_kind_of Mongoid::Criteria
+      MySubject.stub :default_locks, my_subject_default_locks do
+        MySubject1.stub :default_locks, my_subject_1_default_locks do
+          MySubject2.stub :default_locks, my_subject_2_default_locks do
+            subject.must_be_kind_of Mongoid::Criteria
+          end
+        end
+      end
     end
 
-    it 'allows to pass prefix' do
-      skip 'not sure how to best test this'
-      selector = AccessibleQueryBuilder.call(base_class, ability, action, prefix: :foo).selector
+    describe 'prefix' do
+      let(:my_subject) { MySubject.create! }
+      let(:my_subject_1) { MySubject1.create! }
+      let(:my_subject_2) { MySubject2.create! }
+      let(:prefix) { :foo }
+
+      before do
+        my_subject; my_subject_1
+        owner.my_locks = [MyLock.new(subject_type: MySubject, action: :read, outcome: false)]
+      end
+
+      it 'allows to pass prefix' do
+        MySubject.stub :default_locks, my_subject_default_locks do
+          MySubject1.stub :default_locks, my_subject_1_default_locks do
+            MySubject2.stub :default_locks, my_subject_2_default_locks do
+              selector = AccessibleQueryBuilder.call(base_class, ability, action, prefix: prefix).selector
+              selector.must_equal('$and' => [{ '$or' => [{ "#{prefix}_type" => { '$nin' => ['MongoidAbility::MySubject', 'MongoidAbility::MySubject1', 'MongoidAbility::MySubject2'] } }, { "#{prefix}_type" => { '$in' => [] }, "#{prefix}_id" => { '$in' => [] } }] }, { "#{prefix}_id" => { '$nin' => [] } }])
+            end
+          end
+        end
+      end
     end
 
     # ---------------------------------------------------------------------
@@ -35,9 +59,15 @@ module MongoidAbility
       end
 
       it 'does not return subject with that id' do
-        MySubject.accessible_by(ability, :read).wont_include my_subject
-        MySubject.accessible_by(ability, :read).wont_include my_subject_1
-        MySubject1.accessible_by(ability, :read).wont_include my_subject_1
+        MySubject.stub :default_locks, my_subject_default_locks do
+          MySubject1.stub :default_locks, my_subject_1_default_locks do
+            MySubject2.stub :default_locks, my_subject_2_default_locks do
+              MySubject.accessible_by(ability, :read).wont_include my_subject
+              MySubject.accessible_by(ability, :read).wont_include my_subject_1
+              MySubject1.accessible_by(ability, :read).wont_include my_subject_1
+            end
+          end
+        end
       end
     end
 
@@ -51,8 +81,14 @@ module MongoidAbility
       end
 
       it 'does not return subject with that id' do
-        MySubject.accessible_by(ability, :read).wont_include my_subject_a
-        MySubject.accessible_by(ability, :read).must_include my_subject_b
+        MySubject.stub :default_locks, my_subject_default_locks do
+          MySubject1.stub :default_locks, my_subject_1_default_locks do
+            MySubject2.stub :default_locks, my_subject_2_default_locks do
+              MySubject.accessible_by(ability, :read).wont_include my_subject_a
+              MySubject.accessible_by(ability, :read).must_include my_subject_b
+            end
+          end
+        end
       end
     end
 
@@ -69,8 +105,14 @@ module MongoidAbility
       end
 
       it 'does not return subject with that id' do
-        MySubject.accessible_by(ability, :read).must_include my_subject
-        MySubject.accessible_by(ability, :read).must_include my_subject_1
+        MySubject.stub :default_locks, my_subject_default_locks do
+          MySubject1.stub :default_locks, my_subject_1_default_locks do
+            MySubject2.stub :default_locks, my_subject_2_default_locks do
+              MySubject.accessible_by(ability, :read).must_include my_subject
+              MySubject.accessible_by(ability, :read).must_include my_subject_1
+            end
+          end
+        end
       end
     end
   end

data/test/mongoid_ability/can_options_test.rb

@@ -5,13 +5,13 @@ module MongoidAbility
     let(:owner) { MyOwner.new }
     let(:ability) { Ability.new(owner) }
 
-    before do
-      MySubject.default_locks = [ MyLock1.new(action: :read, outcome: false) ]
-    end
+    let(:default_locks) { [MyLock1.new(action: :read, outcome: false)] }
 
     it 'allows to pass options to a can? block' do
-      ability.can?(:read, MySubject, {}).must_equal false
-      ability.can?(:read, MySubject, { override: true }).must_equal true
+      MySubject.stub :default_locks, default_locks do
+        ability.can?(:read, MySubject, {}).must_equal false
+        ability.can?(:read, MySubject, override: true).must_equal true
+      end
     end
   end
 end

data/test/mongoid_ability/lock_test.rb

@@ -6,11 +6,9 @@ module MongoidAbility
     let(:my_subject) { MySubject.new }
     let(:inherited_lock) { MyLock1.new }
 
-    # ---------------------------------------------------------------------
-
-    before do
-      MySubject.default_locks = [MyLock.new(action: :read, outcome: true), MyLock.new(action: :update, outcome: false)]
-    end
+    let(:my_subject_default_locks) { [MyLock.new(subject_type: MySubject, action: :read, outcome: true)] }
+    let(:my_subject_1_default_locks) { [MyLock.new(subject_type: MySubject1, action: :false, outcome: true)] }
+    let(:my_subject_2_default_locks) { [] }
 
     # ---------------------------------------------------------------------
 
@@ -51,7 +49,7 @@ module MongoidAbility
 
       it 'converts empty String to nil' do
         id = ''
-        MyLock.for_subject_id(id.to_s).selector['subject_id'].must_equal nil
+        MyLock.for_subject_id(id.to_s).selector['subject_id'].must_be_nil
       end
     end
 
@@ -68,17 +66,35 @@ module MongoidAbility
       end
 
       it 'does not affect calculated_outcome' do
-        @ability.can?(:read, my_subject).must_equal true
+        MySubject.stub :default_locks, my_subject_default_locks do
+          MySubject1.stub :default_locks, my_subject_1_default_locks do
+            MySubject2.stub :default_locks, my_subject_2_default_locks do
+              @ability.can?(:read, my_subject).must_equal true
+            end
+          end
+        end
       end
 
       it 'returns calculated_outcome without this lock' do
-        subject_lock.inherited_outcome.must_equal false
-        subject_type_lock.inherited_outcome.must_equal true
+        MySubject.stub :default_locks, my_subject_default_locks do
+          MySubject1.stub :default_locks, my_subject_1_default_locks do
+            MySubject2.stub :default_locks, my_subject_2_default_locks do
+              subject_lock.inherited_outcome.must_equal false
+              subject_type_lock.inherited_outcome.must_equal true
+            end
+          end
+        end
       end
 
       it 'returns calculated_outcome for default locks' do
-        lock = MySubject.default_locks.detect { |l| l.action == :read }
-        lock.inherited_outcome.must_equal true
+        MySubject.stub :default_locks, my_subject_default_locks do
+          MySubject1.stub :default_locks, my_subject_1_default_locks do
+            MySubject2.stub :default_locks, my_subject_2_default_locks do
+              lock = MySubject.default_locks.detect { |l| l.action == :read }
+              lock.inherited_outcome.must_equal true
+            end
+          end
+        end
       end
     end
   end

data/test/mongoid_ability/owner_locks_test.rb

@@ -10,31 +10,27 @@ module MongoidAbility
     let(:owner) { MyOwner.new }
     let(:ability) { Ability.new(owner) }
 
-    # ---------------------------------------------------------------------
-
-    before do
-      MySubject.default_locks = [MyLock.new(subject_type: MySubject, action: :read, outcome: true)]
-    end
-
-    # ---------------------------------------------------------------------
+    let(:default_locks) { [MyLock.new(subject_type: MySubject, action: :read, outcome: true)] }
 
     describe 'when lock for subject' do
       before { owner.my_locks = [subject_lock] }
 
       it 'applies it' do
-        ability.can?(:read, subject.class).must_equal true
-        ability.can?(:read, subject).must_equal false
+        MySubject.stub :default_locks, default_locks do
+          ability.can?(:read, subject.class).must_equal true
+          ability.can?(:read, subject).must_equal false
+        end
       end
     end
 
-    # ---------------------------------------------------------------------
-
     describe 'when lock for subject type' do
       before { owner.my_locks = [subject_type_lock] }
 
       it 'applies it' do
-        ability.can?(:read, subject.class).must_equal false
-        ability.can?(:read, subject).must_equal false
+        MySubject.stub :default_locks, default_locks do
+          ability.can?(:read, subject.class).must_equal false
+          ability.can?(:read, subject).must_equal false
+        end
       end
     end
   end

data/test/mongoid_ability/resolve_default_locks_test.rb

@@ -1,27 +1,41 @@
-require "test_helper"
+require 'test_helper'
 
 module MongoidAbility
   describe ResolveDefaultLocks do
-
     describe '.call' do
-      before do
-        MySubject.default_locks = [
+      let(:options) { {} }
+
+      let(:my_subject_default_locks) do
+        [
           MyLock.new(subject_type: MySubject, action: :read, outcome: true),
           MyLock.new(subject_type: MySubject, action: :update, outcome: false)
         ]
+      end
 
-        MySubject1.default_locks = [
+      let(:my_subject_1_default_locks) do
+        [
           MyLock.new(subject_type: MySubject1, action: :read, outcome: false),
           MyLock.new(subject_type: MySubject1, action: :update, outcome: true)
         ]
       end
 
-      it { ResolveDefaultLocks.call(nil, :read, MySubject, nil, {}).must_equal true }
-      it { ResolveDefaultLocks.call(nil, :update, MySubject, nil, {}).must_equal false }
+      it 'resolves on self' do
+        MySubject.stub :default_locks, my_subject_default_locks do
+          MySubject1.stub :default_locks, my_subject_1_default_locks do
+            ResolveDefaultLocks.call(nil, :read, MySubject, nil, options).must_equal MySubject.default_locks.first
+            ResolveDefaultLocks.call(nil, :update, MySubject, nil, options).must_equal MySubject.default_locks.last
+          end
+        end
+      end
 
-      it { ResolveDefaultLocks.call(nil, :read, MySubject1, nil, {}).must_equal false }
-      it { ResolveDefaultLocks.call(nil, :update, MySubject1, nil, {}).must_equal true }
+      it 'resolves on subclass' do
+        MySubject.stub :default_locks, my_subject_default_locks do
+          MySubject1.stub :default_locks, my_subject_1_default_locks do
+            ResolveDefaultLocks.call(nil, :read, MySubject1, nil, options).must_equal MySubject1.default_locks.first
+            ResolveDefaultLocks.call(nil, :update, MySubject1, nil, options).must_equal MySubject1.default_locks.last
+          end
+        end
+      end
     end
-
   end
 end