mongoid_ability 1.0.0 → 2.0.0

data/test/mongoid_ability/find_lock_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+
+module MongoidAbility
+  describe FindLock do
+    let(:owner) { MyOwner.new }
+
+    describe 'default lock' do
+      before { MySubject.default_lock MyLock, :read, true }
+
+      it { FindLock.call(owner, :read, MySubject).must_equal MySubject.default_locks.for_action(:read).first }
+      it { FindLock.call(owner, :read, MySubject1).must_equal MySubject.default_locks.for_action(:read).first }
+    end
+
+    describe 'inherited lock' do
+      before { 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 { FindLock.call(owner, :read, MySubject).must_equal lock }
+
+      describe 'conflicting locks' do
+        let(:lock_1) { MyLock.new(subject_type: MySubject, action: :read, outcome: true) }
+        let(:lock_2) { MyLock.new(subject_type: MySubject, action: :read, outcome: false) }
+
+        let(:role_1) { MyRole.new(my_locks: [lock_1]) }
+        let(:role_2) { MyRole.new(my_locks: [lock_2]) }
+        let(:owner) { MyOwner.new(my_roles: [role_1, role_2]) }
+
+        it { FindLock.call(owner, :read, MySubject).must_equal lock_1 }
+      end
+
+      describe 'id lock' do
+        let(:my_subject) { MySubject.new }
+        let(:other_subject) { MySubject.new }
+        let(:lock_1) { MyLock.new(subject_type: my_subject.model_name, subject_id: my_subject.id, action: :read, outcome: false) }
+        let(:lock_2) { MyLock.new(subject_type: other_subject.model_name, subject_id: other_subject.id, action: :read, outcome: false) }
+        let(:role) { MyRole.new(my_locks: [lock_1, lock_2]) }
+        let(:owner) { MyOwner.new(my_roles: [role]) }
+
+        it { FindLock.call(owner, :read, MySubject).must_equal MySubject.default_locks.for_action(:read).first }
+        it { FindLock.call(owner, :read, my_subject.class, my_subject.id).must_equal lock_1 }
+      end
+    end
+
+    describe 'owned lock' do
+      before { MySubject.default_lock MyLock, :read, true }
+
+      let(:lock) { MyLock.new(subject_type: MySubject, action: :read, outcome: false) }
+      let(:owner) { MyOwner.new(my_locks: [lock]) }
+
+      it { FindLock.call(owner, :read, MySubject).must_equal lock }
+
+      describe 'id lock' do
+        let(:my_subject) { MySubject.new }
+        let(:other_subject) { MySubject.new }
+        let(:lock_1) { MyLock.new(subject_type: my_subject.model_name, subject_id: my_subject.id, action: :read, outcome: false) }
+        let(:lock_2) { MyLock.new(subject_type: other_subject.model_name, subject_id: other_subject.id, action: :read, outcome: false) }
+        let(:owner) { MyOwner.new(my_locks: [lock_1, lock_2]) }
+
+        it { FindLock.call(owner, :read, MySubject).must_equal MySubject.default_locks.for_action(:read).first }
+        it { FindLock.call(owner, :read, my_subject.class, my_subject.id).must_equal lock_1 }
+      end
+    end
+  end
+end

data/test/mongoid_ability/lock_test.rb

@@ -3,13 +3,10 @@ require 'test_helper'
 module MongoidAbility
   describe Lock do
     subject { MyLock.new }
+
     let(:my_subject) { MySubject.new }
     let(:inherited_lock) { MyLock1.new }
 
-    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) { [] }
-
     # ---------------------------------------------------------------------
 
     it { subject.must_respond_to :action }
@@ -55,47 +52,42 @@ module MongoidAbility
 
     # ---------------------------------------------------------------------
 
