permissioner 0.2.0.beta → 1.0.0.beta

data/spec/permissioner/matchers/exactly_allow_resources_spec.rb

@@ -19,26 +19,26 @@ describe Permissioner::Matchers::ExactlyAllowResources do
 
     it 'should return true if given resources exaclty allowed' do
       matcher = create_matcher :user, :comment, :post
-      matcher.matches?(permission_service).should be_true
+      expect(matcher.matches?(permission_service)).to be_truthy
     end
 
     it 'should return false if at least one resource is not allowed' do
       matcher = create_matcher :user, :comment, :account
-      matcher.matches?(permission_service).should be_false
+      expect(matcher.matches?(permission_service)).to be_falsey
     end
 
     it 'should return false if more resources allowed than expected' do
       matcher = create_matcher :user, :comment
-      matcher.matches?(permission_service).should be_false
+      expect(matcher.matches?(permission_service)).to be_falsey
     end
 
     it 'should work if no resource is allowed' do
       matcher = create_matcher :user, :comment
-      matcher.matches?(PermissionService.new).should be_false
+      expect(matcher.matches?(PermissionService.new)).to be_falsey
     end
   end
 
-  describe '#failure_message_for_should' do
+  describe '#failure_message' do
 
     it 'should be available' do
       matcher = create_matcher(:user, :comment)
@@ -48,30 +48,30 @@ describe Permissioner::Matchers::ExactlyAllowResources do
           "[:comment, :post, :user] allowed"
       #call is necessary because matches sets @permission_service
       matcher.matches?(permission_service)
-      matcher.failure_message_for_should.should eq expected_messages
+      expect(matcher.failure_message).to eq expected_messages
     end
 
     it 'should work if no controller allowed' do
       matcher = create_matcher(:user, :comment)
       #call is necessary because matches sets @permission_service
       matcher.matches?((PermissionService.new))
-      matcher.failure_message_for_should.should be_kind_of(String)
+      expect(matcher.failure_message).to be_kind_of(String)
     end
   end
 
-  describe '#failure_message_for_should_not' do
+  describe '# failure_message_when_negated' do
 
     it 'should be available' do
       matcher = create_matcher(:user, :comment)
       expected_messages =
           "expected to exactly not allow resources \n" \
           "[:comment, :user], but these resources are exactly allowed\n"
-      matcher.failure_message_for_should_not.should eq expected_messages
+      expect(matcher. failure_message_when_negated).to eq expected_messages
     end
 
     it 'should work if no controller allowed' do
       matcher = create_matcher(:comment, :user)
-      matcher.failure_message_for_should_not.should be_kind_of(String)
+      expect(matcher. failure_message_when_negated).to be_kind_of(String)
     end
   end
 

data/spec/permissioner/matchers/exactly_expect_actions_spec.rb

@@ -18,9 +18,9 @@ describe Permissioner::Matchers::ExactlyExpectActions 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']]]
+      expect(matcher.instance_variable_get(:@all_expected_actions)).to 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']]]
+      expect(matcher.instance_variable_get(:@all_expected_actions)).to eq [['controller', ['action_1', 'action_2']]]
     end
 
     it 'should raise an exception if multiple actions not stated as array' do
@@ -40,7 +40,7 @@ describe Permissioner::Matchers::ExactlyExpectActions do
             [:users, [:show, :new, :create]],
             [:posts, [:show, :edit, :update]]
         )
-        matcher.matches?(permission_service).should be_true
+        expect(matcher.matches?(permission_service)).to be_truthy
       end
 
       it 'should return true if for a given controller all actions are allowed and all is expected' do
@@ -50,7 +50,7 @@ describe Permissioner::Matchers::ExactlyExpectActions do
             [:users, [:show, :new, :create]],
             [:posts, [:show, :edit, :update]]
         )
-        matcher.matches?(permission_service).should be_true
+        expect(matcher.matches?(permission_service)).to be_truthy
       end
     end
 
@@ -62,7 +62,7 @@ describe Permissioner::Matchers::ExactlyExpectActions do
             [:users, [:show, :new, :create]],
             [:accounts, [:show, :edit, :update]]
         )
-        matcher.matches?(permission_service).should be_false
+        expect(matcher.matches?(permission_service)).to be_falsey
       end
 
       it 'should return false if at least one controller is allowed but no expected' do
