cancancan 1.8.0 → 1.9.0

data/spec/cancan/ability_spec.rb

@@ -7,12 +7,12 @@ describe CanCan::Ability do
 
   it "is able to :read anything" do
     @ability.can :read, :all
-    expect(@ability.can?(:read, String)).to be_true
-    expect(@ability.can?(:read, 123)).to be_true
+    expect(@ability.can?(:read, String)).to be(true)
+    expect(@ability.can?(:read, 123)).to be(true)
   end
 
   it "does not have permission to do something it doesn't know about" do
-    expect(@ability.can?(:foodfight, String)).to be_false
+    expect(@ability.can?(:foodfight, String)).to be(false)
   end
 
   it "passes true to `can?` when non false/nil is returned in block" do
@@ -20,7 +20,7 @@ describe CanCan::Ability do
     @ability.can :read, Symbol do |sym|
       "foo" # TODO test that sym is nil when no instance is passed
     end
-    expect(@ability.can?(:read, :some_symbol)).to be_true
+    expect(@ability.can?(:read, :some_symbol)).to be(true)
   end
 
   it "passes nil to a block when no instance is passed" do
@@ -28,7 +28,7 @@ describe CanCan::Ability do
       expect(sym).to be_nil
       true
     end
-    expect(@ability.can?(:read, Symbol)).to be_true
+    expect(@ability.can?(:read, Symbol)).to be(true)
   end
 
   it "passes to previous rule, if block returns false or nil" do
@@ -39,10 +39,10 @@ describe CanCan::Ability do
     @ability.can :read, Integer do |i|
       i > 10
     end
-    expect(@ability.can?(:read, Symbol)).to be_true
-    expect(@ability.can?(:read, 11)).to be_true
-    expect(@ability.can?(:read, 1)).to be_true
-    expect(@ability.can?(:read, 6)).to be_false
+    expect(@ability.can?(:read, Symbol)).to be(true)
+    expect(@ability.can?(:read, 11)).to be(true)
+    expect(@ability.can?(:read, 1)).to be(true)
+    expect(@ability.can?(:read, 6)).to be(false)
   end
 
   it "does not pass class with object if :all objects are accepted" do
@@ -51,7 +51,7 @@ describe CanCan::Ability do
       @block_called = true
     end
     @ability.can?(:preview, 123)
-    expect(@block_called).to be_true
+    expect(@block_called).to be(true)
   end
 
   it "does not call block when only class is passed, only return true" do
@@ -59,8 +59,8 @@ describe CanCan::Ability do
     @ability.can :preview, :all do |object|
       @block_called = true
     end
-    expect(@ability.can?(:preview, Hash)).to be_true
-    expect(@block_called).to be_false
+    expect(@ability.can?(:preview, Hash)).to be(true)
+    expect(@block_called).to be(false)
   end
 
   it "passes only object for global manage actions" do
@@ -68,22 +68,22 @@ describe CanCan::Ability do
       expect(object).to eq("foo")
       @block_called = true
     end
-    expect(@ability.can?(:stuff, "foo")).to be_true
-    expect(@block_called).to be_true
+    expect(@ability.can?(:stuff, "foo")).to be(true)
+    expect(@block_called).to be(true)
   end
 
   it "makes alias for update or destroy actions to modify action" do
     @ability.alias_action :update, :destroy, :to => :modify
     @ability.can :modify, :all
-    expect(@ability.can?(:update, 123)).to be_true
-    expect(@ability.can?(:destroy, 123)).to be_true
+    expect(@ability.can?(:update, 123)).to be(true)
+    expect(@ability.can?(:destroy, 123)).to be(true)
   end
 
   it "allows deeply nested aliased actions" do
     @ability.alias_action :increment, :to => :sort
     @ability.alias_action :sort, :to => :modify
     @ability.can :modify, :all
-    expect(@ability.can?(:increment, 123)).to be_true
+    expect(@ability.can?(:increment, 123)).to be(true)
   end
 
   it "raises an Error if alias target is an exist action" do
@@ -98,7 +98,7 @@ describe CanCan::Ability do
       @block_called = true
     end
     @ability.can?(:foo, 123)
-    expect(@block_called).to be_true
+    expect(@block_called).to be(true)
   end
 
   it "passes nil to object when comparing class with can check" do
@@ -109,20 +109,20 @@ describe CanCan::Ability do
       @block_called = true
     end
     @ability.can?(:foo, Hash)