+    describe 'sort' do
+      let(:lock0) { MyLock.new(subject_type: MySubject, action: :update, outcome: false) }
+      let(:lock1) { MyLock.new(subject_type: MySubject, action: :update, outcome: true) }
+      let(:lock2) { MyLock.new(subject_type: MySubject, action: :read, outcome: false, options: { override: true }) }
+      let(:lock3) { MyLock.new(subject_type: MySubject, action: :read, outcome: false) }
+      let(:lock4) { MyLock.new(subject_type: MySubject, action: :read, outcome: true) }
+
+      let(:owner) { MyOwner.new(my_locks: [lock1, lock2, lock3, lock4]) }
+
+      let(:sorted_locks) { owner.my_locks.sort(&Lock.sort) }
+
+      it { sorted_locks[0].must_equal lock4 }
+      it { sorted_locks[3].must_equal lock1 }
+    end
+
+    # ---------------------------------------------------------------------
+
     describe '#inherited_outcome' do
-      let(:my_subject) { MySubject.new }
-      let(:subject_type_lock) { MyLock.new(subject_type: MySubject, action: :read, outcome: false) }
-      let(:subject_lock) { MyLock.new(subject: my_subject, action: :read, outcome: true) }
-      let(:owner) { MyOwner.new(my_locks: [subject_type_lock, subject_lock]) }
+      before(:all) { MySubject.default_lock MyLock, :read, true }
 
-      before do
-        @ability = Ability.new(owner) # initialize owner
-      end
+      let(:owner) { MyOwner.new(my_locks: [
+        MyLock.new(subject_type: MySubject, action: :read, outcome: false),
+        MyLock.new(subject: my_subject, action: :read, outcome: true)
+      ]) }
 
-      it 'does not affect calculated_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, my_subject).must_equal true
-            end
-          end
-        end
-      end
+      let(:ability) { Ability.new(owner) }
 
-      it 'returns calculated_outcome without this 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
-              subject_lock.inherited_outcome.must_equal false
-              subject_type_lock.inherited_outcome.must_equal true
-            end
-          end
-        end
-      end
+      let(:subject_type_lock) { owner.my_locks.detect(&:class_lock?) }
+      let(:subject_lock) { owner.my_locks.detect(&:id_lock?) }
+      let(:default_lock) { MySubject.default_locks.detect { |l| l.action == :read } }
 
-      it 'returns calculated_outcome for default 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
-              lock = MySubject.default_locks.detect { |l| l.action == :read }
-              lock.inherited_outcome.must_equal true
-            end
-          end
-        end
-      end
+      it { ability.can?(:read, my_subject).must_equal true }
+
+      it { subject_lock.inherited_outcome.must_equal false }
+      it { subject_type_lock.inherited_outcome.must_equal true }
+      it { default_lock.inherited_outcome.must_equal true }
     end
   end
 end

data/test/mongoid_ability/owner_locks_test.rb

@@ -4,34 +4,27 @@ module MongoidAbility
   describe 'owner locks test' do
     subject { MySubject.new }
 
-    let(:subject_lock) { MyLock.new(action: :read, subject: subject, outcome: false) }
-    let(:subject_type_lock) { MyLock.new(action: :read, subject_type: subject.class, outcome: false) }
-
     let(:owner) { MyOwner.new }
     let(:ability) { Ability.new(owner) }
 
-    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
-        MySubject.stub :default_locks, default_locks do
-          ability.can?(:read, subject.class).must_equal true
-          ability.can?(:read, subject).must_equal false
-        end
-      end
+      let(:subject_lock) { MyLock.new(action: :read, subject: subject, outcome: false) }
+      let(:owner) { MyOwner.new(my_locks: [subject_lock]) }
+
+      before(:all) { MySubject.default_lock MyLock, :read, true }
+
+      it { ability.can?(:read, subject.class).must_equal true }
+      it { ability.can?(:read, subject).must_equal false }
     end
 
     describe 'when lock for subject type' do
-      before { owner.my_locks = [subject_type_lock] }
-
-      it 'applies it' do
-        MySubject.stub :default_locks, default_locks do
-          ability.can?(:read, subject.class).must_equal false
-          ability.can?(:read, subject).must_equal false
-        end
-      end
+      let(:subject_type_lock) { MyLock.new(action: :read, subject_type: subject.class, outcome: false) }
+      let(:owner) { MyOwner.new(my_locks: [subject_type_lock]) }
+
+      before(:all) { MySubject.default_lock MyLock, :read, true }
+
+      it { ability.can?(:read, subject.class).must_equal false }
+      it { ability.can?(:read, subject).must_equal false }
     end
   end
 end

