warden 1.2.3 → 1.2.4

data/spec/warden/config_spec.rb

@@ -9,40 +9,40 @@ describe Warden::Config do
 
   it "should behave like a hash" do
     @config[:foo] = :bar
-    @config[:foo].should == :bar
+    expect(@config[:foo]).to eq(:bar)
   end
 
   it "should provide hash accessors" do
     @config.failure_app = :foo
-    @config[:failure_app].should == :foo
+    expect(@config[:failure_app]).to eq(:foo)
     @config[:failure_app] = :bar
-    @config.failure_app.should == :bar
+    expect(@config.failure_app).to eq(:bar)
   end
 
   it "should allow to read and set default strategies" do
     @config.default_strategies :foo, :bar
-    @config.default_strategies.should == [:foo, :bar]
+    expect(@config.default_strategies).to eq([:foo, :bar])
   end
 
   it "should allow to silence missing strategies" do
     @config.silence_missing_strategies!
-    @config.silence_missing_strategies?.should be_true
+    expect(@config.silence_missing_strategies?).to eq(true)
   end
 
   it "should set the default_scope" do
-    @config.default_scope.should == :default
+    expect(@config.default_scope).to eq(:default)
     @config.default_scope = :foo
-    @config.default_scope.should == :foo
+    expect(@config.default_scope).to eq(:foo)
   end
 
   it "should merge given options on initialization" do
-    Warden::Config.new(:foo => :bar)[:foo].should == :bar
+    expect(Warden::Config.new(:foo => :bar)[:foo]).to eq(:bar)
   end
 
   it "should setup defaults with the scope_defaults method" do
     c = Warden::Config.new
     c.scope_defaults :foo, :strategies => [:foo, :bar], :store => false
-    c.default_strategies(:scope => :foo).should == [:foo, :bar]
-    c.scope_defaults(:foo).should == {:store => false}
+    expect(c.default_strategies(:scope => :foo)).to eq([:foo, :bar])
+    expect(c.scope_defaults(:foo)).to eq(store: false)
   end
 end

data/spec/warden/errors_spec.rb

@@ -8,40 +8,40 @@ describe Warden::Proxy::Errors do
   end
 
   it "should report that it is empty on first creation" do
-    @errors.empty?.should == true
+    expect(@errors).to be_empty
   end
 
   it "should continue to report that it is empty even after being checked" do
     @errors.on(:foo)
-    @errors.empty?.should == true
+    expect(@errors).to be_empty
   end
 
   it "should add an error" do
     @errors.add(:login, "Login or password incorrect")
-    @errors[:login].should == ["Login or password incorrect"]
+    expect(@errors[:login]).to eq(["Login or password incorrect"])
   end
 
   it "should allow many errors to be added to the same field" do
     @errors.add(:login, "bad 1")
     @errors.add(:login, "bad 2")
-    @errors.on(:login).should == ["bad 1", "bad 2"]
+    expect(@errors.on(:login)).to eq(["bad 1", "bad 2"])
   end
 
   it "should give the full messages for an error" do
     @errors.add(:login, "login wrong")
     @errors.add(:password, "password wrong")
     ["password wrong", "login wrong"].each do |msg|
-      @errors.full_messages.should include(msg)
+      expect(@errors.full_messages).to include(msg)
     end
   end
 
   it "should return the error for a specific field / label" do
     @errors.add(:login, "wrong")
-    @errors.on(:login).should == ["wrong"]
+    expect(@errors.on(:login)).to eq(["wrong"])
   end
 
   it "should return nil for a specific field if it's not been set" do
-    @errors.on(:not_there).should be_nil
+    expect(@errors.on(:not_there)).to be_nil
   end
 
 end

data/spec/warden/hooks_spec.rb

@@ -21,13 +21,13 @@ describe "standard authentication hooks" do
       RAM.after_set_user do |user, auth, opts|
         "boo"
       end
-      RAM._after_set_user.should have(1).item
+      expect(RAM._after_set_user.length).to eq(1)
     end
 
     it "should allow me to add multiple after_set_user hooks" do
       RAM.after_set_user{|user, auth, opts| "foo"}
       RAM.after_set_user{|u,a| "bar"}
-      RAM._after_set_user.should have(2).items
+      expect(RAM._after_set_user.length).to eq(2)
     end
 
     it "should run each after_set_user hook after the user is set" do
