permissioner 0.0.2.beta → 0.1.0.beta

data/spec/permissioner/matchers/exactly_expect_actions_spec.rb

@@ -0,0 +1,188 @@
+require 'spec_helper'
+
+describe Permissioner::Matchers::ExactlyExpectActions do
+
+  let(:permission_service) do
+    permission_service = PermissionService.new
+    permission_service.allow_actions :comments, [:index, :show, :new, :create]
+    permission_service.allow_actions :users, [:show, :new, :create]
+    permission_service.allow_actions :posts, [:show, :edit, :update]
+    permission_service
+  end
+
+  def create_matcher(*all_expected_actions)
+    Permissioner::Matchers::ExactlyExpectActions.new(:@allowed_actions, *all_expected_actions)
+  end
+
+  describe '#initialize' do
+
+    it 'should transform expected_actions into string array' do
+      matcher = create_matcher [:controller, :action]
+      matcher.instance_variable_get(:@all_expected_actions).should eq [['controller', ['action']]]
+      matcher = create_matcher [:controller, [:action_1, :action_2]]
+      matcher.instance_variable_get(:@all_expected_actions).should eq [['controller', ['action_1', 'action_2']]]
+    end
+
+    it 'should raise an exception if multiple actions not stated as array' do
+      expect {
+        create_matcher [:controller, :action_1, :action_2]
+      }.to raise_exception "multiple actions for a controller must stated as array, e.g. [:new, :create]"
+    end
+  end
+
+  describe '#matches' do
+
+    context 'on success' do
+
+      it 'should return true if all expected controllers with actions are exactly allowed' do
+        matcher = create_matcher(
+            [:comments, [:index, :show, :new, :create]],
+            [:users, [:show, :new, :create]],
+            [:posts, [:show, :edit, :update]]
+        )
+        matcher.matches?(permission_service).should be_true
+      end
+
+      it 'should return true if for a given controller all actions are allowed and all is expected' do
+        permission_service.allow_actions :comments, :all
+        matcher = create_matcher(
+            [:comments, :all],
+            [:users, [:show, :new, :create]],
+            [:posts, [:show, :edit, :update]]
+        )
+        matcher.matches?(permission_service).should be_true
+      end
+    end
+
+    context 'if controllers did not match' do
+
+      it 'should return false if at least one expected controller is not allowed' do
+        matcher = create_matcher(
+            [:comments, [:index, :show, :new, :create]],
+            [:users, [:show, :new, :create]],
+            [:accounts, [:show, :edit, :update]]
+        )
+        matcher.matches?(permission_service).should be_false
+      end
+
+      it 'should return false if at least one controller is allowed but no expected' do
+        matcher = create_matcher(
+            [:comments, [:index, :show, :new, :create]],
+            [:users, [:show, :new, :create]]
+        )
+        matcher.matches?(permission_service).should be_false
+      end
+    end
+
+    context 'if actions for controllers did not match' do
+
+      it 'should return false if at least one expected action is not allowed' do
+        matcher = create_matcher(
+            [:comments, [:update, :show, :new, :create]],
+            [:users, [:show, :new, :create]],
+            [:posts, [:show, :edit, :update]]
+        )
+        matcher.matches?(permission_service).should be_false
+      end
+
+      it 'should return false if at least one action is not allowed but no expected' do
+        matcher = create_matcher(
+            [:comments, [:index, :show, :new]],
+            [:users, [:show, :new, :create]],
+            [:posts, [:show, :edit, :update]]
+        )
+        matcher.matches?(permission_service).should be_false
+      end
+    end
+
+    it 'should work even when not action is configured' do
+      matcher = create_matcher(
+          [:comments, [:update, :show, :new, :create]],
+          [:users, [:show, :new, :create]],
+          [:posts, [:show, :edit, :update]]
+      )
+      matcher.matches?(PermissionService.new).should be_false
+    end
+  end
+
+  describe '#failure_message_for_should' do
+
+    context 'if controllers did not match' do
+
+      it 'should be available' do
+        matcher = create_matcher(
+            [:users, []],
+            [:posts, []]
+        )
+        expected_messages =
+            "expected to find actions for controllers \n" \
+          "[\"posts\", \"users\"], but found actions for controllers\n"\
+          "[\"comments\", \"posts\", \"users\"]"
+        #call is necessary because matches sets @permission_service
+        matcher.matches?(permission_service)
+        matcher.failure_message_for_should.should eq expected_messages
+      end
+
+      it 'should work if no controller allowed' do
+        matcher = create_matcher(
+            [:users, []],
+            [:posts, []]
+        )
+        #call is necessary because matches sets @permission_service
+        matcher.matches?(PermissionService.new)
+        matcher.failure_message_for_should.should be_kind_of(String)
+      end
+    end
+
+    context 'if actions for controllers did not match' do
+
+      it 'should be available' do
+        matcher = create_matcher(
+            [:comments, [:show, :new, :create]],
+            [:users, [:show, :new, :create, :update]],
+            [:posts, [:show, :edit, :update]]
+        )
+        expected_messages =
+            "expected actions did not match for following controllers:\n"\
+            "comments:\n"\
+            "[\"create\", \"new\", \"show\"] were expected but found actions\n"\
+            "[\"create\", \"index\", \"new\", \"show\"]\n"\
+            "users:\n"\
+            "[\"create\", \"new\", \"show\", \"update\"] were expected but found actions\n"\
+            "[\"create\", \"new\", \"show\"]\n"
+        #call is necessary because matches sets @permission_service
+        matcher.matches?(permission_service)
+        matcher.failure_message_for_should.should eq expected_messages
+      end
+
+
+      it 'should work if no controller allowed' do
+        matcher = create_matcher(
+            [:comments, [:show, :new, :create]],
+            [:users, [:show, :new, :create, :update]],
+            [:posts, [:show, :edit, :update]]
+        )
+        #call is necessary because matches sets @permission_service
+        matcher.matches?(PermissionService.new)
+        matcher.failure_message_for_should.should be_kind_of(String)
+      end
+    end
+  end
+
+
+  describe '#failure_message_for_should_not' do
+
+    it 'should be available' do
+      matcher = create_matcher
+      expected_messages = 'given actions are exactly match although this is not expected'
+      matcher.failure_message_for_should_not.should eq expected_messages
+    end
+
+    it 'should be available' do
+      matcher = create_matcher
+      matcher.matches?(PermissionService.new)
+      matcher.failure_message_for_should_not.should be_kind_of(String)
+    end
+  end
+
+end

