mongoid_ability 1.0.0 → 2.0.0

data/test/mongoid_ability/ability_basic_benchmark.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+require 'minitest/benchmark'
+
+module MongoidAbility
+  describe 'basic ability Benchmark' do
+    let(:read_lock) { MyLock.new(subject_type: MySubject, action: :read, outcome: false) }
+    let(:owner) { MyRole.new(my_locks: [read_lock]) }
+    let(:ability) { Ability.new(owner) }
+
+    before(:all) { MySubject.default_lock MyLock, :read, true }
+
+    bench_performance_constant 'can?' do |n|
+      n.times do
+        ability.can?(:read, MySubject).must_equal false
+      end
+    end
+
+    bench_performance_constant 'cannot?' do |n|
+      n.times do
+        ability.cannot?(:read, MySubject).must_equal true
+      end
+    end
+
+    # bench_performance_constant 'accessible_by' do |n|
+    #   n.times do
+    #     MySubject.accessible_by(ability, :read).must_be_kind_of Mongoid::Criteria
+    #   end
+    # end
+  end
+end

data/test/mongoid_ability/ability_basic_test.rb

@@ -2,27 +2,58 @@ require 'test_helper'
 
 module MongoidAbility
   describe 'basic ability test' do
-    let(:read_lock) { MyLock.new(subject_type: MySubject, action: :read, outcome: false) }
-    let(:owner) { MyRole.new(my_locks: [read_lock]) }
+    let(:owner) { MyRole.new }
     let(:ability) { Ability.new(owner) }
 
-    let(:default_locks) { [MyLock.new(action: :read, outcome: true)] }
+    describe 'default' do
+      it { ability.can?(:read, MySubject).must_equal false }
+      it { ability.cannot?(:read, MySubject).must_equal true }
+    end
 
-    it 'owner can?' do
-      MySubject.stub :default_locks, default_locks do
-        ability.can?(:read, MySubject).must_equal false
-      end
+    describe 'class locks' do
+      before(:all) { MySubject.default_lock MyLock, :read, true }
+
+      it { ability.can?(:read, MySubject).must_equal true }
+      it { ability.cannot?(:read, MySubject).must_equal false }
     end
 
-    it 'owner cannot?' do
-      MySubject.stub :default_locks, default_locks do
-        ability.cannot?(:read, MySubject).must_equal true
+    describe 'inherited locks' do
+      describe 'subject_type' do
+        let(:read_lock) { MyLock.new(subject_type: MySubject, action: :read, outcome: true) }
+        let(:my_role) { MyRole.new(my_locks: [read_lock]) }
+        let(:owner) { MyOwner.new(my_roles: [my_role]) }
+
+        it { ability.can?(:read, MySubject).must_equal true }
+        it { ability.cannot?(:read, MySubject).must_equal false }
+      end
+
+      describe 'subject_id' do
+        let(:my_subject) { MySubject.new }
+        let(:read_lock) { MyLock.new(subject: my_subject, action: :read, outcome: true) }
+        let(:my_role) { MyRole.new(my_locks: [read_lock]) }
+        let(:owner) { MyOwner.new(my_roles: [my_role]) }
+
+        it { ability.can?(:read, my_subject).must_equal true }
+        it { ability.cannot?(:read, my_subject).must_equal false }
       end
     end
 
-    it 'is accessible by' do
-      MySubject.stub :default_locks, default_locks do
-        MySubject.accessible_by(ability, :read).must_be_kind_of Mongoid::Criteria
+    describe 'owner locks' do
+      describe 'subject_type' do
+        let(:read_lock) { MyLock.new(subject_type: MySubject, action: :read, outcome: true) }
+        let(:owner) { MyOwner.new(my_locks: [read_lock]) }
+
+        it { ability.can?(:read, MySubject).must_equal true }
+        it { ability.cannot?(:read, MySubject).must_equal false }
+      end
+
+      describe 'subject_id' do
+        let(:my_subject) { MySubject.new }
+        let(:read_lock) { MyLock.new(subject: my_subject, action: :read, outcome: true) }
+        let(:owner) { MyOwner.new(my_locks: [read_lock]) }
+
+        it { ability.can?(:read, my_subject).must_equal true }
+        it { ability.cannot?(:read, my_subject).must_equal false }
       end
     end
   end

data/test/mongoid_ability/ability_marshal_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+module MongoidAbility
+  describe 'marshal' do
+    before(:all) { MySubject.default_lock MyLock, :read, true }
+
+    let(:read_lock) { MyLock.new(subject_type: MySubject1, action: :read, outcome: false) }
+    let(:owner) { MyRole.new(my_locks: [read_lock]) }
+    let(:ability) { Ability.new(owner) }
+
+    let(:ability_dump) { Marshal.dump(ability) }
+    let(:ability_load) { Marshal.load(ability_dump) }
+
+    it { ability_dump.must_be :present? }
+    it { ability_load.send(:rules).count.must_equal 2 }
+  end
+end

data/test/mongoid_ability/ability_options_test.rb