@@ -70,7 +70,7 @@ describe Permissioner::Matchers::ExactlyExpectActions do
             [:comments, [:index, :show, :new, :create]],
             [:users, [:show, :new, :create]]
         )
-        matcher.matches?(permission_service).should be_false
+        expect(matcher.matches?(permission_service)).to be_falsey
       end
     end
 
@@ -82,7 +82,7 @@ describe Permissioner::Matchers::ExactlyExpectActions do
             [:users, [:show, :new, :create]],
             [:posts, [:show, :edit, :update]]
         )
-        matcher.matches?(permission_service).should be_false
+        expect(matcher.matches?(permission_service)).to be_falsey
       end
 
       it 'should return false if at least one action is not allowed but no expected' do
@@ -91,7 +91,7 @@ describe Permissioner::Matchers::ExactlyExpectActions do
             [:users, [:show, :new, :create]],
             [:posts, [:show, :edit, :update]]
         )
-        matcher.matches?(permission_service).should be_false
+        expect(matcher.matches?(permission_service)).to be_falsey
       end
     end
 
@@ -101,11 +101,11 @@ describe Permissioner::Matchers::ExactlyExpectActions do
           [:users, [:show, :new, :create]],
           [:posts, [:show, :edit, :update]]
       )
-      matcher.matches?(PermissionService.new).should be_false
+      expect(matcher.matches?(PermissionService.new)).to be_falsey
     end
   end
 
-  describe '#failure_message_for_should' do
+  describe '#failure_message' do
 
     context 'if controllers did not match' do
 
@@ -120,7 +120,7 @@ describe Permissioner::Matchers::ExactlyExpectActions do
           "[\"comments\", \"posts\", \"users\"]"
         #call is necessary because matches sets @permission_service
         matcher.matches?(permission_service)
-        matcher.failure_message_for_should.should eq expected_messages
+        expect(matcher.failure_message).to eq expected_messages
       end
 
       it 'should work if no controller allowed' do
@@ -130,7 +130,7 @@ describe Permissioner::Matchers::ExactlyExpectActions do
         )
         #call is necessary because matches sets @permission_service
         matcher.matches?(PermissionService.new)
-        matcher.failure_message_for_should.should be_kind_of(String)
+        expect(matcher.failure_message).to be_kind_of(String)
       end
     end
 
@@ -152,7 +152,7 @@ describe Permissioner::Matchers::ExactlyExpectActions do
             "[\"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
+        expect(matcher.failure_message).to eq expected_messages
       end
 
 
@@ -164,24 +164,24 @@ describe Permissioner::Matchers::ExactlyExpectActions do
         )
         #call is necessary because matches sets @permission_service
         matcher.matches?(PermissionService.new)
-        matcher.failure_message_for_should.should be_kind_of(String)
+        expect(matcher.failure_message).to be_kind_of(String)
       end
     end
   end
 
 
-  describe '#failure_message_for_should_not' do
+  describe '# failure_message_when_negated' 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
+      expect(matcher. failure_message_when_negated).to 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)
+      expect(matcher. failure_message_when_negated).to be_kind_of(String)
     end
   end
 

data/spec/permissioner/matchers_spec.rb

@@ -13,39 +13,39 @@ describe Permissioner::Matchers do
   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'
+      expect(permission_service).to receive(:allow_action?).with(:comments, :index, resource: 'resource', params: 'params').and_return(true)
+      expect(permission_service).to 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
+      expect(permission_service).to receive(:allow_action?).and_return(false)
+      expect(permission_service).not_to 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
+      expect(permission_service).to receive(:allow_attribute?).with(:comment, :user_id, :text).and_return(true)
+      expect(permission_service).to 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
+      expect(permission_service).to receive(:allow_attribute?).and_return(false)
+      expect(permission_service).not_to 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'
+      expect(permission_service).to receive(:passed_filters?).with(:comment, :user_id, resource: 'resource', params: 'params').and_return(true)
+      expect(permission_service).to pass_filters :comment, :user_id, resource: 'resource', params: 'params'
     end
 
     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
+      expect(permission_service).to receive(:passed_filters?).and_return(false)
+      expect(permission_service).not_to pass_filters
     end
   end
 
