warden 1.2.3 → 1.2.5

data/spec/warden/scoped_session_serializer.rb

@@ -31,25 +31,25 @@ describe Warden::Manager do
   end
 
   it "should respond to :serialize" do
-    serializer_respond_to?(:serialize).should == true
+    serializer_respond_to?(:serialize).should be_true
   end
 
   it "should respond to :deserialize" do
-    serializer_respond_to?(:deserialize).should == true
+    serializer_respond_to?(:deserialize).should be_true
   end
 
   it "should respond to {scope}_deserialize if Manager.serialize_from_session is called with scope" do
     Rack::Builder.new do 
       Warden::Manager.serialize_from_session ( :admin ) { |n| n }
     end
-    serializer_respond_to?(:admin_deserialize).should == true
+    serializer_respond_to?(:admin_deserialize).should be_true
   end
 
   it "should respond to {scope}_serialize if Manager.serialize_into_session is called with scope" do
     Rack::Builder.new do 
       Warden::Manager.serialize_into_session(:admin) { |n| n }
     end
-    serializer_respond_to?(:admin_serialize).should == true
+    serializer_respond_to?(:admin_serialize).should be_true
   end
 
   def initialize_with_scope(scope, &block)
@@ -66,11 +66,11 @@ describe Warden::Manager do
     end
     serializer = Warden::SessionSerializer.new(@env)
     serializer.store("user", :admin)
-    serialized_object.should == "user"
+    serialized_object.should eq("user")
   end
 
   it "should not have a {scope}_serialize by default" do
-    serializer_respond_to?(:admin_serialize).should == false
+    serializer_respond_to?(:admin_serialize).should be_false
   end
 
   it "should execute {scope}_serialize when calling store with a scope" do
@@ -82,7 +82,7 @@ describe Warden::Manager do
 
     serializer = Warden::SessionSerializer.new(@env)
     serializer.store("user", :admin)
-    serialized_object.should == "user"
+    serialized_object.should eq("user")
   end
 
 
@@ -100,7 +100,7 @@ describe Warden::Manager do
     @env['rack.session'][serializer.key_for(:admin)] = "test"
     serializer.fetch(:admin)
 
-    serialized_object.should == "test"
+    serialized_object.should eq("test")
   end
 
   it "should execute deserialize if {scope}_deserialize is not present" do
@@ -117,7 +117,7 @@ describe Warden::Manager do
     @env['rack.session'][serializer.key_for(:admin)] = "test"
     serializer.fetch(:admin)
 
-    serialized_object.should == "test"
+    serialized_object.should eq("test")
   end
 
 end

data/spec/warden/session_serializer_spec.rb

@@ -10,44 +10,44 @@ describe Warden::SessionSerializer do
 
   it "should store data for the default scope" do
     @session.store("user", :default)
-    @env['rack.session'].should == { "warden.user.default.key"=>"user" }
+    expect(@env['rack.session']).to eq({ "warden.user.default.key"=>"user" })
   end
 
   it "should check if a data is stored or not" do
-    @session.should_not be_stored(:default)
+    expect(@session).not_to be_stored(:default)
     @session.store("user", :default)
-    @session.should be_stored(:default)
+    expect(@session).to be_stored(:default)
   end
 
   it "should load an user from store" do
-    @session.fetch(:default).should be_nil
+    expect(@session.fetch(:default)).to be_nil
     @session.store("user", :default)
-    @session.fetch(:default).should == "user"
+    expect(@session.fetch(:default)).to eq("user")
   end
 
   it "should store data based on the scope" do
     @session.store("user", :default)
-    @session.fetch(:default).should == "user"
-    @session.fetch(:another).should be_nil
+    expect(@session.fetch(:default)).to eq("user")
+    expect(@session.fetch(:another)).to be_nil
   end
 
   it "should delete data from store" do
     @session.store("user", :default)
-    @session.fetch(:default).should == "user"
+    expect(@session.fetch(:default)).to eq("user")
     @session.delete(:default)
-    @session.fetch(:default).should be_nil
+    expect(@session.fetch(:default)).to be_nil
   end
 
   it "should delete information from store if user cannot be retrieved" do
     @session.store("user", :default)
-    @env['rack.session'].should have_key("warden.user.default.key")
-    @session.instance_eval "def deserialize(key); nil; end"
+    expect(@env['rack.session']).to have_key("warden.user.default.key")
+    allow(@session).to receive(:deserialize).and_return(nil)
     @session.fetch(:default)