@@ -0,0 +1,93 @@
+require 'test_helper'
+
+module MongoidAbility
+  describe 'options test' do
+    let(:owner) { MyOwner.new }
+    let(:ability) { Ability.new(owner) }
+    let(:subject1) { MySubject.new }
+
+    describe 'Boolean' do
+      let(:subject2) { MySubject.new(override: true) }
+
+      describe 'positive' do
+        before(:all) { MySubject.default_lock MyLock, :read, true, override: true }
+
+        it { ability.can?(:read, subject1).must_equal false }
+        it { ability.can?(:read, subject2).must_equal true }
+      end
+
+      describe 'negative' do
+        before(:all) do
+          MySubject.default_lock MyLock, :read, true
+          MySubject.default_lock MyLock, :read, false, override: true
+        end
+
+        it { ability.can?(:read, subject1).must_equal true }
+        it { ability.can?(:read, subject2).must_equal false }
+      end
+    end
+
+    describe 'String' do
+      let(:subject2) { MySubject.new(str_val: "Jan Tschichold") }
+
+      describe 'positive' do
+        before(:all) { MySubject.default_lock MyLock, :read, true, str_val: 'Jan Tschichold' }
+
+        it { ability.can?(:read, subject1).must_equal false }
+        it { ability.can?(:read, subject2).must_equal true }
+      end
+
+      describe 'negative' do
+        before(:all) do
+          MySubject.default_lock MyLock, :read, true
+          MySubject.default_lock MyLock, :read, false, str_val: 'Jan Tschichold'
+        end
+
+        it { ability.can?(:read, subject1).must_equal true }
+        it { ability.can?(:read, subject2).must_equal false }
+      end
+    end
+
+    describe 'Regexp' do
+      let(:subject2) { MySubject.new(str_val: "Jan Tschichold") }
+
+      describe 'positive' do
+        before(:all) { MySubject.default_lock MyLock, :read, true, str_val: /tschichold/i }
+
+        it { ability.can?(:read, subject1).must_equal false }
+        it { ability.can?(:read, subject2).must_equal true }
+      end
+
+      describe 'negative' do
+        before(:all) do
+          MySubject.default_lock MyLock, :read, true
+          MySubject.default_lock MyLock, :read, false, str_val: /tschichold/i
+        end
+
+        it { ability.can?(:read, subject1).must_equal true }
+        it { ability.can?(:read, subject2).must_equal false }
+      end
+    end
+
+    describe 'Array' do
+      let(:subject2) { MySubject.new(str_val: "John") }
+
+      describe 'positive' do
+        before(:all) { MySubject.default_lock MyLock, :read, true, str_val: %w(John Paul George Ringo) }
+
+        it { ability.can?(:read, subject1).must_equal false }
+        it { ability.can?(:read, subject2).must_equal true }
+      end
+
+      describe 'negative' do
+        before(:all) do
+          MySubject.default_lock MyLock, :read, true
+          MySubject.default_lock MyLock, :read, false, str_val: %w(John Paul George Ringo)
+        end
+
+        it { ability.can?(:read, subject1).must_equal true }
+        it { ability.can?(:read, subject2).must_equal false }
+      end
+    end
+  end
+end

data/test/mongoid_ability/ability_test.rb

@@ -5,63 +5,44 @@ 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
-      # 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)] }
+      before(:all) { MySubject.default_lock MyLock, :update, true }
+      after(:all) { [MySubject, MySubject1, MySubject2, MySubject11, MySubject21].each(&:reset_default_locks!) }
 
       it 'propagates from superclass to all subclasses' 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
-              ability.can?(:update, MySubject).must_equal true
-              ability.can?(:update, MySubject1).must_equal true
-              ability.can?(:update, MySubject2).must_equal true
-            end
-          end
-        end
+        ability.can?(:update, MySubject).must_equal true
+        ability.can?(:update, MySubject1).must_equal true
+        ability.can?(:update, MySubject2).must_equal true
       end
     end
 
     describe 'when defined for all superclasses' do
-      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
-        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
+      before(:all) do
+        MySubject.default_lock MyLock, :read, false
+        MySubject1.default_lock MyLock, :read, true
+        MySubject2.default_lock MyLock, :read, false
       end
+
+      it { ability.can?(:read, MySubject).must_equal false }
+      it { ability.can?(:read, MySubject1).must_equal true }
+      it { ability.can?(:read, MySubject2).must_equal false }
     end
 
     describe 'when defined for some superclasses' do
-      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)] }
+      before(:all) do
+        MySubject.default_lock MyLock, :read, false
+        MySubject1.reset_default_locks!
+        MySubject2.default_lock MyLock, :read, true
+      end
 
       it 'propagates default locks to subclasses' 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
-              ability.can?(:read, MySubject).must_equal false
-              ability.can?(:read, MySubject1).must_equal false
-              ability.can?(:read, MySubject2).must_equal true
-            end
-          end
-        end
+        ability.can?(:read, MySubject).must_equal false
+        ability.can?(:read, MySubject1).must_equal false
+        ability.can?(:read, MySubject2).must_equal true
       end
     end
 