-    expect(@block_called).to be_true
+    expect(@block_called).to be(true)
   end
 
   it "automatically makes alias for index and show into read calls" do
     @ability.can :read, :all
-    expect(@ability.can?(:index, 123)).to be_true
-    expect(@ability.can?(:show, 123)).to be_true
+    expect(@ability.can?(:index, 123)).to be(true)
+    expect(@ability.can?(:show, 123)).to be(true)
   end
 
   it "automatically makes alias for new and edit into create and update respectively" do
     @ability.can :create, :all
     @ability.can :update, :all
-    expect(@ability.can?(:new, 123)).to be_true
-    expect(@ability.can?(:edit, 123)).to be_true
+    expect(@ability.can?(:new, 123)).to be(true)
+    expect(@ability.can?(:edit, 123)).to be(true)
   end
 
   it "does not respond to prepare (now using initialize)" do
@@ -130,56 +130,56 @@ describe CanCan::Ability do
   end
 
   it "offers cannot? method which is simply invert of can?" do
-    expect(@ability.cannot?(:tie, String)).to be_true
+    expect(@ability.cannot?(:tie, String)).to be(true)
   end
 
   it "is able to specify multiple actions and match any" do
     @ability.can [:read, :update], :all
-    expect(@ability.can?(:read, 123)).to be_true
-    expect(@ability.can?(:update, 123)).to be_true
-    expect(@ability.can?(:count, 123)).to be_false
+    expect(@ability.can?(:read, 123)).to be(true)
+    expect(@ability.can?(:update, 123)).to be(true)
+    expect(@ability.can?(:count, 123)).to be(false)
   end
 
   it "is able to specify multiple classes and match any" do
     @ability.can :update, [String, Range]
-    expect(@ability.can?(:update, "foo")).to be_true
-    expect(@ability.can?(:update, 1..3)).to be_true
-    expect(@ability.can?(:update, 123)).to be_false
+    expect(@ability.can?(:update, "foo")).to be(true)
+    expect(@ability.can?(:update, 1..3)).to be(true)
+    expect(@ability.can?(:update, 123)).to be(false)
   end
 
   it "checks if there is a permission for any of given subjects" do
     @ability.can :update, [String, Range]
-    expect(@ability.can?(:update, {:any => ["foo", 1..3]})).to be_true
-    expect(@ability.can?(:update, {:any => [1..3, "foo"]})).to be_true
-    expect(@ability.can?(:update, {:any => [123, "foo"]})).to be_true
-    expect(@ability.can?(:update, {:any => [123, 1.0]})).to be_false
+    expect(@ability.can?(:update, {:any => ["foo", 1..3]})).to be(true)
+    expect(@ability.can?(:update, {:any => [1..3, "foo"]})).to be(true)
+    expect(@ability.can?(:update, {:any => [123, "foo"]})).to be(true)
+    expect(@ability.can?(:update, {:any => [123, 1.0]})).to be(false)
   end
 
   it "supports custom objects in the rule" do
     @ability.can :read, :stats
-    expect(@ability.can?(:read, :stats)).to be_true
-    expect(@ability.can?(:update, :stats)).to be_false
-    expect(@ability.can?(:read, :nonstats)).to be_false
-    expect(@ability.can?(:read, {:any => [:stats, :nonstats]})).to be_true
-    expect(@ability.can?(:read, {:any => [:nonstats, :neitherstats]})).to be_false
+    expect(@ability.can?(:read, :stats)).to be(true)
+    expect(@ability.can?(:update, :stats)).to be(false)
+    expect(@ability.can?(:read, :nonstats)).to be(false)
+    expect(@ability.can?(:read, {:any => [:stats, :nonstats]})).to be(true)
+    expect(@ability.can?(:read, {:any => [:nonstats, :neitherstats]})).to be(false)
   end
 
   it "checks ancestors of class" do
     @ability.can :read, Numeric
-    expect(@ability.can?(:read, Integer)).to be_true
-    expect(@ability.can?(:read, 1.23)).to be_true
-    expect(@ability.can?(:read, "foo")).to be_false
-    expect(@ability.can?(:read, {:any => [Integer, String]})).to be_true
+    expect(@ability.can?(:read, Integer)).to be(true)
+    expect(@ability.can?(:read, 1.23)).to be(true)
+    expect(@ability.can?(:read, "foo")).to be(false)
+    expect(@ability.can?(:read, {:any => [Integer, String]})).to be(true)
   end
 
   it "supports 'cannot' method to define what user cannot do" do
     @ability.can :read, :all
     @ability.cannot :read, Integer