data/test/mongoid_ability/owner_test.rb

@@ -13,9 +13,7 @@ module MongoidAbility
         subject.run_callbacks(:save)
       end
 
-      it 'prefers closed locks' do
-        subject.my_locks.sort.must_equal [closed_lock].sort
-      end
+      it { subject.my_locks.sort(&Lock.sort).must_equal [closed_lock].sort(&Lock.sort) }
 
       describe 'locks relation' do
         it { subject.class.locks_relation_name.must_equal :my_locks }
@@ -29,17 +27,9 @@ module MongoidAbility
       let(:other_lock) { MyLock.new(action: :update, subject: MySubject.new) }
       let(:owner) { MyOwner.new(my_locks: [subject_type_lock, subject_lock]) }
 
-      it 'returns true when lock for same action & subject_type' do
-        owner.has_lock?(subject_type_lock).must_equal true
-      end
-
-      it 'returns true when lock for same action & subject' do
-        owner.has_lock?(subject_lock).must_equal true
-      end
-
-      it 'returns false for non existing lock' do
-        owner.has_lock?(other_lock).must_equal false
-      end
+      it { owner.has_lock?(subject_type_lock).must_equal true }
+      it { owner.has_lock?(subject_lock).must_equal true }
+      it { owner.has_lock?(other_lock).must_equal false }
     end
   end
 end

data/test/mongoid_ability/subject_test.rb

@@ -2,79 +2,53 @@ require 'test_helper'
 
 module MongoidAbility
   describe Subject do
-    let(:my_subject_default_locks) { [] }
-    let(:my_subject_1_default_locks) { [] }
-    let(:my_subject_2_default_locks) { [] }
-
     describe '.default_lock' do
-      it 'stores them' 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
-              MySubject.default_lock MyLock, :read, true
-              MySubject.default_lock MyLock, :update, true
-              MySubject1.default_lock MyLock1, :update, false
-
-              MySubject.default_locks.map(&:action).map(&:to_s).sort.must_equal %w(read update)
-              MySubject1.default_locks.map(&:action).map(&:to_s).sort.must_equal %w(update)
-            end
-          end
-        end
+      before(:all) do
+        MySubject.default_lock MyLock, :read, true
+        MySubject.default_lock MyLock, :update, true
+        MySubject1.default_lock MyLock1, :update, false
       end
+
+      it { MySubject.default_locks.map(&:action).map(&:to_s).sort.must_equal %w(read update) }
+      it { MySubject1.default_locks.map(&:action).map(&:to_s).sort.must_equal %w(update) }
     end
 
     describe 'prevents conflicts' do
-      it 'does not allow multiple locks for same action' 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
-              MySubject.default_lock MyLock1, :read, false
-              MySubject1.default_lock MyLock, :read, true
-
-              MySubject.default_locks.count { |l| l.action == :read }.must_equal 1
-            end
-          end
+      describe 'multiple locks for same action' do
+        before(:all) do
+          MySubject.default_lock MyLock1, :read, false
+          MySubject1.default_lock MyLock, :read, true
         end
-      end
 
-      it 'replace existing locks with new attributes' 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
-              MySubject.default_lock MyLock1, :read, false
-              MySubject1.default_lock MyLock, :read, true
+        it { MySubject.default_locks.count { |l| l.action == :read }.must_equal 1 }
+      end
 
-              MySubject.default_locks.detect { |l| l.action == :read }.outcome.must_equal false
-            end
-          end
+      describe 'replace existing locks with new attributes' do
+        before(:all) do
+          MySubject.default_lock MyLock1, :read, false
+          MySubject1.default_lock MyLock, :read, true
         end
-      end
 
-      it 'replaces existing locks with new one' 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
-              MySubject.default_lock MyLock1, :read, false
-              MySubject1.default_lock MyLock, :read, true
+        it { MySubject.default_locks.detect { |l| l.action == :read }.outcome.must_equal false }
+      end
 