@@ -40,9 +40,9 @@ describe "standard authentication hooks" do
       end
       env = env_with_params
       setup_rack(app).call(env)
-      env['warden'].user.should be_nil
-      env['warden.spec.hook.foo'].should == "run foo"
-      env['warden.spec.hook.bar'].should == "run bar"
+      expect(env['warden'].user).to be_nil
+      expect(env['warden.spec.hook.foo']).to eq("run foo")
+      expect(env['warden.spec.hook.bar']).to eq("run bar")
     end
 
     it "should not run the event specified with except" do
@@ -76,22 +76,22 @@ describe "standard authentication hooks" do
       end
       env = env_with_params
       setup_rack(app).call(env)
-      env['warden.spec.order'].should == [1,2,3]
+      expect(env['warden.spec.order']).to eq([1,2,3])
     end
 
     context "after_authentication" do
       it "should be a wrapper to after_set_user behavior" do
         RAM.after_authentication{|u,a,o| a.env['warden.spec.hook.baz'] = "run baz"}
         RAM.after_authentication{|u,a,o| a.env['warden.spec.hook.paz'] = "run paz"}
-        RAM.after_authentication{|u,a,o| o[:event].should == :authentication }
+        RAM.after_authentication{|u,a,o| expect(o[:event]).to eq(:authentication) }
         app = lambda do |e|
           e['warden'].authenticate(:pass)
           valid_response
         end
         env = env_with_params
         setup_rack(app).call(env)
-        env['warden.spec.hook.baz'].should == 'run baz'
-        env['warden.spec.hook.paz'].should == 'run paz'
+        expect(env['warden.spec.hook.baz']).to eq('run baz')
+        expect(env['warden.spec.hook.paz']).to eq('run paz')
       end
 
       it "should not be invoked on default after_set_user scenario" do
@@ -115,7 +115,7 @@ describe "standard authentication hooks" do
         end
         env = env_with_params
         setup_rack(app).call(env)
-        env['warden.spec.order'].should == [1,2,3]
+        expect(env['warden.spec.order']).to eq([1,2,3])
       end
 
       it "should allow me to log out a user in an after_set_user block" do
@@ -127,7 +127,7 @@ describe "standard authentication hooks" do
         end
         env = env_with_params
         setup_rack(app).call(env)
-        env['warden'].authenticated?.should be_false
+        expect(env['warden']).not_to be_authenticated
       end
     end
 
@@ -135,13 +135,13 @@ describe "standard authentication hooks" do
       it "should be a wrapper to after_set_user behavior" do
         RAM.after_fetch{|u,a,o| a.env['warden.spec.hook.baz'] = "run baz"}
         RAM.after_fetch{|u,a,o| a.env['warden.spec.hook.paz'] = "run paz"}
-        RAM.after_fetch{|u,a,o| o[:event].should == :fetch }
+        RAM.after_fetch{|u,a,o| expect(o[:event]).to eq(:fetch) }
         env = env_with_params
         setup_rack(lambda { |e| valid_response }).call(env)
         env['rack.session']['warden.user.default.key'] = "Foo"
-        env['warden'].user.should == "Foo"
-        env['warden.spec.hook.baz'].should == 'run baz'
-        env['warden.spec.hook.paz'].should == 'run paz'
+        expect(env['warden'].user).to eq("Foo")
+        expect(env['warden.spec.hook.baz']).to eq('run baz')
+        expect(env['warden.spec.hook.paz']).to eq('run paz')
       end
 
       it "should not be invoked on default after_set_user scenario" do
@@ -159,7 +159,7 @@ describe "standard authentication hooks" do
         env = env_with_params
         setup_rack(lambda { |e| valid_response }).call(env)
         env['rack.session']['warden.user.default.key'] = nil
-        env['warden'].user.should be_nil
+        expect(env['warden'].user).to be_nil
       end
 
       it "should run filters in the given order" do
@@ -174,7 +174,7 @@ describe "standard authentication hooks" do
         end
         env = env_with_params
         setup_rack(app).call(env)
-        env['warden.spec.order'].should == [1,2,3]
+        expect(env['warden.spec.order']).to eq([1,2,3])
       end
     end
   end