-    expect(@ability.can?(:read, "foo")).to be_true
-    expect(@ability.can?(:read, 123)).to be_false
-    expect(@ability.can?(:read, {:any => ["foo", "bar"]})).to be_true
-    expect(@ability.can?(:read, {:any => [123, "foo"]})).to be_false
-    expect(@ability.can?(:read, {:any => [123, 456]})).to be_false
+    expect(@ability.can?(:read, "foo")).to be(true)
+    expect(@ability.can?(:read, 123)).to be(false)
+    expect(@ability.can?(:read, {:any => ["foo", "bar"]})).to be(true)
+    expect(@ability.can?(:read, {:any => [123, "foo"]})).to be(false)
+    expect(@ability.can?(:read, {:any => [123, 456]})).to be(false)
   end
 
   it "passes to previous rule, if block returns false or nil" do
@@ -187,22 +187,23 @@ describe CanCan::Ability do
     @ability.cannot :read, Integer do |int|
       int > 10 ? nil : ( int > 5 )
     end
-    expect(@ability.can?(:read, "foo")).to be_true
-    expect(@ability.can?(:read, 3)).to be_true
-    expect(@ability.can?(:read, 8)).to be_false
-    expect(@ability.can?(:read, 123)).to be_true
-    expect(@ability.can?(:read, {:any => [123, 8]})).to be_true
-    expect(@ability.can?(:read, {:any => [8, 9]})).to be_false
+
+    expect(@ability.can?(:read, "foo")).to be(true)
+    expect(@ability.can?(:read, 3)).to be(true)
+    expect(@ability.can?(:read, 8)).to be(false)
+    expect(@ability.can?(:read, 123)).to be(true)
+    expect(@ability.can?(:read, {:any => [123, 8]})).to be(true)
+    expect(@ability.can?(:read, {:any => [8, 9]})).to be(false)
   end
 
   it "always returns `false` for single cannot definition" do
     @ability.cannot :read, Integer do |int|
       int > 10 ? nil : ( int > 5 )
     end
-    expect(@ability.can?(:read, "foo")).to be_false
-    expect(@ability.can?(:read, 3)).to be_false
-    expect(@ability.can?(:read, 8)).to be_false
-    expect(@ability.can?(:read, 123)).to be_false
+    expect(@ability.can?(:read, "foo")).to be(false)
+    expect(@ability.can?(:read, 3)).to be(false)
+    expect(@ability.can?(:read, 8)).to be(false)
+    expect(@ability.can?(:read, 123)).to be(false)
   end
 
   it "passes to previous cannot definition, if block returns false or nil" do
@@ -210,10 +211,10 @@ describe CanCan::Ability do
     @ability.can :read, Integer do |int|
       int > 10 ? nil : ( int > 5 )
     end
-    expect(@ability.can?(:read, "foo")).to be_false
-    expect(@ability.can?(:read, 3)).to be_false
-    expect(@ability.can?(:read, 10)).to be_true
-    expect(@ability.can?(:read, 123)).to be_false
+    expect(@ability.can?(:read, "foo")).to be(false)
+    expect(@ability.can?(:read, 3)).to be(false)
+    expect(@ability.can?(:read, 10)).to be(true)
+    expect(@ability.can?(:read, 123)).to be(false)
   end
 
   it "appends aliased actions" do
@@ -232,91 +233,94 @@ describe CanCan::Ability do
     @ability.can :read, Integer do |int, x|
       int > x
     end
-    expect(@ability.can?(:read, 2, 1)).to be_true
-    expect(@ability.can?(:read, 2, 3)).to be_false
-    expect(@ability.can?(:read, {:any => [4, 5]}, 3)).to be_true
-    expect(@ability.can?(:read, {:any => [2, 3]}, 3)).to be_false
+
+    expect(@ability.can?(:read, 2, 1)).to be(true)
+    expect(@ability.can?(:read, 2, 3)).to be(false)
+    expect(@ability.can?(:read, {:any => [4, 5]}, 3)).to be(true)
+    expect(@ability.can?(:read, {:any => [2, 3]}, 3)).to be(false)
   end
 
   it "uses conditions as third parameter and determine abilities from it" do
     @ability.can :read, Range, :begin => 1, :end => 3