@@ -69,21 +50,10 @@ 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)] }
+        let(:owner) { MyOwner.new(my_locks: [MyLock.new(subject_type: MySubject, action: :read, outcome: true)]) }
+        before(:all) { MySubject.default_lock MyLock, :read, false }
 
-        before do
-          owner.my_locks = [MyLock.new(subject_type: MySubject, action: :read, outcome: true)]
-        end
-
-        it 'applies the superclass lock' 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
-                ability.can?(:read, MySubject2).must_equal true
-              end
-            end
-          end
-        end
+        it { ability.can?(:read, MySubject2).must_equal true }
       end
     end
 
@@ -91,42 +61,28 @@ 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
-          owner.my_roles = [
+        let(:owner) do
+          MyOwner.new(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)])
-          ]
+            MyRole.new(my_locks: [MyLock.new(subject_type: MySubject, action: :read, outcome: false)]),
+          ])
         end
 
-        it 'prefers positive outcome' 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
-                ability.can?(:read, MySubject).must_equal true
-              end
-            end
-          end
-        end
+        before(:all) { MySubject.default_lock MyLock, :read, false }
+
+        it { ability.can?(:read, MySubject).must_equal true }
       end
 
       describe 'when defined for superclass' do
-        let(:my_subject_default_locks) { [MyLock.new(subject_type: MySubject, action: :read, outcome: false)] }
-
-        before do
-          owner.my_roles = [MyRole.new(my_locks: [MyLock.new(subject_type: MySubject, action: :read, outcome: true)])]
+        let(:owner) do
+          MyOwner.new(my_roles: [
+            MyRole.new(my_locks: [MyLock.new(subject_type: MySubject, action: :read, outcome: true)])
+          ])
         end
 
-        it 'applies the superclass lock' 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
-                ability.can?(:read, MySubject2).must_equal true
-              end
-            end
-          end
-        end
+        before(:all) { MySubject.default_lock MyLock, :read, false }
+
+        it { ability.can?(:read, MySubject2).must_equal true }
       end
     end
 
@@ -134,40 +90,65 @@ 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)] }
+        let(:role_lock) { MyLock.new(subject_type: MySubject, action: :read, outcome: true) }
+        let(:owner_lock) { MyLock.new(subject_type: MySubject, action: :read, outcome: false) }
 
-        before do
-          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
+        let(:role) { MyRole.new(my_locks: [role_lock]) }
+        let(:owner) { MyOwner.new(my_locks: [owner_lock], my_roles: [role]) }
 
-        it 'prefers user locks' 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
-                ability.can?(:read, MySubject).must_equal false
-              end
-            end
-          end
-        end
+        before(:all) { MySubject.default_lock MyLock, :read, false }
+
+        it { ability.can?(:read, MySubject).must_equal false }
       end
 
       describe 'roles and default locks' do
-        let(:my_subject_default_locks) { [MyLock.new(subject_type: MySubject, action: :read, outcome: false)] }
+        describe 'negative positive' do
+          before(:all) { MySubject.default_lock MyLock, :read, false }
+
+          let(:lock) { MyLock.new(subject_type: MySubject, action: :read, outcome: true) }
+          let(:role) { MyRole.new(my_locks: [lock]) }
+          let(:owner) { MyOwner.new(my_roles: [role]) }
+
+          it { ability.can?(:read, MySubject).must_equal true }
 
-        before do
-          owner.my_roles = [MyRole.new(my_locks: [MyLock.new(subject_type: MySubject, action: :read, outcome: true)])]
+          describe 'subclass' do
+            let(:lock) { MyLock.new(subject_type: MySubject1, action: :read, outcome: true) }
+
+            it { ability.can?(:read, MySubject).must_equal false }
+            it { ability.can?(:read, MySubject1).must_equal true }
+          end
         end
 
-        it 'prefers role locks' 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
-                ability.can?(:read, MySubject).must_equal true
-              end
-            end
+        describe 'positive negative' do
+          before(:all) { MySubject.default_lock MyLock, :read, true }
+
+          let(:lock) { MyLock.new(subject_type: MySubject, action: :read, outcome: false) }
+          let(:role) { MyRole.new(my_locks: [lock]) }
+          let(:owner) { MyOwner.new(my_roles: [role]) }
+
+          it { ability.can?(:read, MySubject).must_equal false }
+
+          describe 'subclass' do
+            let(:lock) { MyLock.new(subject_type: MySubject1, action: :read, outcome: false) }
+
+            it { ability.can?(:read, MySubject).must_equal true }
+            it { ability.can?(:read, MySubject1).must_equal false }
           end
         end
+
+        describe 'positive negative positive' do
+          before(:all) do
+            MySubject.default_lock MyLock, :read, true
+            MySubject1.default_lock MyLock, :read, false
+          end
+
+          let(:lock) { MyLock.new(subject_type: MySubject, action: :read, outcome: true) }
+          let(:role) { MyRole.new(my_locks: [lock]) }
+          let(:owner) { MyOwner.new(my_roles: [role]) }
+
+          it { ability.can?(:read, MySubject).must_equal true }
+          it { ability.can?(:read, MySubject1).must_equal false }
+        end
       end
     end
   end