@@ -53,8 +53,8 @@ describe Permissioner::Matchers do
 
     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)
+      expect(Permissioner::Matchers::ExactlyExpectActions).to receive(:new).with(:@allowed_actions, *expected_actions).and_call_original
+      expect(matcher_helper.exactly_allow_actions(*expected_actions)).to be_kind_of(Permissioner::Matchers::ExactlyExpectActions)
     end
   end
 
@@ -62,8 +62,8 @@ describe Permissioner::Matchers do
 
     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)
+      expect(Permissioner::Matchers::ExactlyExpectActions).to receive(:new).with(:@filters, *expected_actions).and_call_original
+      expect(matcher_helper.exactly_have_filters_for(*expected_actions)).to be_kind_of(Permissioner::Matchers::ExactlyExpectActions)
     end
   end
 
@@ -71,24 +71,24 @@ describe Permissioner::Matchers do
 
     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)
+      expect(Permissioner::Matchers::ExactlyAllowAttributes).to receive(:new).with(*expected_attributes).and_call_original
+      expect(matcher_helper.exactly_allow_attributes(*expected_attributes)).to be_kind_of(Permissioner::Matchers::ExactlyAllowAttributes)
     end
   end
 
   describe '#exactly_allow_controllers' do
 
     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)
+      expect(Permissioner::Matchers::ExactlyAllowControllers).to receive(:new).with(:controller_1, :controller_2).and_call_original
+      expect(matcher_helper.exactly_allow_controllers(:controller_1, :controller_2)).to be_kind_of(Permissioner::Matchers::ExactlyAllowControllers)
     end
   end
 
   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)
+      expect(Permissioner::Matchers::ExactlyAllowResources).to receive(:new).with(:resource_1, :resource_2).and_call_original
+      expect(matcher_helper.exactly_allow_resources(:resource_1, :resource_2)).to be_kind_of(Permissioner::Matchers::ExactlyAllowResources)
     end
   end
 

data/spec/permissioner/service_additions_spec.rb

@@ -13,13 +13,13 @@ describe Permissioner::ServiceAdditions do
   describe '#initialize' do
 
     it 'should call configure_permissions' do
-      permission_service_class.any_instance.should_receive(:configure_permissions).once
+      expect_any_instance_of(permission_service_class).to receive(:configure_permissions).once
       permission_service_class.new
     end
 
     it 'should set current_user' do
       permission_service = permission_service_class.new 'current_user'
-      permission_service.current_user.should eq 'current_user'
+      expect(permission_service.current_user).to eq 'current_user'
     end
   end
 
@@ -29,21 +29,21 @@ describe Permissioner::ServiceAdditions do
 
       it 'should return true if action is allowed' do
         permission_service.allow_actions :comments, :index
-        permission_service.allow_action?(:comments, :index).should be_true
+        expect(permission_service.allow_action?(:comments, :index)).to be_truthy
       end
 
       it 'should return true for every action if  all actions of controller are allowed' do
         permission_service.allow_actions :comments, :all
-        permission_service.allow_action?(:comments, :index).should be_true
+        expect(permission_service.allow_action?(:comments, :index)).to be_truthy
       end
 
       it 'should return true if allow_all is true' do
         permission_service.allow_all
-        permission_service.allow_action?(:comments, :index).should be_true
+        expect(permission_service.allow_action?(:comments, :index)).to be_truthy
       end
 
       it 'should return false if actions is not allowed' do
-        permission_service.allow_action?(:comments, :index).should be_false
+        expect(permission_service.allow_action?(:comments, :index)).to be_falsey
       end
     end
 
@@ -52,48 +52,48 @@ describe Permissioner::ServiceAdditions do
       it 'should return true if action is allowed and all filters return true' do
         permission_service.allow_actions :comments, :index, &Proc.new { true }
         permission_service.add_filter :comments, :index, &Proc.new { true }
-        permission_service.allow_action?(:comments, :index).should be_true
+        expect(permission_service.allow_action?(:comments, :index)).to be_truthy
       end
 
       it 'should return true for every action if all actions of controller are allowed and filters return true' do
         permission_service.allow_actions :comments, :all
         permission_service.add_filter :comments, :index, &Proc.new { true }
