mongoid_ability 0.0.11 → 0.1.0

data/test/mongoid_ability/accessible_query_builder_test.rb

@@ -3,18 +3,22 @@ require "test_helper"
 module MongoidAbility
   describe AccessibleQueryBuilder do
 
-    let(:base_class) { SubjectTest }
-    
-    let(:user) { TestUser.new }
-    let(:ability) { Ability.new(user) }
+    let(:base_class) { MySubject }
+
+    let(:owner) { MyOwner.new }
+    let(:ability) { Ability.new(owner) }
 
     let(:action) { :read }
 
     subject { AccessibleQueryBuilder.call(base_class, ability, action) }
 
+    before do
+      MySubject.default_locks = [ MyLock.new(subject_type: MySubject, action: :read, outcome: false) ]
+    end
+
     it 'returns Mongoid::Criteria' do
       subject.must_be_kind_of Mongoid::Criteria
     end
 
   end
-end
+end

data/test/mongoid_ability/can_options_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+module MongoidAbility
+  describe 'can options test' do
+    let(:owner) { MyOwner.new }
+    let(:ability) { Ability.new(owner) }
+
+    before do
+      MySubject.default_locks = [ MyLock1.new(action: :read, outcome: false) ]
+    end
+
+    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
+    end
+  end
+end

data/test/mongoid_ability/lock_test.rb

@@ -3,92 +3,73 @@ require 'test_helper'
 module MongoidAbility
   describe Lock do
 
-    let(:subject_test) { SubjectTest.new }
-    subject { TestLock.new }
-    
-    # =====================================================================
-
-    describe 'fields' do
-      it 'has :action' do
-        subject.must_respond_to :action
-        subject.action.must_be_kind_of Symbol
-      end
+    subject { MyLock.new }
+    let(:my_subject) { MySubject.new }
+    let(:inherited_lock) { MyLock1.new }
 
-      it 'has :outcome' do
-        subject.must_respond_to :outcome
-        subject.outcome.must_equal false
-      end
-    end
+    # ---------------------------------------------------------------------
 
-    # =====================================================================
-      
-    describe 'associations' do
-      it 'embedded in :owner' do
-        subject.must_respond_to :owner
-        subject.relations['owner'].macro.must_equal :embedded_in
-      end
+    it { subject.must_respond_to :action }
+    it { subject.must_respond_to :outcome }
+    it { subject.must_respond_to :subject }
+    it { subject.must_respond_to :subject_id }
+    it { subject.must_respond_to :subject_type }
+    it { subject.must_respond_to :owner }
 
-      it 'belongs to :subject' do
-        subject.must_respond_to :subject
-        subject.must_respond_to :subject_type
-        subject.must_respond_to :subject_id
-      end
+    # ---------------------------------------------------------------------
+
+    it '#open?' do
+      subject.must_respond_to :open?
+      subject.open?.must_equal false
+    end
+    it '#closed?' do
+      subject.must_respond_to :closed?
+      subject.closed?.must_equal true
+    end
+    it '#class_lock?' do
+      subject.must_respond_to :class_lock?
+    end
+    it '#id_lock?' do
+      subject.must_respond_to :id_lock?
     end
-    
-    # =====================================================================
 
-    describe 'instance methods' do
-      it 'has #open?' do
-        subject.must_respond_to :open?
-        subject.open?.must_equal false
-      end
-      it 'has #closed?' do
-        subject.must_respond_to :closed?
-        subject.closed?.must_equal true
-      end
-      it 'has #class_lock?' do
-        subject.must_respond_to :class_lock?
-      end
-      it 'has #id_lock?' do
-        subject.must_respond_to :id_lock?
-      end
+    # ---------------------------------------------------------------------
 
-      describe '#criteria' do
-        let(:open_subject_type_lock) {  TestLock.new(subject_type: subject_test.class.to_s, action: :read, outcome: true) }
-        let(:closed_subject_type_lock) {  TestLock.new(subject_type: subject_test.class.to_s, action: :read, outcome: false) }
+    describe '#criteria' do
+      let(:open_subject_type_lock) {  MyLock.new(subject_type: MySubject, action: :read, outcome: true) }
+      let(:closed_subject_type_lock) {  MyLock.new(subject_type: MySubject, action: :read, outcome: false) }
 
-        let(:open_subject_lock) {  TestLock.new(subject: subject_test, action: :read, outcome: true) }
-        let(:closed_subject_lock) {  TestLock.new(subject: subject_test, action: :read, outcome: false) }
+      let(:open_subject_lock) {  MyLock.new(subject: my_subject, action: :read, outcome: true) }
+      let(:closed_subject_lock) {  MyLock.new(subject: my_subject, action: :read, outcome: false) }
 
-        it 'returns conditions Hash' do
-          open_subject_type_lock.conditions.must_be_kind_of Hash
-          closed_subject_type_lock.conditions.must_be_kind_of Hash
+      it 'returns conditions Hash' do
+        open_subject_type_lock.conditions.must_be_kind_of Hash
+        closed_subject_type_lock.conditions.must_be_kind_of Hash
 