-    @env['rack.session'].should_not have_key("warden.user.default.key")
+    expect(@env['rack.session']).not_to have_key("warden.user.default.key")
   end
 
   it "should support a nil session store" do
     @env['rack.session'] = nil
-    @session.fetch(:default).should be_nil
+    expect(@session.fetch(:default)).to be_nil
   end
 end

data/spec/warden/strategies/base_spec.rb

@@ -17,7 +17,7 @@ describe Warden::Strategies::Base do
       end
       strategy = Warden::Strategies[:foo].new(env_with_params)
       strategy._run!
-      strategy.headers["foo"].should == "bar"
+      expect(strategy.headers["foo"]).to eq("bar")
     end
 
     it "should allow us to clear the headers" do
@@ -28,9 +28,9 @@ describe Warden::Strategies::Base do
       end
       strategy = Warden::Strategies[:foo].new(env_with_params)
       strategy._run!
-      strategy.headers["foo"].should == "bar"
+      expect(strategy.headers["foo"]).to eq("bar")
       strategy.headers.clear
-      strategy.headers.should be_empty
+      expect(strategy.headers).to be_empty
     end
   end
 
@@ -42,7 +42,7 @@ describe Warden::Strategies::Base do
     end
     strategy = RAS[:foobar].new(env_with_params)
     strategy._run!
-    strategy.user.should == "foo"
+    expect(strategy.user).to eq("foo")
   end
 
   it "should be performed after run" do
@@ -50,20 +50,20 @@ describe Warden::Strategies::Base do
       def authenticate!; end
     end
     strategy = RAS[:foobar].new(env_with_params)
-    strategy.should_not be_performed
+    expect(strategy).not_to be_performed
     strategy._run!
-    strategy.should be_performed
+    expect(strategy).to be_performed
     strategy.clear!
-    strategy.should_not be_performed
+    expect(strategy).not_to be_performed
   end
 
   it "should set the scope" do
     RAS.add(:foobar) do
       def authenticate!
-        self.scope.should == :user
+        expect(self.scope).to eq(:user) # TODO: Not being called at all. What's this?
       end
     end
-    strategy = RAS[:foobar].new(env_with_params, :user)
+    _strategy = RAS[:foobar].new(env_with_params, :user)
   end
 
   it "should allow you to set a message" do
@@ -74,7 +74,7 @@ describe Warden::Strategies::Base do
     end
     strategy = RAS[:foobar].new(env_with_params)
     strategy._run!
-    strategy.message.should == "foo message"
+    expect(strategy.message).to eq("foo message")
   end
 
   it "should provide access to the errors" do
@@ -87,7 +87,7 @@ describe Warden::Strategies::Base do
     env['warden'] = Warden::Proxy.new(env, Warden::Manager.new({}))
     strategy = RAS[:foobar].new(env)
     strategy._run!
-    strategy.errors.on(:foo).should == ["foo has an error"]
+    expect(strategy.errors.on(:foo)).to eq(["foo has an error"])
   end
 
   describe "halting" do
@@ -99,7 +99,7 @@ describe Warden::Strategies::Base do
       end
       str = RAS[:foobar].new(env_with_params)
       str._run!
-      str.should be_halted
+      expect(str).to be_halted
     end
 
     it "should not be halted if halt was not called" do
@@ -110,7 +110,7 @@ describe Warden::Strategies::Base do
       end
       str = RAS[:foobar].new(env_with_params)
       str._run!
-      str.should_not be_halted
+      expect(str).not_to be_halted
     end
 
   end
@@ -124,8 +124,8 @@ describe Warden::Strategies::Base do
       end
       str = RAS[:foobar].new(env_with_params)
       str._run!
-      str.should_not be_halted
-      str.user.should be_nil
+      expect(str).not_to be_halted
+      expect(str.user).to be_nil
     end
   end
 
@@ -138,7 +138,7 @@ describe Warden::Strategies::Base do
       end
       str = RAS[:foobar].new(env_with_params)
       str._run!
-      str.user.should be_nil
+      expect(str.user).to be_nil
     end
 
     it "should mark the strategy as halted when redirecting" do
@@ -149,7 +149,7 @@ describe Warden::Strategies::Base do
       end
       str = RAS[:foobar].new(env_with_params)
       str._run!
-      str.should be_halted
+      expect(str).to be_halted
     end
 
     it "should escape redirected url parameters" do