-        permission_service.allow_action?(:comments, :index).should be_true
+        expect(permission_service.allow_action?(:comments, :index)).to be_truthy
       end
 
       it 'should return true if allow_all is true but filters return false' do
         permission_service.allow_all
         permission_service.allow_actions :comments, :index, &Proc.new { false }
         permission_service.add_filter :comments, :index, &Proc.new { false }
-        permission_service.allow_action?(:comments, :index).should be_true
+        expect(permission_service.allow_action?(:comments, :index)).to be_truthy
       end
 
       it 'should return false if given action allowed but filters return false' do
         permission_service.allow_actions :comments, :index, &Proc.new { false }
-        permission_service.allow_action?(:comments, :index).should be_false
+        expect(permission_service.allow_action?(:comments, :index)).to be_falsey
       end
 
       it 'should return false if given action allowed but at least one filter returns false' do
         permission_service.allow_actions :comments, :index, &Proc.new { true }
         permission_service.add_filter :comments, :index, &Proc.new { false }
-        permission_service.allow_action?(:comments, :index).should be_false
+        expect(permission_service.allow_action?(:comments, :index)).to be_falsey
       end
 
       it 'should return false for every action if all actions of controller are allowed but filters return false' do
         permission_service.allow_actions :comments, :all
         permission_service.add_filter :comments, :index, &Proc.new { false }
-        permission_service.allow_action?(:comments, :index).should be_false
+        expect(permission_service.allow_action?(:comments, :index)).to be_falsey
       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
+      expect(permission_service.allow_action?('comments', 'index')).to be_truthy
     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)
+      expect(permission_service).to receive(:passed_filters?).with(:comments, :index, resource: :resource, params: :params)
       permission_service.allow_action?(:comments, :index, resource: :resource, params: :params)
     end
   end
@@ -102,51 +102,51 @@ describe Permissioner::ServiceAdditions 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).should be_true
+      expect(permission_service.passed_filters?(:comments, :create)).to be_truthy
     end
 
     it 'should return true when no filters are added at all' do
-      permission_service.passed_filters?(:comments, :create).should be_true
+      expect(permission_service.passed_filters?(:comments, :create)).to be_truthy
     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).should be_true
+      expect(permission_service.passed_filters?(:comments, :create)).to be_truthy
     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).should be_false