data/spec/permissioner/matchers_spec.rb

@@ -1,52 +1,95 @@
 require 'spec_helper'
 
-describe 'matchers' do
+describe Permissioner::Matchers do
 
-  before :each do
-    @permission_service = double('permission_service')
+  let(:matcher_helper) do
+    matcher_helper = Class.new
+    matcher_helper.extend(Permissioner::Matchers)
+    matcher_helper
   end
 
-  describe 'allow_action' do
+  let(:permission_service) { PermissionService.new }
 
-    it 'should delegate call to PermissionService#allow_action?' do
-      @permission_service.should_receive(:allow_action?).with(:comments, :index).and_return(true)
-      @permission_service.should allow_action :comments, :index
+  describe '#allow_action' do
+
+    it 'should delegate call to PermissionService#allow_action? and pass when is returns true' do
+      permission_service.should_receive(:allow_action?).with(:comments, :index, resource: 'resource', params: 'params').and_return(true)
+      permission_service.should allow_action :comments, :index, resource: 'resource', params: 'params'
+    end
+
+    it 'should fail when PermissionService#allow_action? returns false' do
+      permission_service.should_receive(:allow_action?).and_return(false)
+      permission_service.should_not allow_action
+    end
+  end
+
+  describe '#allow_attribute' do
+
+    it 'should delegate call to PermissionService#allow_action? and pass when is returns true' do
+      permission_service.should_receive(:allow_attribute?).with(:comment, :user_id, :text).and_return(true)
+      permission_service.should allow_attribute :comment, :user_id, :text
+    end
+
+    it 'should fail when PermissionService#allow_action? returns false' do
+      permission_service.should_receive(:allow_attribute?).and_return(false)
+      permission_service.should_not allow_attribute
+    end
+  end
+
+  describe '#pass_filters' do
+
+    it 'should delegate call to PermissionService#passed_filters? and pass when is returns true' do
+      permission_service.should_receive(:passed_filters?).with(:comment, :user_id, resource: 'resource', params: 'params').and_return(true)
+      permission_service.should pass_filters :comment, :user_id, resource: 'resource', params: 'params'
     end
 