-              MySubject.default_locks.detect { |l| l.action == :read }.class.must_equal MyLock1
-            end
-          end
+      describe 'replaces existing locks with new one' do
+        before(:all) do
+          MySubject.default_lock MyLock1, :read, false
+          MySubject1.default_lock MyLock, :read, true
         end
-      end
 
-      it 'replaces superclass 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
-              MySubject.default_lock MyLock1, :read, false
-              MySubject1.default_lock MyLock, :read, true
+        it { MySubject.default_locks.detect { |l| l.action == :read }.class.must_equal MyLock1 }
+      end
 
-              MySubject1.default_locks.count.must_equal 1
-              MySubject1.default_locks.detect { |l| l.action == :read }.outcome.must_equal true
-            end
-          end
+      describe 'replaces superclass locks' do
+        before(:all) do
+          MySubject.default_lock MyLock1, :read, false
+          MySubject1.default_lock MyLock, :read, true
         end
+
+        it { MySubject1.default_locks.count.must_equal 1 }
+        it { MySubject1.default_locks.detect { |l| l.action == :read }.outcome.must_equal true }
       end
     end
 

data/test/support/test_classes/my_lock.rb

@@ -1,15 +1,10 @@
-module MongoidAbility
-  class MyLock
-    include Mongoid::Document
-    include Mongoid::Timestamps
-    include MongoidAbility::Lock
-    
-    embedded_in :owner, polymorphic: true, touch: true
-  end
+class MyLock
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  include MongoidAbility::Lock
 
-  class MyLock1 < MyLock
-    def calculated_outcome(opts = {})
-      opts.fetch(:override, outcome)
-    end
-  end
+  embedded_in :owner, polymorphic: true, touch: true
+end
+
+class MyLock1 < MyLock
 end

data/test/support/test_classes/my_owner.rb

@@ -1,21 +1,19 @@
-module MongoidAbility
-  class MyOwner
-    include Mongoid::Document
-    include Mongoid::Timestamps
-    include MongoidAbility::Owner
+class MyOwner
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  include MongoidAbility::Owner
 
-    embeds_many :my_locks, class_name: 'MongoidAbility::MyLock', as: :owner
-    has_and_belongs_to_many :my_roles
+  embeds_many :my_locks, class_name: 'MyLock', as: :owner
+  has_and_belongs_to_many :my_roles
 
-    def self.locks_relation_name
-      :my_locks
-    end
-
-    def self.inherit_from_relation_name
-      :my_roles
-    end
+  def self.locks_relation_name
+    :my_locks
   end
 
-  class MyOwner1 < MyOwner
+  def self.inherit_from_relation_name
+    :my_roles
   end
 end
+
+class MyOwner1 < MyOwner
+end

data/test/support/test_classes/my_role.rb

@@ -1,16 +1,14 @@
-module MongoidAbility
-  class MyRole
-    include Mongoid::Document
-    include MongoidAbility::Owner
+class MyRole
+  include Mongoid::Document
+  include MongoidAbility::Owner
 
-    embeds_many :my_locks, class_name: 'MongoidAbility::MyLock', as: :owner
-    has_and_belongs_to_many :my_owners
+  embeds_many :my_locks, class_name: 'MyLock', as: :owner
+  has_and_belongs_to_many :my_owners
 
-    def self.locks_relation_name
-      :my_locks
-    end
+  def self.locks_relation_name
+    :my_locks
   end
+end
 
-  class MyRole1 < MyRole
-  end
+class MyRole1 < MyRole
 end

data/test/support/test_classes/my_subject.rb

@@ -1,12 +1,19 @@
-module MongoidAbility
-  class MySubject
-    include Mongoid::Document
-    include MongoidAbility::Subject
-  end
+class MySubject
+  include Mongoid::Document
+  include MongoidAbility::Subject
 
-  class MySubject1 < MySubject
-  end
+  field :str_val, type: String
+  field :override, type: Boolean, default: false
+end
+
+class MySubject1 < MySubject
+end
+
+class MySubject11 < MySubject
+end
+
+class MySubject2 < MySubject1
+end
 
-  class MySubject2 < MySubject1
-  end
+class MySubject21 < MySubject11
 end