-    expect(@ability.can?(:read, 1..3)).to be_true
-    expect(@ability.can?(:read, 1..4)).to be_false
-    expect(@ability.can?(:read, Range)).to be_true
-    expect(@ability.can?(:read, {:any => [1..3, 1..4]})).to be_true
-    expect(@ability.can?(:read, {:any => [1..4, 2..4]})).to be_false
+
+    expect(@ability.can?(:read, 1..3)).to be(true)
+    expect(@ability.can?(:read, 1..4)).to be(false)
+    expect(@ability.can?(:read, Range)).to be(true)
+    expect(@ability.can?(:read, {:any => [1..3, 1..4]})).to be(true)
+    expect(@ability.can?(:read, {:any => [1..4, 2..4]})).to be(false)
   end
 
   it "allows an array of options in conditions hash" do
     @ability.can :read, Range, :begin => [1, 3, 5]
-    expect(@ability.can?(:read, 1..3)).to be_true
-    expect(@ability.can?(:read, 2..4)).to be_false
-    expect(@ability.can?(:read, 3..5)).to be_true
-    expect(@ability.can?(:read, {:any => [2..4, 3..5]})).to be_true
-    expect(@ability.can?(:read, {:any => [2..4, 2..5]})).to be_false
+
+    expect(@ability.can?(:read, 1..3)).to be(true)
+    expect(@ability.can?(:read, 2..4)).to be(false)
+    expect(@ability.can?(:read, 3..5)).to be(true)
+    expect(@ability.can?(:read, {:any => [2..4, 3..5]})).to be(true)
+    expect(@ability.can?(:read, {:any => [2..4, 2..5]})).to be(false)
   end
 
   it "allows a range of options in conditions hash" do
     @ability.can :read, Range, :begin => 1..3
-    expect(@ability.can?(:read, 1..10)).to be_true
-    expect(@ability.can?(:read, 3..30)).to be_true
-    expect(@ability.can?(:read, 4..40)).to be_false
+    expect(@ability.can?(:read, 1..10)).to be(true)
+    expect(@ability.can?(:read, 3..30)).to be(true)
+    expect(@ability.can?(:read, 4..40)).to be(false)
   end
 
   it "allows nested hashes in conditions hash" do
     @ability.can :read, Range, :begin => { :to_i => 5 }
-    expect(@ability.can?(:read, 5..7)).to be_true
-    expect(@ability.can?(:read, 6..8)).to be_false
+    expect(@ability.can?(:read, 5..7)).to be(true)
+    expect(@ability.can?(:read, 6..8)).to be(false)
   end
 
   it "matches any element passed in to nesting if it's an array (for has_many associations)" do
     @ability.can :read, Range, :to_a => { :to_i => 3 }
-    expect(@ability.can?(:read, 1..5)).to be_true
-    expect(@ability.can?(:read, 4..6)).to be_false
+    expect(@ability.can?(:read, 1..5)).to be(true)
+    expect(@ability.can?(:read, 4..6)).to be(false)
   end
 
   it "accepts a set as a condition value" do
     expect(object_with_foo_2 = double(:foo => 2)).to receive(:foo)
-    expect(object_with_foo_3 = double(:foo => 3)).to receive(:foo) 
+    expect(object_with_foo_3 = double(:foo => 3)).to receive(:foo)
     @ability.can :read, Object, :foo => [1, 2, 5].to_set
-    expect(@ability.can?(:read, object_with_foo_2)).to be_true
-    expect(@ability.can?(:read, object_with_foo_3)).to be_false
+    expect(@ability.can?(:read, object_with_foo_2)).to be(true)
+    expect(@ability.can?(:read, object_with_foo_3)).to be(false)
   end
 
   it "does not match subjects return nil for methods that must match nested a nested conditions hash" do
     expect(object_with_foo = double(:foo => :bar)).to receive(:foo)
     @ability.can :read, Array, :first => { :foo => :bar }
-    expect(@ability.can?(:read, [object_with_foo])).to be_true
-    expect(@ability.can?(:read, [])).to be_false
+    expect(@ability.can?(:read, [object_with_foo])).to be(true)
+    expect(@ability.can?(:read, [])).to be(false)
   end
 
   it "matches strings but not substrings specified in a conditions hash" do
     @ability.can :read, String, :presence => "declassified"