-    it 'should return false when PermissionService#allow_action? returns false' do
-      @permission_service.should_receive(:allow_action?).and_return(false)
-      @permission_service.should_not allow_action
+    it 'should fail when PermissionService#passed_filters? returns false' do
+      permission_service.should_receive(:passed_filters?).and_return(false)
+      permission_service.should_not pass_filters
     end
   end
 
-  describe 'allow_attribute' do
+  describe '#exactly_allow_actions' do
 
-    it 'should delegate call to PermissionService#allow_action?' do
-      @permission_service.should_receive(:allow_attribute?).with(:comment, :user_id, :text).and_return(true)
-      @permission_service.should allow_attribute :comment, :user_id, :text
+    it 'should return correctly instantiated instance of ExactlyExpectActions' do
+      expected_actions = [:controller_1, :actions_1], [:controller_2, :actions_2]
+      Permissioner::Matchers::ExactlyExpectActions.should_receive(:new).with(:@allowed_actions, *expected_actions).and_call_original
+      matcher_helper.exactly_allow_actions(*expected_actions).should be_kind_of(Permissioner::Matchers::ExactlyExpectActions)
     end
+  end
+
+  describe '#exactly_have_filters_for' do
 
-    it 'should return false when PermissionService#allow_action? returns false' do
-      @permission_service.should_receive(:allow_attribute?).and_return(false)
-      @permission_service.should_not allow_attribute
+    it 'should return correctly instantiated instance of ExactlyExpectActions' do
+      expected_actions = [:controller_1, :actions_1], [:controller_2, :actions_2]
+      Permissioner::Matchers::ExactlyExpectActions.should_receive(:new).with(:@filters, *expected_actions).and_call_original
+      matcher_helper.exactly_have_filters_for(*expected_actions).should be_kind_of(Permissioner::Matchers::ExactlyExpectActions)
     end
   end
 
-  describe 'pass_filters' do
+  describe '#exactly_allow_attributes' do
 
-    it 'should delegate call to PermissionService#passed_filters?' do
-      @permission_service.should_receive(:passed_filters?).with(:comment, :user_id, :block).and_return(true)
-      @permission_service.should pass_filters :comment, :user_id, :block
+    it 'should return correctly instantiated instance of ExactlyAllowAttributes' do
+      expected_attributes = [:resource_1, :attribute_1], [:resource_2, :attribute_2]
+      Permissioner::Matchers::ExactlyAllowAttributes.should_receive(:new).with(*expected_attributes).and_call_original
+      matcher_helper.exactly_allow_attributes(*expected_attributes).should be_kind_of(Permissioner::Matchers::ExactlyAllowAttributes)
     end
+  end
+
+  describe '#exactly_allow_controllers' do
 
-    it 'should return false when PermissionService#passed_filters? returns false' do
-      @permission_service.should_receive(:passed_filters?).and_return(false)
-      @permission_service.should_not pass_filters
+    it 'should return correctly instantiated instance of ExactlyAllowControllers' do
+      Permissioner::Matchers::ExactlyAllowControllers.should_receive(:new).with(:controller_1, :controller_2).and_call_original
+      matcher_helper.exactly_allow_controllers(:controller_1, :controller_2).should be_kind_of(Permissioner::Matchers::ExactlyAllowControllers)
     end
+  end
 
-    it 'should set empty Hash as default value for params argument' do
-      @permission_service.should_receive(:passed_filters?).with(:comment, :user_id, {}).and_return(true)
-      @permission_service.should pass_filters :comment, :user_id
+  describe '#exactly_allow_resources' do
+
+    it 'should return correctly instantiated instance of ExactlyAllowControllers' do
+      Permissioner::Matchers::ExactlyAllowResources.should_receive(:new).with(:resource_1, :resource_2).and_call_original
+      matcher_helper.exactly_allow_resources(:resource_1, :resource_2).should be_kind_of(Permissioner::Matchers::ExactlyAllowResources)
     end
   end
+
 end

data/spec/permissioner/{permission_service_additions_spec.rb → service_additions_spec.rb}

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-describe Permissioner::PermissionServiceAdditions do
+describe Permissioner::ServiceAdditions do
 
   let(:permission_service_class) do
     permission_service_class = Class.new
-    permission_service_class.send(:include, Permissioner::PermissionServiceAdditions)
+    permission_service_class.send(:include, Permissioner::ServiceAdditions)
     permission_service_class
   end
 