@@ -195,7 +195,7 @@ describe "standard authentication hooks" do
       env = env_with_params
       setup_rack(lambda { |e| valid_response }).call(env)
       env['rack.session']['warden.user.default.key'] = "Foo"
-      env['warden'].user.should == "Foo"
+      expect(env['warden'].user).to eq("Foo")
     end
 
     it "should be called if fetched user is nil" do
@@ -203,8 +203,8 @@ describe "standard authentication hooks" do
       RAM.after_failed_fetch{|u,a,o| calls += 1 }
       env = env_with_params
       setup_rack(lambda { |e| valid_response }).call(env)
-      env['warden'].user.should be_nil
-      calls.should == 1
+      expect(env['warden'].user).to be_nil
+      expect(calls).to eq(1)
     end
   end
 
@@ -220,13 +220,13 @@ describe "standard authentication hooks" do
 
     it "should allow me to add a before_failure hook" do
       RAM.before_failure{|env, opts| "foo"}
-      RAM._before_failure.should have(1).item
+      expect(RAM._before_failure.length).to eq(1)
     end
 
     it "should allow me to add multiple before_failure hooks" do
       RAM.before_failure{|env, opts| "foo"}
       RAM.before_failure{|env, opts| "bar"}
-      RAM._before_failure.should have(2).items
+      expect(RAM._before_failure.length).to eq(2)
     end
 
     it "should run each before_failure hooks before failing" do
@@ -235,8 +235,8 @@ describe "standard authentication hooks" do
       app = lambda{|e| e['warden'].authenticate!(:failz); valid_response}
       env = env_with_params
       setup_rack(app).call(env)
-      env['warden.spec.before_failure.foo'].should == "foo"
-      env['warden.spec.before_failure.bar'].should  == "bar"
+      expect(env['warden.spec.before_failure.foo']).to eq("foo")
+      expect(env['warden.spec.before_failure.bar']).to eq("bar")
     end
 
     it "should run filters in the given order" do
@@ -250,7 +250,7 @@ describe "standard authentication hooks" do
       end
       env = env_with_params
       setup_rack(app).call(env)
-      env['warden.spec.order'].should == [1,2,3]
+      expect(env['warden.spec.order']).to eq([1,2,3])
     end
   end
 
@@ -266,13 +266,13 @@ describe "standard authentication hooks" do
 
     it "should allow me to add an before_logout hook" do
       RAM.before_logout{|user, auth, scopes| "foo"}
-      RAM._before_logout.should have(1).item
+      expect(RAM._before_logout.length).to eq(1)
     end
 
     it "should allow me to add multiple after_authentication hooks" do
       RAM.before_logout{|u,a,o| "bar"}
       RAM.before_logout{|u,a,o| "baz"}
-      RAM._before_logout.should have(2).items
+      expect(RAM._before_logout.length).to eq(2)
     end
 
     it "should run each before_logout hook before logout is run" do
@@ -282,8 +282,8 @@ describe "standard authentication hooks" do
       env = env_with_params
       setup_rack(app).call(env)
       env['warden'].logout
-      env['warden.spec.hook.lorem'].should == 'run lorem'
-      env['warden.spec.hook.ipsum'].should == 'run ipsum'
+      expect(env['warden.spec.hook.lorem']).to eq('run lorem')
+      expect(env['warden.spec.hook.ipsum']).to eq('run ipsum')
     end
 
     it "should run before_logout hook for a specified scope" do
@@ -301,12 +301,12 @@ describe "standard authentication hooks" do
       setup_rack(app).call(env)
 
       env['warden'].logout(:scope1)
-      env['warden.spec.hook.a'].should == [:scope1]
-      env['warden.spec.hook.b'].should == []
+      expect(env['warden.spec.hook.a']).to eq([:scope1])
+      expect(env['warden.spec.hook.b']).to eq([])
 
       env['warden'].logout(:scope2)
-      env['warden.spec.hook.a'].should == [:scope1]
-      env['warden.spec.hook.b'].should == [:scope2]
+      expect(env['warden.spec.hook.a']).to eq([:scope1])
+      expect(env['warden.spec.hook.b']).to eq([:scope2])
     end
 
     it "should run filters in the given order" do
@@ -321,14 +321,14 @@ describe "standard authentication hooks" do
       end
       env = env_with_params
       setup_rack(app).call(env)