@@ -160,7 +160,7 @@ describe Warden::Strategies::Base do
       end
       str = RAS[:foobar].new(env_with_params)
       str._run!
-      str.headers["Location"].should == "/foo/bar?foo=bar"
+      expect(str.headers["Location"]).to eq("/foo/bar?foo=bar")
     end
 
     it "should allow you to set a message" do
@@ -171,8 +171,8 @@ describe Warden::Strategies::Base do
       end
       str = RAS[:foobar].new(env_with_params)
       str._run!
-      str.headers["Location"].should == "/foo/bar?foo=bar"
-      str.message.should == "You are being redirected foo"
+      expect(str.headers["Location"]).to eq("/foo/bar?foo=bar")
+      expect(str.message).to eq("You are being redirected foo")
     end
 
     it "should set the action as :redirect" do
@@ -183,7 +183,7 @@ describe Warden::Strategies::Base do
       end
       str = RAS[:foobar].new(env_with_params)
       str._run!
-      str.result.should == :redirect
+      expect(str.result).to be(:redirect)
     end
   end
 
@@ -207,42 +207,42 @@ describe Warden::Strategies::Base do
 
     it "should allow you to fail hard" do
       @hard._run!
-      @hard.user.should be_nil
+      expect(@hard.user).to be_nil
     end
 
     it "should halt the strategies when failing hard" do
       @hard._run!
-      @hard.should be_halted
+      expect(@hard).to be_halted
     end
 
     it "should allow you to set a message when failing hard" do
       @hard._run!
-      @hard.message.should == "You are not cool enough"
+      expect(@hard.message).to eq("You are not cool enough")
     end
 
     it "should set the action as :failure when failing hard" do
       @hard._run!
-      @hard.result.should == :failure
+      expect(@hard.result).to be(:failure)
     end
 
     it "should allow you to fail soft" do
       @soft._run!
-      @soft.user.should be_nil
+      expect(@soft.user).to be_nil
     end
 
     it "should not halt the strategies when failing soft" do
       @soft._run!
-      @soft.should_not be_halted
+      expect(@soft).not_to be_halted
     end
 
     it "should allow you to set a message when failing soft" do
       @soft._run!
-      @soft.message.should == "You are too soft"
+      expect(@soft.message).to eq("You are too soft")
     end
 
     it "should set the action as :failure when failing soft" do
       @soft._run!
-      @soft.result.should == :failure
+      expect(@soft.result).to be(:failure)
     end
   end
 
@@ -262,22 +262,22 @@ describe Warden::Strategies::Base do
 
     it "should be authenticated after success" do
       @str._run!
-      @str.user.should_not be_nil
+      expect(@str.user).not_to be_nil
     end
 
     it "should allow you to set a message when succeeding" do
       @str._run!
-      @str.message.should == "Welcome to the club!"
+      expect(@str.message).to eq("Welcome to the club!")
     end
 
     it "should store the user" do
       @str._run!
-      @str.user.should == "Foo User"
+      expect(@str.user).to eq("Foo User")
     end
 
     it "should set the action as :success" do
       @str._run!
-      @str.result.should == :success
+      expect(@str.result).to be(:success)
     end
   end
 
@@ -293,20 +293,20 @@ describe Warden::Strategies::Base do
     end
 
     it "should allow me to set a custom rack response" do
-      @str.user.should be_nil
+      expect(@str.user).to be_nil
     end
 
     it "should halt the strategy" do
-      @str.should be_halted
+      expect(@str).to be_halted
     end
 
     it "should provide access to the custom rack response" do
-      @str.custom_response.should == [521, {"foo" => "bar"}, ["BAD"]]
+      expect(@str.custom_response).to eq([521, {"foo" => "bar"}, ["BAD"]])
     end
 
     it "should set the action as :custom" do
       @str._run!
-      @str.result.should == :custom
+      expect(@str.result).to eq(:custom)
     end
   end
 

data/spec/warden/strategies_spec.rb

@@ -8,14 +8,14 @@ describe Warden::Strategies do
         success("foo")
       end
     end
-    Warden::Strategies[:strategy1].ancestors.should include(Warden::Strategies::Base)
+    expect(Warden::Strategies[:strategy1].ancestors).to include(Warden::Strategies::Base)
   end
 
   it "should raise an error if I add a strategy via a block, that does not have an authenticate! method" do