@@ -30,99 +30,157 @@ describe Permissioner::PermissionServiceAdditions do
       permission_service.allow_action?(:comments, :index).should be_true
     end
 
-    context 'when no block given' do
+    context 'block not given' do
 
       it 'should return true if given action allowed' do
         permission_service.allow_actions :comments, :index
         permission_service.allow_action?(:comments, :index).should be_true
       end
 
+      it 'should return true for every action when all actions are allowed' do
+        permission_service.allow_actions :comments, :all
+        permission_service.allow_action?(:comments, :index).should be_true
+      end
+
+      it 'should return true if action is allowed and given filter returns true' do
+        permission_service.add_filter :comments, :index, &Proc.new { true }
+        permission_service.allow_actions :comments, :index
+        permission_service.allow_action?(:comments, :index).should be_true
+      end
+
       it 'should return false if given action not allowed' do
         permission_service.allow_action?(:comments, :index).should be_false
         permission_service.allow_actions :comments, :create
         permission_service.allow_action?(:comments, :index).should be_false
       end
+
+      it 'should return false if action is allowed and given filter returns false' do
+        permission_service.add_filter :comments, :index, &Proc.new { false }
+        permission_service.allow_actions :comments, :index
+        permission_service.allow_action?(:comments, :index).should be_false
+      end
     end
 
-    context 'when block given' do
+    context 'block given' do
 
       it 'should call block for given action when ressource is given' do
         block = Proc.new {}
         block.should_receive(:call)
         permission_service.allow_actions :comments, :index, &block
-        permission_service.allow_action?(:comments, :index, 'resource')
-      end
-
-      it 'should not call block for given action but no ressource is given' do
-        block = Proc.new {}
-        block.should_receive(:call).never
-        permission_service.allow_actions :comments, :index, &block
-        permission_service.allow_action?(:comments, :index)
+        permission_service.allow_action?(:comments, :index, resource: 'resource')
       end
 
       it 'should return true when block returns true' do
         block = Proc.new { true }
         permission_service.allow_actions :comments, :index, &block
-        permission_service.allow_action?(:comments, :index, 'resource').should be_true
+        permission_service.allow_action?(:comments, :index).should be_true
+      end
+
+      it 'should return true if block and given filter returns true' do
+        permission_service.add_filter :comments, :index, &Proc.new { true }
+        permission_service.allow_actions :comments, :index, &Proc.new { true }
+        permission_service.allow_action?(:comments, :index).should be_true
       end
 
       it 'should return false when block returns false' do
         block = Proc.new { false }
         permission_service.allow_actions :comments, :index, &block
-        permission_service.allow_action?(:comments, :index, 'resource').should be_false
+        permission_service.allow_action?(:comments, :index, resource: 'resource').should be_false
       end
 
-      it 'should return false when no ressource given' do
-        block = Proc.new { true }
-        permission_service.allow_actions :comments, :index, &block
-        permission_service.allow_action?(:comments, :index).should be_false
+      it 'should return false if block returns true and given filter returns false' do
+        permission_service.add_filter :comments, :index, &Proc.new { false }
+        permission_service.allow_actions :comments, :index, &Proc.new { true }
+        permission_service.allow_action?(:comments, :index, resource: 'resource').should be_false
+      end
+
+      it 'should return false if block returns false and given filter returns true' do
+        permission_service.add_filter :comments, :index, &Proc.new { true }
+        permission_service.allow_actions :comments, :index, &Proc.new { false }
+        permission_service.allow_action?(:comments, :index, resource: 'resource').should be_false
       end
     end
+
+    it 'should also except arguments as string' do
+      permission_service.allow_actions :comments, :index
+      permission_service.allow_action?('comments', 'index').should be_true
+    end
+
+    it 'should pass arguments to passed_filters? if action is principally allowed' do
+      permission_service.allow_actions :comments, :index
+      permission_service.should_receive(:passed_filters?).with(:comments, :index, resource: :resource, params: :params)
+      permission_service.allow_action?(:comments, :index, resource: :resource, params: :params)
+    end
   end
 
   describe '#passed_filters?' do
 
     it 'should return true when all blocks for given controller and action returns true' do
       permission_service.add_filter(:comments, :create, &Proc.new { true })