-          open_subject_lock.conditions.must_be_kind_of Hash
-          closed_subject_lock.conditions.must_be_kind_of Hash
-        end
+        open_subject_lock.conditions.must_be_kind_of Hash
+        closed_subject_lock.conditions.must_be_kind_of Hash
+      end
 
-        describe 'when open' do
-          it 'includes subject_type' do
-            open_subject_type_lock.conditions.must_equal({ _type: open_subject_type_lock.subject_type })
-          end
+      describe 'when open' do
+        it 'includes subject_type' do
+          open_subject_type_lock.conditions.must_equal({ _type: open_subject_type_lock.subject_type })
+        end
 
-          it 'includes id' do
-            open_subject_lock.conditions.must_equal({ _type: open_subject_type_lock.subject_type, _id: open_subject_lock.subject_id })
-          end
+        it 'includes id' do
+          open_subject_lock.conditions.must_equal({ _type: open_subject_type_lock.subject_type, _id: open_subject_lock.subject_id })
         end
+      end
 
-        describe 'when closed' do
-          it 'excludes subject_type' do
-            closed_subject_type_lock.conditions.must_equal({ '$not' => { _type: open_subject_type_lock.subject_type }})
-          end
+      describe 'when closed' do
+        it 'excludes subject_type' do
+          closed_subject_type_lock.conditions.must_equal({ '$not' => { _type: open_subject_type_lock.subject_type }})
+        end
 
-          it 'includes id' do
-            closed_subject_lock.conditions.must_equal({ '$not' => { _type: open_subject_type_lock.subject_type, _id: open_subject_lock.subject_id }})
-          end
+        it 'includes id' do
+          closed_subject_lock.conditions.must_equal({ '$not' => { _type: open_subject_type_lock.subject_type, _id: open_subject_lock.subject_id }})
         end
       end
     end
 
   end
-end
+end

data/test/mongoid_ability/owner_locks_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+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) }
+
+    # ---------------------------------------------------------------------
+
+    before do
+      MySubject.default_locks = [ MyLock.new(subject_type: MySubject, action: :read, outcome: true) ]
+    end
+
+    # ---------------------------------------------------------------------
+
+    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
+      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
+      end
+    end
+
+  end
+end

data/test/mongoid_ability/owner_test.rb

@@ -2,52 +2,25 @@ require 'test_helper'
 
 module MongoidAbility
   describe Owner do
+    subject { MyOwner.new }
 
-    subject { TestOwner.new }
+    describe '#cleanup_locks' do
+      let(:closed_lock) { MyLock.new(action: :read, outcome: false, subject_type: Object.to_s) }
+      let(:open_lock) { MyLock1.new(action: :read, outcome: true, subject_type: Object.to_s) }
 
-    # =====================================================================
-
-    describe 'fields' do
-    end
-
-    # =====================================================================
-
-    describe 'associations' do
-    end
-
-    # =====================================================================
-
-    describe 'class methods' do
-      describe 'lock_class_name' do
-        it 'finds class that includes the MongoidAbility::Lock module' do
-          TestOwner.lock_class_name.must_equal 'TestLock'
-        end
+      before do
+        subject.my_locks = [open_lock, closed_lock].shuffle
+        subject.run_callbacks(:save)
       end
 
-      describe 'locks_relation_name' do
-        it 'finds the name of relation that contains locks' do
-          TestOwner.locks_relation_name.must_equal :test_locks
-        end
+      it 'prefers closed locks' do
+        subject.my_locks.sort.must_equal [closed_lock].sort
       end
-    end
-
-    # =====================================================================
 
-    describe 'instance methods' do
-      describe 'cleanup_locks' do
-        let(:closed_lock) { TestLock.new(action: :read, outcome: false, subject_type: Object.to_s) }
-        let(:open_lock) { TestLock.new(action: :read, outcome: true, subject_type: Object.to_s) }
-
-        before do
-          subject.test_locks = [open_lock, closed_lock].shuffle
-          subject.run_callbacks(:save)
-        end
-
-        it 'prefers closed locks' do
-          subject.test_locks.sort.must_equal [closed_lock].sort
-        end
+      describe 'locks relation' do
+        it { subject.class.locks_relation_name.must_equal :my_locks }
+        it { subject.locks_relation.metadata[:name].must_equal :my_locks }
       end
     end
-
   end
 end

data/test/mongoid_ability/resolve_default_locks_test.rb