-      env['warden.spec.order'].should == [1,2,3]
+      expect(env['warden.spec.order']).to eq([1,2,3])
     end
   end
 
   describe "on_request" do
     before(:each) do
-      @old_on_request = RAM._on_request.dup
       RAM = Warden::Manager unless defined?(RAM)
+      @old_on_request = RAM._on_request.dup
       RAM._on_request.clear
     end
 
@@ -339,13 +339,13 @@ describe "standard authentication hooks" do
 
     it "should allow me to add an on_request hook" do
       RAM.on_request{|proxy| "foo"}
-      RAM._on_request.should have(1).item
+      expect(RAM._on_request.length).to eq(1)
     end
 
     it "should allow me to add multiple on_request hooks" do
       RAM.on_request{|proxy| "foo"}
       RAM.on_request{|proxy| "bar"}
-      RAM._on_request.should have(2).items
+      expect(RAM._on_request.length).to eq(2)
     end
 
     it "should run each on_request hooks when initializing" do
@@ -354,8 +354,8 @@ describe "standard authentication hooks" do
       app = lambda{|e| valid_response}
       env = env_with_params
       setup_rack(app).call(env)
-      env['warden.spec.on_request.foo'].should == "foo"
-      env['warden.spec.on_request.bar'].should  == "bar"
+      expect(env['warden.spec.on_request.foo']).to eq("foo")
+      expect(env['warden.spec.on_request.bar']).to  eq("bar")
     end
 
     it "should run filters in the given order" do
@@ -367,7 +367,7 @@ describe "standard authentication hooks" do
       end
       env = Rack::MockRequest.env_for("/", "warden.spec.order" => [])
       setup_rack(app).call(env)
-      env['warden.spec.order'].should == [1,2,3]
+      expect(env['warden.spec.order']).to eq([1,2,3])
     end
   end
 end

data/spec/warden/manager_spec.rb

@@ -10,7 +10,7 @@ describe Warden::Manager do
   it "should insert a Proxy object into the rack env" do
     env = env_with_params
     setup_rack(success_app).call(env)
-    env["warden"].should be_an_instance_of(Warden::Proxy)
+    expect(env["warden"]).to be_an_instance_of(Warden::Proxy)
   end
 
   describe "thrown auth" do
@@ -30,22 +30,32 @@ describe Warden::Manager do
     describe "Failure" do
       it "should respond with a 401 response if the strategy fails authentication" do
          env = env_with_params("/", :foo => "bar")
-         app = lambda do |env|
-           env['warden'].authenticate(:failz)
+         app = lambda do |_env|
+           _env['warden'].authenticate(:failz)
            throw(:warden, :action => :unauthenticated)
          end
-         result = setup_rack(app, :failure_app => @fail_app).call(env)
-         result.first.should == 401
+         result = setup_rack(app, :failure_app => @fail_app).call(env) # TODO: What is @fail_app?
+         expect(result.first).to eq(401)
       end
 
       it "should use the failure message given to the failure method" do
         env = env_with_params("/", {})
-        app = lambda do |env|
-          env['warden'].authenticate(:failz)
+        app = lambda do |_env|
+          _env['warden'].authenticate(:failz)
           throw(:warden)
         end
-        result = setup_rack(app, :failure_app => @fail_app).call(env)
-        result.last.should == ["You Fail!"]
+        result = setup_rack(app, :failure_app => @fail_app).call(env) # TODO: What is @fail_app?
+        expect(result.last).to eq(["You Fail!"])
+      end
+
+      it "should set the message from the winning strategy in warden.options hash" do
+        env = env_with_params("/", {})
+        app = lambda do |_env|
+          _env['warden'].authenticate(:failz)
+          throw(:warden)
+        end
+        setup_rack(app, :failure_app => @fail_app).call(env) # TODO: What is @fail_app?
+        expect(env["warden.options"][:message]).to eq("The Fails Strategy Has Failed You")
       end
 
       it "should render the failure app when there's a failure" do
@@ -56,29 +66,29 @@ describe Warden::Manager do
           [401, {"Content-Type" => "text/plain"}, ["Failure App"]]
         end
         result = setup_rack(app, :failure_app => fail_app).call(env_with_params)