-      permission_service.passed_filters?(:comments, :create, 'params').should be_true
+      permission_service.passed_filters?(:comments, :create).should be_true
     end
 
     it 'should return true when no filters are added at all' do
-      permission_service.passed_filters?(:comments, :create, 'params').should be_true
+      permission_service.passed_filters?(:comments, :create).should be_true
     end
 
     it 'should return true when for given controller and action no filters has been added' do
       permission_service.add_filter(:comments, :update, &Proc.new {})
-      permission_service.passed_filters?(:comments, :create, 'params').should be_true
+      permission_service.passed_filters?(:comments, :create).should be_true
     end
 
     it 'should return false when at least one block for given controller and action returns false' do
       permission_service.add_filter(:comments, :create, &Proc.new { true })
       permission_service.add_filter(:comments, :create, &Proc.new { false })
       permission_service.add_filter(:comments, :create, &Proc.new { true })
-      permission_service.passed_filters?(:comments, :create, 'params').should be_false
+      permission_service.passed_filters?(:comments, :create).should be_false
+    end
+
+    it 'should pass resource to the given block' do
+      resource = Object.new
+      permission_service.add_filter(:comments, :create, &Proc.new { |r, p| r.should be resource })
+      permission_service.passed_filters?(:comments, :create, resource: resource)
     end
 
     it 'should pass params to the given block' do
       params = Object.new
-      permission_service.add_filter(:comments, :create, &Proc.new { |p| p.object_id.should eq params.object_id })
-      permission_service.passed_filters?(:comments, :create, params)
+      permission_service.add_filter(:comments, :create, &Proc.new { |r, p| p.should be params })
+      permission_service.passed_filters?(:comments, :create, params: params)
+    end
+
+    it 'should set params to {} if not given' do
+      permission_service.add_filter(:comments, :create, &Proc.new { |r, p| p.should eq({}) })
+      permission_service.passed_filters?(:comments, :create)
+    end
+
+    it 'should set params to {} if nil' do
+      permission_service.add_filter(:comments, :create, &Proc.new { |r, p| p.should eq({}) })
+      permission_service.passed_filters?(:comments, :create, params: nil)
+    end
+
+    it 'should set default values for params and current resource' do
+      block = Proc.new do |current_resource, params|
+        current_resource.should be_nil
+        params.should eq({})
+      end
+      permission_service.add_filter(:comments, :create, &block)
+      permission_service.passed_filters?(:comments, :create)
     end
   end
 
-  describe '#allow_attributes?' do
+  describe '#allow_attribute?' do
 
     it 'should return true when @allow_all is true' do
       permission_service.allow_all
       permission_service.allow_attribute?(:comment, :user_id).should be_true
     end
 
-    it 'should return true when param is allowed' do
+    it 'should return true when attribute is allowed' do
       permission_service.allow_attributes(:comment, :user_id)
       permission_service.allow_attribute?(:comment, :user_id).should be_true
     end
 
-    it 'should return false when param not allowed' do
+    it 'should return false when attribute not allowed' do
       permission_service.allow_attribute?(:comment, :user_id).should be_false
     end
   end
@@ -242,7 +300,38 @@ describe Permissioner::PermissionServiceAdditions do
     end
   end
 
-  describe 'configure' do
+  describe '#clear_filters' do
+
+    before :each do
+      permission_service.add_filter [:users, :comments], [:edit, :update], &Proc.new {}
+    end
+
+    it 'should delete filters for actions if one controller and action are given' do
+      permission_service.clear_filters :users, :edit
+      filters = permission_service.instance_variable_get(:@filters)
+      filters.count.should eq 3
+      filters.should_not have_key([:users, :edit])
+    end
+
+    it 'should delete filters for actions if multiple controllers and actions are given' do
+      permission_service.clear_filters [:users, :comments], [:edit, :update]
+      filters = permission_service.instance_variable_get(:@filters)
+      filters.should be_empty
+    end
+
+  end
+
+  describe '#clear_all_filters' do
+
+    it 'should set @filters to nil' do
+      permission_service.add_filter(:comments, :create, &Proc.new {})
+      permission_service.instance_variable_get(:@filters).should_not be_nil
+      permission_service.clear_all_filters
+      permission_service.instance_variable_get(:@filters).should be_nil
+    end
+  end
+
+  describe '#configure' do
 
     it 'should create new instance of given configurer class' do
       permission_service.stub(:current_user).and_return('current_user')