@@ -0,0 +1,27 @@
+require "test_helper"
+
+module MongoidAbility
+  describe ResolveDefaultLocks do
+
+    describe '.call' do
+      before do
+        MySubject.default_locks = [
+          MyLock.new(subject_type: MySubject, action: :read, outcome: true),
+          MyLock.new(subject_type: MySubject, action: :update, outcome: false)
+        ]
+
+        MySubject1.default_locks = [
+          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 { ResolveDefaultLocks.call(nil, :read, MySubject1, nil, {}).must_equal false }
+      it { ResolveDefaultLocks.call(nil, :update, MySubject1, nil, {}).must_equal true }
+    end
+
+  end
+end

data/test/mongoid_ability/resolve_inherited_locks_test.rb

@@ -0,0 +1,49 @@
+require "test_helper"
+
+module MongoidAbility
+  describe ResolveInheritedLocks do
+
+    describe 'when defined on class' do
+      let(:owner) { MyOwner.new }
+      let(:my_subject) { MySubject.new }
+
+      before { MySubject.default_locks = [ MyLock.new(subject_type: MySubject, action: :my_read, outcome: true) ] }
+
+      # ---------------------------------------------------------------------
+      
+      it 'returns it' do
+        ResolveInheritedLocks.call(owner, :my_read, MySubject, nil).must_equal true
+        ResolveInheritedLocks.call(owner, :my_read, MySubject, my_subject).must_equal true
+      end
+
+      # ---------------------------------------------------------------------
+
+      describe 'when defined on one of the inherited owners' do
+        let(:inherited_owner_1) { MyOwner.new }
+        let(:inherited_owner_2) { MyOwner.new }
+        let(:owner) { MyOwner.new(my_roles: [inherited_owner_1, inherited_owner_2]) }
+        let(:my_subject) { MySubject.new }
+
+        before { inherited_owner_1.my_locks = [ MyLock.new(action: :my_read, subject_type: MySubject, outcome: false) ] }
+
+        it 'returns it' do
+          ResolveInheritedLocks.call(owner, :my_read, MySubject, nil).must_equal false
+          ResolveInheritedLocks.call(owner, :my_read, MySubject, my_subject).must_equal false
+        end
+
+        # ---------------------------------------------------------------------
+
+        describe 'when defined on user' do
+          before { owner.my_locks = [ MyLock.new(action: :my_read, subject_type: MySubject, outcome: true) ] }
+
+          it 'returns it' do
+            ResolveInheritedLocks.call(owner, :my_read, MySubject, nil).must_equal true
+            ResolveInheritedLocks.call(owner, :my_read, MySubject, my_subject).must_equal true
+          end
+        end
+
+      end
+    end
+
+  end
+end

data/test/mongoid_ability/resolve_locks_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+module MongoidAbility
+  describe ResolveLocks do
+
+    let(:owner) { MyOwner.new }
+
+    describe 'errors' do
+      it 'raises NameError for invalid subject_type' do
+        -> { ResolveLocks.call(owner, :read, 'Foo') }.must_raise NameError
+      end
+
+      it 'raises StandardError when subject_type does not have default_locks' do
+        -> { ResolveLocks.call(owner, :read, Object) }.must_raise StandardError
+      end
+
+      it 'raises StandardError when subject_type class or its ancestors does not have default_lock' do
+        MySubject.stub(:default_locks, []) do
+          -> { ResolveLocks.call(owner, :read, MySubject) }.must_raise StandardError
+        end
+      end
+    end
+
+  end
+end

data/test/mongoid_ability/resolve_owner_locks_test.rb

@@ -0,0 +1,50 @@
+require "test_helper"
+
+module MongoidAbility
+  describe ResolveOwnerLocks do
+    let(:owner) { MyOwner.new }
+    let(:my_subject) { MySubject.new }
+
+    subject { ResolveOwnerLocks.call(owner, :read, MySubject, nil) }
+    let(:resolver_for_subject_id) { ResolveOwnerLocks.call(owner, :read, MySubject, my_subject) }
+
+    # =====================================================================
+
+    describe '#outcome' do
+      before do
+        MySubject.default_locks = [ MyLock.new(subject_type: MySubject, action: :read, outcome: false) ]
+      end
+
+      describe 'no locks' do
+        it { subject.must_be_nil }
+      end
+
+      describe 'id locks' do
+        it 'returns outcome' do
+          owner.my_locks = [ MyLock.new(action: :read, subject: my_subject, outcome: true) ]
+          resolver_for_subject_id.must_equal true
+        end
+
+        it 'prefers negative outcome' do
+          owner.my_locks = [ MyLock.new(action: :read, subject: my_subject, outcome: true),
+                             MyLock.new(action: :read, subject: my_subject, outcome: false) ]
+          resolver_for_subject_id.must_equal false
+        end
+      end
+
+      describe 'class locks' do
+        it 'returns outcome' do
+          owner.my_locks = [ MyLock.new(action: :read, subject_type: MySubject, outcome: true) ]
+          subject.must_equal true
+        end
+
+        it 'prefers negative outcome' do
+          owner.my_locks = [ MyLock.new(action: :read, subject_type: MySubject, outcome: true),
+                             MyLock.new(action: :read, subject_type: MySubject, outcome: false) ]
+          subject.must_equal false
+        end
+      end
+    end
+
+  end
+end