-        result.last.should == ["Failure App"]
+        expect(result.last).to eq(["Failure App"])
       end
 
       it "should call failure app if warden is thrown even after successful authentication" do
         env = env_with_params("/", {})
-        app = lambda do |env|
-          env['warden'].authenticate(:pass)
+        app = lambda do |_env|
+          _env['warden'].authenticate(:pass)
           throw(:warden)
         end
         result = setup_rack(app, :failure_app => @fail_app).call(env)
-        result.first.should == 401
-        result.last.should == ["You Fail!"]
+        expect(result.first).to eq(401)
+        expect(result.last).to eq(["You Fail!"])
       end
 
       it "should set the attempted url in warden.options hash" do
         env = env_with_params("/access/path", {})
-        app = lambda do |env|
-          env['warden'].authenticate(:pass)
+        app = lambda do |_env|
+          _env['warden'].authenticate(:pass)
           throw(:warden)
         end
-        result = setup_rack(app, :failure_app => @fail_app).call(env)
-        result.first.should == 401
-        env["warden.options"][:attempted_path].should == "/access/path"
+        result = setup_rack(app, :failure_app => @fail_app).call(env) # TODO: What is @fail_app?
+        expect(result.first).to eq(401)
+        expect(env["warden.options"][:attempted_path]).to eq("/access/path")
       end
 
       it "should catch a resubmitted request" do
@@ -122,21 +132,21 @@ describe Warden::Manager do
         end
 
         result = builder.to_app.call(env)
-        result[0].should == 401
-        result[2].body.should == ["Bad"]
-        $throw_count.should == 2
+        expect(result[0]).to eq(401)
+        expect(result[2].body).to eq(["Bad"])
+        expect($throw_count).to eq(2)
       end
 
       it "should use the default scopes action when a bare throw is used" do
          env = env_with_params("/", :foo => "bar")
          action = nil
 
-         failure = lambda do |env|
-           action = env['PATH_INFO'] 
+         failure = lambda do |_env|
+           action = _env['PATH_INFO']
            [401, {}, ['fail']]
          end
 
-         app = lambda do |env|
+         app = lambda do |_env|
            throw(:warden)
          end
          result = setup_rack(app,
@@ -144,8 +154,8 @@ describe Warden::Manager do
                              :configurator => lambda{ |c| c.scope_defaults(:default, :action => 'my_action', :strategies => [:password]) }
                             ).call(env)
 
-         action.should == "/my_action"
-         result.first.should == 401
+         expect(action).to eq("/my_action")
+         expect(result.first).to eq(401)
       end
     end # failure
   end
@@ -169,9 +179,9 @@ describe Warden::Manager do
           end
         end
         result = @app.call(env_with_params)
-        result[0].should == 302
-        result[1]["Location"].should == "/foo/bar?foo=bar"
-        result[2].should == ["custom redirection message"]
+        expect(result[0]).to be(302)
+        expect(result[1]["Location"]).to eq("/foo/bar?foo=bar")
+        expect(result[2]).to eq(["custom redirection message"])
       end
 
       it "should redirect with a default message" do
@@ -181,9 +191,9 @@ describe Warden::Manager do
           end
         end
         result = @app.call(env_with_params)
-        result[0].should == 302
-        result[1]['Location'].should == "/foo/bar?foo=bar"
-        result[2].should == ["You are being redirected to /foo/bar?foo=bar"]
+        expect(result[0]).to eq(302)
+        expect(result[1]['Location']).to eq("/foo/bar?foo=bar")
+        expect(result[2]).to eq(["You are being redirected to /foo/bar?foo=bar"])
       end
 
       it "should redirect with a permanent redirect" do
@@ -193,7 +203,7 @@ describe Warden::Manager do
           end
         end
         result = @app.call(env_with_params)
-        result[0].should == 301
+        expect(result[0]).to eq(301)
       end
 
       it "should redirect with a content type" do
@@ -203,9 +213,9 @@ describe Warden::Manager do
           end
         end
         result = @app.call(env_with_params)
-        result[0].should == 302
-        result[1]["Location"].should == "/foo/bar?foo=bar"
-        result[1]["Content-Type"].should == "text/xml"
+        expect(result[0]).to eq(302)
+        expect(result[1]["Location"]).to eq("/foo/bar?foo=bar")
+        expect(result[1]["Content-Type"]).to eq("text/xml")
       end
 
       it "should redirect with a default content type" do