-    lambda do
+    expect {
       Warden::Strategies.add(:strategy2) do
       end
-    end.should raise_error
+    }.to raise_error(NoMethodError)
   end
 
   it "should raise an error if I add a strategy that does not extend Warden::Strategies::Base" do
@@ -33,25 +33,26 @@ describe Warden::Strategies do
       def authenticate!; end
     end
     strategy = Warden::Strategies[:strategy3]
-    strategy.should_not be_nil
-    strategy.ancestors.should include(Warden::Strategies::Base)
+    expect(strategy).not_to be_nil
+    expect(strategy.ancestors).to include(Warden::Strategies::Base)
   end
 
   it "should allow me to add a strategy with the required methods" do
     class MyStrategy < Warden::Strategies::Base
       def authenticate!; end
     end
-    lambda do
+
+    expect {
       Warden::Strategies.add(:strategy4, MyStrategy)
-    end.should_not raise_error
+    }.not_to raise_error
   end
 
   it "should not allow a strategy that does not have an authenticate! method" do
     class MyOtherStrategy
     end
-    lambda do
+    expect {
       Warden::Strategies.add(:strategy5, MyOtherStrategy)
-    end.should raise_error
+    }.to raise_error(NoMethodError)
   end
 
   it "should allow me to change a class when providing a block and class" do
@@ -62,7 +63,7 @@ describe Warden::Strategies do
       def authenticate!; end
     end
 
-    Warden::Strategies[:foo].ancestors.should include(MyStrategy)
+    expect(Warden::Strategies[:foo].ancestors).to include(MyStrategy)
   end
 
   it "should allow me to update a previously given strategy" do
@@ -77,7 +78,7 @@ describe Warden::Strategies do
       include new_module
     end
 
-    Warden::Strategies[:strategy6].ancestors.should include(new_module)
+    expect(Warden::Strategies[:strategy6].ancestors).to include(new_module)
   end
 
   it "should allow me to clear the strategies" do
@@ -86,8 +87,8 @@ describe Warden::Strategies do
         :foo
       end
     end
-    Warden::Strategies[:foobar].should_not be_nil
+    expect(Warden::Strategies[:foobar]).not_to be_nil
     Warden::Strategies.clear!
-    Warden::Strategies[:foobar].should be_nil
+    expect(Warden::Strategies[:foobar]).to be_nil
   end
 end

data/spec/warden/test/helpers_spec.rb

@@ -10,12 +10,12 @@ describe Warden::Test::Helpers do
     login_as user
     app = lambda{|e|
       $captures << :run
-      e['warden'].should be_authenticated
-      e['warden'].user.should == "A User"
+      expect(e['warden']).to be_authenticated
+      expect(e['warden'].user).to eq("A User")
       valid_response
     }
     setup_rack(app).call(env_with_params)
-    $captures.should == [:run]
+    expect($captures).to eq([:run])
   end
 
   it "should log me in as a user of a given scope" do
@@ -24,11 +24,11 @@ describe Warden::Test::Helpers do
     app = lambda{|e|
       $captures << :run
       w = e['warden']
-      w.should be_authenticated(:foo_scope)
-      w.user(:foo_scope).should == {:some => "user"}
+      expect(w).to be_authenticated(:foo_scope)
+      expect(w.user(:foo_scope)).to eq(some: "user")
     }
     setup_rack(app).call(env_with_params)
-    $captures.should == [:run]
+    expect($captures).to eq([:run])
   end
 
   it "should login multiple users with different scopes" do
@@ -39,13 +39,13 @@ describe Warden::Test::Helpers do
     app = lambda{|e|
       $captures << :run
       w = e['warden']
-      w.user.should == "A user"
-      w.user(:foo).should == "A foo user"
-      w.should be_authenticated
-      w.should be_authenticated(:foo)
+      expect(w.user).to eq("A user")
+      expect(w.user(:foo)).to eq("A foo user")
+      expect(w).to be_authenticated
+      expect(w).to be_authenticated(:foo)
     }
     setup_rack(app).call(env_with_params)
-    $captures.should == [:run]
+    expect($captures).to eq([:run])
   end
 
   it "should log out all users" do