-    expect(@ability.can?(:read, "declassified")).to be_true
-    expect(@ability.can?(:read, "classified")).to be_false
+    expect(@ability.can?(:read, "declassified")).to be(true)
+    expect(@ability.can?(:read, "classified")).to be(false)
   end
 
   it "does not stop at cannot definition when comparing class" do
     @ability.can :read, Range
     @ability.cannot :read, Range, :begin => 1
-    expect(@ability.can?(:read, 2..5)).to be_true
-    expect(@ability.can?(:read, 1..5)).to be_false
-    expect(@ability.can?(:read, Range)).to be_true
+    expect(@ability.can?(:read, 2..5)).to be(true)
+    expect(@ability.can?(:read, 1..5)).to be(false)
+    expect(@ability.can?(:read, Range)).to be(true)
   end
 
   it "stops at cannot definition when no hash is present" do
     @ability.can :read, :all
     @ability.cannot :read, Range
-    expect(@ability.can?(:read, 1..5)).to be_false
-    expect(@ability.can?(:read, Range)).to be_false
+    expect(@ability.can?(:read, 1..5)).to be(false)
+    expect(@ability.can?(:read, Range)).to be(false)
   end
 
   it "allows to check ability for Module" do
     module B; end
     class A; include B; end
     @ability.can :read, B
-    expect(@ability.can?(:read, A)).to be_true
-    expect(@ability.can?(:read, A.new)).to be_true
+    expect(@ability.can?(:read, A)).to be(true)
+    expect(@ability.can?(:read, A.new)).to be(true)
   end
 
   it "passes nil to a block for ability on Module when no instance is passed" do
@@ -326,33 +330,35 @@ describe CanCan::Ability do
       expect(sym).to be_nil
       true
     end
-    expect(@ability.can?(:read, B)).to be_true
-    expect(@ability.can?(:read, A)).to be_true
+    expect(@ability.can?(:read, B)).to be(true)
+    expect(@ability.can?(:read, A)).to be(true)
   end
 
   it "checks permissions through association when passing a hash of subjects" do
     @ability.can :read, Range, :string => {:length => 3}
-    expect(@ability.can?(:read, "foo" => Range)).to be_true
-    expect(@ability.can?(:read, "foobar" => Range)).to be_false
-    expect(@ability.can?(:read, 123 => Range)).to be_true
-    expect(@ability.can?(:read, {:any => [{"foo" => Range}, {"foobar" => Range}]})).to be_true
-    expect(@ability.can?(:read, {:any => [{"food" => Range}, {"foobar" => Range}]})).to be_false
+
+    expect(@ability.can?(:read, "foo" => Range)).to be(true)
+    expect(@ability.can?(:read, "foobar" => Range)).to be(false)
+    expect(@ability.can?(:read, 123 => Range)).to be(true)
+    expect(@ability.can?(:read, {:any => [{"foo" => Range}, {"foobar" => Range}]})).to be(true)
+    expect(@ability.can?(:read, {:any => [{"food" => Range}, {"foobar" => Range}]})).to be(false)
   end
 
   it "checks permissions correctly when passing a hash of subjects with multiple definitions" do
     @ability.can :read, Range, :string => {:length => 4}
     @ability.can [:create, :read], Range, :string => {:upcase => 'FOO'}
-    expect(@ability.can?(:read, "foo" => Range)).to be_true
-    expect(@ability.can?(:read, "foobar" => Range)).to be_false
-    expect(@ability.can?(:read, 1234 => Range)).to be_true
-    expect(@ability.can?(:read, {:any => [{"foo" => Range}, {"foobar" => Range}]})).to be_true
-    expect(@ability.can?(:read, {:any => [{"foo.bar" => Range}, {"foobar" => Range}]})).to be_false
+
+    expect(@ability.can?(:read, "foo" => Range)).to be(true)
+    expect(@ability.can?(:read, "foobar" => Range)).to be(false)
+    expect(@ability.can?(:read, 1234 => Range)).to be(true)
+    expect(@ability.can?(:read, {:any => [{"foo" => Range}, {"foobar" => Range}]})).to be(true)
+    expect(@ability.can?(:read, {:any => [{"foo.bar" => Range}, {"foobar" => Range}]})).to be(false)
   end
 
   it "allows to check ability on Hash-like object" do
     class Container < Hash; end
     @ability.can :read, Container
-    expect(@ability.can?(:read, Container.new)).to be_true
+    expect(@ability.can?(:read, Container.new)).to be(true)
   end
 
   it "has initial attributes based on hash conditions of 'new' action" do