@@ -215,9 +225,9 @@ describe Warden::Manager do
           end
         end
         result = @app.call(env_with_params)
-        result[0].should == 302
-        result[1]["Location"].should == "/foo/bar?foo=bar"
-        result[1]["Content-Type"].should == "text/plain"
+        expect(result[0]).to eq(302)
+        expect(result[1]["Location"]).to eq("/foo/bar?foo=bar")
+        expect(result[1]["Content-Type"]).to eq("text/plain")
       end
     end
 
@@ -230,9 +240,9 @@ describe Warden::Manager do
         end
         env = env_with_params
         result = @app.call(env)
-        result[0].should == 401
-        result[2].should == ["You Fail!"]
-        env['PATH_INFO'].should == "/unauthenticated"
+        expect(result[0]).to eq(401)
+        expect(result[2]).to eq(["You Fail!"])
+        expect(env['PATH_INFO']).to eq("/unauthenticated")
       end
 
       it "should allow you to customize the response" do
@@ -242,8 +252,8 @@ describe Warden::Manager do
         end
         env = env_with_params
         result = setup_rack(app).call(env)
-        result[0].should == 401
-        result[2].should == ["Fail From The App"]
+        expect(result[0]).to eq(401)
+        expect(result[2]).to eq(["Fail From The App"])
       end
 
       it "should allow you to customize the response without the explicit call to custom_failure! if not intercepting 401" do
@@ -252,8 +262,8 @@ describe Warden::Manager do
         end
         env = env_with_params
         result = setup_rack(app, :intercept_401 => false).call(env)
-        result[0].should == 401
-        result[2].should == ["Fail From The App"]
+        expect(result[0]).to eq(401)
+        expect(result[2]).to eq(["Fail From The App"])
       end
 
       it "should render the failure application for a 401 if no custom_failure flag is set" do
@@ -261,8 +271,8 @@ describe Warden::Manager do
           [401,{'Content-Type' => 'text/plain'},["Fail From The App"]]
         end
         result = setup_rack(app).call(env_with_params)
-        result[0].should == 401
-        result[2].should == ["You Fail!"]
+        expect(result[0]).to eq(401)
+        expect(result[2]).to eq(["You Fail!"])
       end
 
     end # failing
@@ -275,9 +285,23 @@ describe Warden::Manager do
           end
         end
         result = @app.call(env_with_params)
-        result[0].should == 523
-        result[1]["Custom-Header"].should == "foo"
-        result[2].should == ["Custom Stuff"]
+        expect(result[0]).to be(523)
+        expect(result[1]["Custom-Header"]).to eq("foo")
+        expect(result[2]).to eq(["Custom Stuff"])
+      end
+    end
+
+    describe "app returns Rack::Response" do
+      it "should return it" do
+        RAS.add(:foobar) do
+          def authenticate!
+            custom!(Rack::Response.new(['body'], 201, {"Content-Type" => "text/plain"}))
+          end
+        end
+        result = @app.call(env_with_params)
+        expect(result.status).to eq(201)
+        expect(result.body).to eq(['body'])
+        expect(result.header['Content-Type']).to eq('text/plain')
       end
     end
 
@@ -290,8 +314,8 @@ describe Warden::Manager do
         end
         env = env_with_params
         result = @app.call(env)
-        result[0].should == 200
-        result[2].should == ["Foo Is A Winna"]
+        expect(result[0]).to eq(200)
+        expect(result[2]).to eq(["Foo Is A Winna"])
       end
     end
   end # integrated strategies
@@ -299,9 +323,9 @@ describe Warden::Manager do
   it "should allow me to set a different default scope for warden" do
     Rack::Builder.new do
       use Warden::Manager, :default_scope => :default do |manager|
-        manager.default_scope.should == :default
+        expect(manager.default_scope).to eq(:default)
         manager.default_scope = :other
-        manager.default_scope.should == :other
+        expect(manager.default_scope).to eq(:other)
       end
     end
   end
@@ -309,7 +333,7 @@ describe Warden::Manager do
   it "should allow me to access strategies through manager" do
     Rack::Builder.new do
       use Warden::Manager do |manager|
-        manager.strategies.should == Warden::Strategies
+        expect(manager.strategies).to eq(Warden::Strategies)
       end
     end
   end