@@ -56,16 +56,16 @@ describe Warden::Test::Helpers do
     app = lambda{|e|
       $captures << :run
       w = e['warden']
-      w.user.should == "A user"
-      w.user(:foo).should == "Foo"
+      expect(w.user).to eq("A user")
+      expect(w.user(:foo)).to eq("Foo")
       w.logout
-      w.user.should be_nil
-      w.user(:foo).should be_nil
-      w.should_not be_authenticated
-      w.should_not be_authenticated(:foo)
+      expect(w.user).to be_nil
+      expect(w.user(:foo)).to be_nil
+      expect(w).not_to be_authenticated
+      expect(w).not_to be_authenticated(:foo)
     }
     setup_rack(app).call(env_with_params)
-    $captures.should == [:run]
+    expect($captures).to eq([:run])
   end
 
   it "should logout a specific user" do
@@ -77,17 +77,25 @@ describe Warden::Test::Helpers do
       $captures << :run
       w = e['warden']
       w.logout :foo
-      w.user.should == "A User"
-      w.user(:foo).should be_nil
-      w.should_not be_authenticated(:foo)
+      expect(w.user).to eq("A User")
+      expect(w.user(:foo)).to be_nil
+      expect(w).not_to be_authenticated(:foo)
     }
     setup_rack(app).call(env_with_params)
-    $captures.should == [:run]
+    expect($captures).to eq([:run])
+  end
+
+  it "should return a valid mocked warden" do
+    user = "A User"
+    login_as user
+
+    expect(warden.class).to eq(Warden::Proxy)
+    expect(warden.user).to eq(user)
   end
 
   describe "#asset_paths" do
     it "should default asset_paths to anything asset path regex" do
-      Warden.asset_paths.should == [/^\/assets\//]      
+      expect(Warden.asset_paths).to eq([/^\/assets\//]      )
     end
   end
 end

data/spec/warden/test/test_mode_spec.rb

@@ -15,9 +15,9 @@ describe Warden::Test::WardenHelpers do
     Warden.test_reset!
   end
 
-  it{ Warden.should respond_to(:test_mode!)       }
-  it{ Warden.should respond_to(:on_next_request)  }
-  it{ Warden.should respond_to(:test_reset!)      }
+  it{ expect(Warden).to respond_to(:test_mode!)       }
+  it{ expect(Warden).to respond_to(:on_next_request)  }
+  it{ expect(Warden).to respond_to(:test_reset!)      }
 
   it "should execute the on_next_request block on the next request" do
     Warden.on_next_request do |warden|
@@ -25,36 +25,35 @@ describe Warden::Test::WardenHelpers do
     end
 
     setup_rack(@app).call(env_with_params)
-    $captures.should have(1).item
-    $captures.first.should be_an_instance_of(Warden::Proxy)
+    expect($captures.length).to eq(1)
+    expect($captures.first).to be_an_instance_of(Warden::Proxy)
   end
 
   it "should execute many on_next_request blocks on the next request" do
     Warden.on_next_request{|w| $captures << :first    }
     Warden.on_next_request{|w| $captures << :second   }
     setup_rack(@app).call(env_with_params)
-    $captures.should have(2).items
-    $captures.should == [:first, :second]
+    expect($captures).to eq([:first, :second])
   end
 
   it "should not execute on_next_request blocks on subsequent requests" do
     app = setup_rack(@app)
     Warden.on_next_request{|w| $captures << :first }
     app.call(env_with_params)
-    $captures.should == [:first]
+    expect($captures).to eq([:first])
     $captures.clear
     app.call(env_with_params)
-    $captures.should be_empty
+    expect($captures).to be_empty
   end
 
   it "should allow me to set new_on_next_request items to execute in the same test" do
     app = setup_rack(@app)
     Warden.on_next_request{|w| $captures << :first }
     app.call(env_with_params)
-    $captures.should == [:first]
+    expect($captures).to eq([:first])
     Warden.on_next_request{|w| $captures << :second }
     app.call(env_with_params)
-    $captures.should == [:first, :second]
+    expect($captures).to eq([:first, :second])
   end
 
   it "should remove the on_next_request items when test is reset" do
@@ -62,7 +61,7 @@ describe Warden::Test::WardenHelpers do
     Warden.on_next_request{|w| $captures << :first }
     Warden.test_reset!
     app.call(env_with_params)
-    $captures.should == []
+    expect($captures).to eq([])
   end
 
   context "asset requests" do
@@ -70,7 +69,7 @@ describe Warden::Test::WardenHelpers do
       app = setup_rack(@app)
       Warden.on_next_request{|w| $captures << :first }
       app.call(env_with_params("/assets/fun.gif"))
-      $captures.should == []
+      expect($captures).to eq([])
     end
   end
 end