@@ -474,7 +480,7 @@ describe CanCan::Ability do
       another_ability.can :use, :search
 
       @ability.merge(another_ability)
-      expect(@ability.can?(:use, :search)).to be_true
+      expect(@ability.can?(:use, :search)).to be(true)
       expect(@ability.send(:rules).size).to eq(2)
     end
   end

data/spec/cancan/controller_additions_spec.rb

@@ -17,7 +17,7 @@ describe CanCan::ControllerAdditions do
   it "authorize! assigns @_authorized instance variable and pass args to current ability" do
     allow(@controller.current_ability).to receive(:authorize!).with(:foo, :bar)
     @controller.authorize!(:foo, :bar)
-    expect(@controller.instance_variable_get(:@_authorized)).to be_true
+    expect(@controller.instance_variable_get(:@_authorized)).to be(true)
   end
 
   it "has a current_ability method which generates an ability for the current user" do
@@ -26,8 +26,8 @@ describe CanCan::ControllerAdditions do
 
   it "provides a can? and cannot? methods which go through the current ability" do
     expect(@controller.current_ability).to be_kind_of(Ability)
-    expect(@controller.can?(:foo, :bar)).to be_false
-    expect(@controller.cannot?(:foo, :bar)).to be_true
+    expect(@controller.can?(:foo, :bar)).to be(false)
+    expect(@controller.cannot?(:foo, :bar)).to be(true)
   end
 
   it "load_and_authorize_resource setups a before filter which passes call to ControllerResource" do
@@ -38,7 +38,7 @@ describe CanCan::ControllerAdditions do
   end
 
   it "load_and_authorize_resource properly passes first argument as the resource name" do
-    expect(cancan_resource_class = double).to receive(:load_and_authorize_resource) 
+    expect(cancan_resource_class = double).to receive(:load_and_authorize_resource)
     allow(CanCan::ControllerResource).to receive(:new).with(@controller, :project, :foo => :bar) {cancan_resource_class}
     expect(@controller_class).to receive(:before_filter).with({}) { |options, &block| block.call(@controller) }
     @controller_class.load_and_authorize_resource :project, :foo => :bar
@@ -50,14 +50,14 @@ describe CanCan::ControllerAdditions do
   end
 
   it "authorize_resource setups a before filter which passes call to ControllerResource" do
-    expect(cancan_resource_class = double).to receive(:authorize_resource) 
+    expect(cancan_resource_class = double).to receive(:authorize_resource)
     allow(CanCan::ControllerResource).to receive(:new).with(@controller, nil, :foo => :bar) {cancan_resource_class}
     expect(@controller_class).to receive(:before_filter).with(:except => :show, :if => true) { |options, &block| block.call(@controller) }
     @controller_class.authorize_resource :foo => :bar, :except => :show, :if => true
   end
 
   it "load_resource setups a before filter which passes call to ControllerResource" do
-    expect(cancan_resource_class = double).to receive(:load_resource) 
+    expect(cancan_resource_class = double).to receive(:load_resource)
     allow(CanCan::ControllerResource).to receive(:new).with(@controller, nil, :foo => :bar) {cancan_resource_class}
     expect(@controller_class).to receive(:before_filter).with(:only => [:show, :index], :unless => false) { |options, &block| block.call(@controller) }
     @controller_class.load_resource :foo => :bar, :only => [:show, :index], :unless => false
@@ -66,7 +66,7 @@ describe CanCan::ControllerAdditions do
   it "skip_authorization_check setups a before filter which sets @_authorized to true" do
     expect(@controller_class).to receive(:before_filter).with(:filter_options) { |options, &block| block.call(@controller) }
     @controller_class.skip_authorization_check(:filter_options)
-    expect(@controller.instance_variable_get(:@_authorized)).to be_true
+    expect(@controller.instance_variable_get(:@_authorized)).to be(true)
   end
 
   it "check_authorization triggers AuthorizationNotPerformed in after filter" do
@@ -112,7 +112,7 @@ describe CanCan::ControllerAdditions do
   it "cancan_skipper is an empty hash with :authorize and :load options and remember changes" do
     expect(@controller_class.cancan_skipper).to eq({:authorize => {}, :load => {}})
     @controller_class.cancan_skipper[:load] = true
-    expect(@controller_class.cancan_skipper[:load]).to be_true
+    expect(@controller_class.cancan_skipper[:load]).to be(true)
   end
 
   it "skip_authorize_resource adds itself to the cancan skipper with given model name and options" do