+      expect(permission_service.passed_filters?(:comments, :create)).to be_falsey
     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.add_filter(:comments, :create, &Proc.new { |r, p| expect(r).to 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 { |r, p| p.should be params })
+      permission_service.add_filter(:comments, :create, &Proc.new { |r, p| expect(p).to 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.add_filter(:comments, :create, &Proc.new { |r, p| expect(p).to 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.add_filter(:comments, :create, &Proc.new { |r, p| expect(p).to 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({})
+        expect(current_resource).to be_nil
+        expect(params).to eq({})
       end
       permission_service.add_filter(:comments, :create, &block)
       permission_service.passed_filters?(:comments, :create)
@@ -157,16 +157,16 @@ describe Permissioner::ServiceAdditions 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
+      expect(permission_service.allow_attribute?(:comment, :user_id)).to be_truthy
     end
 
     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
+      expect(permission_service.allow_attribute?(:comment, :user_id)).to be_truthy
     end
 
     it 'should return false when attribute not allowed' do
-      permission_service.allow_attribute?(:comment, :user_id).should be_false
+      expect(permission_service.allow_attribute?(:comment, :user_id)).to be_falsey
     end
   end
 
@@ -176,7 +176,7 @@ describe Permissioner::ServiceAdditions do
 
       it 'should call permit! on given params when @allow_all is true' do
         params = double('params')
-        params.should_receive(:permit!)
+        expect(params).to receive(:permit!)
         permission_service.allow_all
         permission_service.permit_params!(params)
       end
@@ -195,11 +195,11 @@ describe Permissioner::ServiceAdditions do
 
         permission_service.permit_params!(params)
 
-        params[:comment].should be_permitted
-        params[:comment].should include :user_id, :text
-        params[:comment].should_not include :date
-        params[:post].should be_permitted
-        params[:post].should include :title, :content
+        expect(params[:comment]).to be_permitted
+        expect(params[:comment]).to include :user_id, :text
+        expect(params[:comment]).not_to include :date
+        expect(params[:post]).to be_permitted
+        expect(params[:post]).to include :title, :content
       end
     end
 
@@ -209,7 +209,7 @@ describe Permissioner::ServiceAdditions do
 
     it 'should set @allow_all to true' do
       permission_service.allow_all
-      permission_service.instance_variable_get(:@allow_all).should be_true
+      expect(permission_service.instance_variable_get(:@allow_all)).to be_truthy
     end
   end
 
@@ -220,24 +220,24 @@ describe Permissioner::ServiceAdditions do
       it 'should add actions to @allowed_actions when one action is given' do
         permission_service.allow_actions :comments, :index
         allowed_actions = permission_service.instance_variable_get(:@allowed_actions)
-        allowed_actions.count.should eq 1
-        allowed_actions[['comments', 'index']].should be_true
+        expect(allowed_actions.count).to eq 1
+        expect(allowed_actions[['comments', 'index']]).to be_truthy
       end
 
       it 'should add actions to @allowed_actions when multiple actions are given' do
         permission_service.allow_actions([:comments, :users], [:index, :create])
         allowed_actions = permission_service.instance_variable_get(:@allowed_actions)
-        allowed_actions.count.should eq 4
-        allowed_actions[['comments', 'index']].should be_true
-        allowed_actions[['comments', 'create']].should be_true
-        allowed_actions[['users', 'index']].should be_true
-        allowed_actions[['users', 'create']].should be_true
+        expect(allowed_actions.count).to eq 4
+        expect(allowed_actions[['comments', 'index']]).to be_truthy
+        expect(allowed_actions[['comments', 'create']]).to be_truthy
+        expect(allowed_actions[['users', 'index']]).to be_truthy
+        expect(allowed_actions[['users', 'create']]).to be_truthy
       end
 
       it 'should not add any filters' do
         permission_service.allow_actions :comments, :index
         filters = permission_service.instance_variable_get(:@filters)
-        filters.count.should eq 0
+        expect(filters.count).to eq 0
       end
     end
 
@@ -247,19 +247,19 @@ describe Permissioner::ServiceAdditions do
         block = Proc.new {}
         permission_service.allow_actions :comments, :index, &block
         filters = permission_service.instance_variable_get(:@filters)
-        filters.count.should eq 1
-        filters[['comments', 'index']].should eq [block]
+        expect(filters.count).to eq 1
+        expect(filters[['comments', 'index']]).to eq [block]
       end
 
       it 'should add block to @filters when multiple actions are given' do
         block = Proc.new {}
         permission_service.allow_actions([:comments, :users], [:index, :create], &block)
         filters = permission_service.instance_variable_get(:@filters)
-        filters.count.should eq 4
-        filters[['comments', 'index']].should eq [block]
-        filters[['comments', 'create']].should eq [block]
-        filters[['users', 'index']].should eq [block]
-        filters[['users', 'create']].should eq [block]
+        expect(filters.count).to eq 4
+        expect(filters[['comments', 'index']]).to eq [block]
+        expect(filters[['comments', 'create']]).to eq [block]
+        expect(filters[['users', 'index']]).to eq [block]
+        expect(filters[['users', 'create']]).to eq [block]
       end
 
       it 'should add multiple blocks to @filters fore every actions' do
@@ -268,15 +268,15 @@ describe Permissioner::ServiceAdditions do
         permission_service.allow_actions :comments, :index, &block_1
         permission_service.allow_actions :comments, :index, &block_2
         filters = permission_service.instance_variable_get(:@filters)
-        filters.count.should eq 1
-        filters[['comments', 'index']].should eq [block_1, block_2]
+        expect(filters.count).to eq 1
+        expect(filters[['comments', 'index']]).to eq [block_1, block_2]
       end
 
       it 'should add actions to @allowed_actions' do
         permission_service.allow_actions :comments, :index, &Proc.new {}
         allowed_actions = permission_service.instance_variable_get(:@allowed_actions)
-        allowed_actions.count.should eq 1
-        allowed_actions[['comments', 'index']].should be_true
+        expect(allowed_actions.count).to eq 1
+        expect(allowed_actions[['comments', 'index']]).to be_truthy
       end
 
       it 'should raise error if block is given for all actions' do
@@ -296,23 +296,23 @@ describe Permissioner::ServiceAdditions do
     it 'should add resource and attribute to @allowed_params' do
       permission_service.allow_attributes :comment, :text
       allowed_params = permission_service.instance_variable_get(:@allowed_attributes)
-      allowed_params.count.should eq 1
-      allowed_params[:comment].should eq [:text]
+      expect(allowed_params.count).to eq 1
+      expect(allowed_params[:comment]).to eq [:text]
     end
 
     it 'should add resource and attributes to @allowed_params if multiple given' do
       permission_service.allow_attributes [:comment, :post], [:user, :text]
       allowed_params = permission_service.instance_variable_get(:@allowed_attributes)
-      allowed_params.count.should eq 2
-      allowed_params[:comment].should eq [:user, :text]
-      allowed_params[:post].should eq [:user, :text]
+      expect(allowed_params.count).to eq 2
+      expect(allowed_params[:comment]).to eq [:user, :text]
+      expect(allowed_params[:post]).to eq [:user, :text]
     end
 
     it 'should add resource and attributes to @allowed_params if attributes is a Hash' do
       permission_service.allow_attributes :comment, {attributes: [:user, :text]}
       allowed_params = permission_service.instance_variable_get(:@allowed_attributes)
-      allowed_params.count.should eq 1
-      allowed_params[:comment].should eq [{attributes: [:user, :text]}]
+      expect(allowed_params.count).to eq 1
+      expect(allowed_params[:comment]).to eq [{attributes: [:user, :text]}]
     end
   end
 
@@ -322,17 +322,17 @@ describe Permissioner::ServiceAdditions do
       block = Proc.new {}
       permission_service.add_filter(:comments, :create, &block)
       filter_list = permission_service.instance_variable_get(:@filters)[['comments', 'create']]
-      filter_list.count.should eq 1
-      filter_list.should include block
+      expect(filter_list.count).to eq 1
+      expect(filter_list).to include block
     end
 
     it 'should add given block to @filters addressed by controller and action when multiple given' do
       block = Proc.new {}
       permission_service.add_filter([:comments, :posts], [:create, :update], &block)
-      permission_service.instance_variable_get(:@filters)[['comments', 'create']].should include block
-      permission_service.instance_variable_get(:@filters)[['comments', 'update']].should include block
-      permission_service.instance_variable_get(:@filters)[['posts', 'create']].should include block
-      permission_service.instance_variable_get(:@filters)[['posts', 'update']].should include block
+      expect(permission_service.instance_variable_get(:@filters)[['comments', 'create']]).to include block
+      expect(permission_service.instance_variable_get(:@filters)[['comments', 'update']]).to include block
+      expect(permission_service.instance_variable_get(:@filters)[['posts', 'create']]).to include block
+      expect(permission_service.instance_variable_get(:@filters)[['posts', 'update']]).to include block
     end
 
     it 'should add multiple blocks to @filters addressed by controller and action' do
@@ -341,9 +341,9 @@ describe Permissioner::ServiceAdditions do
       permission_service.add_filter(:comments, :create, &block_1)
       permission_service.add_filter(:comments, :create, &block_2)
       filter_list = permission_service.instance_variable_get(:@filters)[['comments', 'create']]
-      filter_list.count.should eq 2
-      filter_list.should include block_1
-      filter_list.should include block_2
+      expect(filter_list.count).to eq 2
+      expect(filter_list).to include block_1
+      expect(filter_list).to include block_2
     end
 
     it 'should rails exception when no block given' do
@@ -370,14 +370,14 @@ describe Permissioner::ServiceAdditions do
     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])
+      expect(filters.count).to eq 3
+      expect(filters).not_to 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
+      expect(filters).to be_empty
     end
 
   end
@@ -386,18 +386,18 @@ describe Permissioner::ServiceAdditions 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
+      expect(permission_service.instance_variable_get(:@filters)).not_to be_nil
       permission_service.clear_all_filters
-      permission_service.instance_variable_get(:@filters).should be_nil
+      expect(permission_service.instance_variable_get(:@filters)).to 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')
+      allow(permission_service).to receive(:current_user).and_return('current_user')
       configurer_class = double('permission_configurer')
-      configurer_class.should_receive(:new).with(permission_service, 'current_user')
+      expect(configurer_class).to receive(:new).with(permission_service, 'current_user')
       permission_service.configure(configurer_class)
     end
   end