warden 1.2.3 → 1.2.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e2a3954f2157d76ec551f9c498a4e27e09a4a698
+  data.tar.gz: ea81f2cd654fbf09ebf9e2ef44d6836cd47bd920
+SHA512:
+  metadata.gz: 74db07fcb955f8109cf57bd7e32868bb198f8c7c94a748ca450bfc7e281cacff1c869af942c1952a0ade3fb209bcd134dc7cf3a916d4d0a36417cc5e9a4790b2
+  data.tar.gz: 6d38527fbf7cbdf032ecf16ce5661584afe1d4fb9dbf4cb4c0d60a32b385b53f7e781eb92d4c1624b16de5fe688183af6f9a258cae079a942ca67bc3e69ddd9b

data/Gemfile

@@ -6,6 +6,6 @@ gem 'rake'
 gem 'rack', '1.3'
 
 group :test do
-  gem 'rspec', '~>2'
+  gem 'rspec', '~>3'
   gem 'rack-test'
 end

data/History.rdoc

@@ -1,3 +1,6 @@
+== Version 1.2.5 / 2016-01-28
+* Expands on the test helpers available to make it easier for testing gems
+
 == Version 1.2.3 / 2013-07-14
 * Fix an issue with lazy loaded sessions
 

data/lib/warden/config.rb

@@ -1,9 +1,8 @@
 # encoding: utf-8
 
 module Warden
-  # This is a class which is yielded on use Warden::Manager. If you have a plugin
-  # and wants to add more configuration to warden, you just need to extend this
-  # class.
+  # This class is yielded inside Warden::Manager. If you have a plugin and want to
+  # add more configuration to warden, you just need to extend this class.
   class Config < Hash
     # Creates an accessor that simply sets and reads a key in the hash:
     #

data/lib/warden/hooks.rb

@@ -18,21 +18,21 @@ module Warden
     # A callback hook set to run every time after a user is set.
     # This callback is triggered the first time one of those three events happens
     # during a request: :authentication, :fetch (from session) and :set_user (when manually set).
-    # You can supply as many hooks as you like, and they will be run in order of decleration.
+    # You can supply as many hooks as you like, and they will be run in order of declaration.
     #
     # If you want to run the callbacks for a given scope and/or event, you can specify them as options.
     # See parameters and example below.
     #
     # Parameters:
     # <options> Some options which specify when the callback should be executed
-    #   scope  - Executes the callback only if it maches the scope(s) given
+    #   scope  - Executes the callback only if it matches the scope(s) given
     #   only   - Executes the callback only if it matches the event(s) given
     #   except - Executes the callback except if it matches the event(s) given
     # <block> A block where you can set arbitrary logic to run every time a user is set
     #   Block Parameters: |user, auth, opts|
     #     user - The user object that is being set
     #     auth - The raw authentication proxy object.
-    #     opts - any options passed into the set_user call includeing :scope
+    #     opts - any options passed into the set_user call including :scope
     #
     # Example:
     #   Warden::Manager.after_set_user do |user,auth,opts|
@@ -77,7 +77,7 @@ module Warden
     end
 
     # after_fetch is just a wrapper to after_set_user, which is only invoked
-    # when the user is fetched from sesion. The options and yielded arguments
+    # when the user is fetched from session. The options and yielded arguments
     # are the same as in after_set_user.
     #
     # :api: public
@@ -85,18 +85,18 @@ module Warden
       after_set_user(options.merge(:event => :fetch), method, &block)
     end
 
-    # A callback that runs just prior to the failur application being called.
+    # A callback that runs just prior to the failure application being called.
     # This callback occurs after PATH_INFO has been modified for the failure (default /unauthenticated)
     # In this callback you can mutate the environment as required by the failure application
     # If a Rails controller were used for the failure_app for example, you would need to set request[:params][:action] = :unauthenticated
     #
     # Parameters:
     # <options> Some options which specify when the callback should be executed
-    #   scope  - Executes the callback only if it maches the scope(s) given
+    #   scope  - Executes the callback only if it matches the scope(s) given
     # <block> A block to contain logic for the callback
     #   Block Parameters: |env, opts|
     #     env - The rack env hash
-    #     opts - any options passed into the authenticate call includeing :scope
+    #     opts - any options passed into the authenticate call including :scope
     #
     # Example:
     #   Warden::Manager.before_failure do |env, opts|
@@ -121,7 +121,7 @@ module Warden
     #
     # Parameters:
     # <options> Some options which specify when the callback should be executed
-    #   scope  - Executes the callback only if it maches the scope(s) given
+    #   scope  - Executes the callback only if it matches the scope(s) given
     # <block> A block to contain logic for the callback
     #   Block Parameters: |user, auth, scope|
     #     user - The authenticated user for the current scope
@@ -149,7 +149,7 @@ module Warden
     #
     # Parameters:
     # <options> Some options which specify when the callback should be executed
-    #   scope  - Executes the callback only if it maches the scope(s) given
+    #   scope  - Executes the callback only if it matches the scope(s) given
     # <block> A block to contain logic for the callback
     #   Block Parameters: |user, auth, scope|
     #     user - The authenticated user for the current scope

data/lib/warden/manager.rb

@@ -4,7 +4,7 @@ require 'warden/config'
 
 module Warden
   # The middleware for Rack Authentication
-  # The middlware requires that there is a session upstream
+  # The middleware requires that there is a session upstream
   # The middleware injects an authentication object into
   # the rack environment hash
   class Manager
@@ -19,7 +19,7 @@ module Warden
       default_strategies = options.delete(:default_strategies)
 
       @app, @config = app, Warden::Config.new(options)
-      @config.default_strategies *default_strategies if default_strategies
+      @config.default_strategies(*default_strategies) if default_strategies
       yield @config if block_given?
       self
     end
@@ -38,13 +38,11 @@ module Warden
       result ||= {}
       case result
       when Array
-        if result.first == 401 && intercept_401?(env)
-          process_unauthenticated(env)
-        else
-          result
-        end
+        handle_chain_result(result.first, result, env)
       when Hash
         process_unauthenticated(env, result)
+      when Rack::Response
+        handle_chain_result(result.status, result, env)
       end
     end
 
@@ -72,8 +70,8 @@ module Warden
         Warden::SessionSerializer.send :define_method, method_name, &block
       end
 
-      # Reconstitues the user from the session.
-      # Use the results of user_session_key to reconstitue the user from the session on requests after the initial login
+      # Reconstitutes the user from the session.
+      # Use the results of user_session_key to reconstitute the user from the session on requests after the initial login
       # You can supply different methods of de-serialization for different scopes by passing a scope symbol
       #
       # Example:
@@ -84,12 +82,25 @@ module Warden
       # :api: public
       def serialize_from_session(scope = nil, &block)
         method_name = scope.nil? ? :deserialize : "#{scope}_deserialize"
+
+        if Warden::SessionSerializer.method_defined? method_name
+          Warden::SessionSerializer.send :remove_method, method_name
+        end
+
         Warden::SessionSerializer.send :define_method, method_name, &block
       end
     end
 
   private
 
+    def handle_chain_result(status, result, env)
+      if status == 401 && intercept_401?(env)
+        process_unauthenticated(env)
+      else
+        result
+      end
+    end
+
     def intercept_401?(env)
       config[:intercept_401] && !env['warden'].custom_failure?
     end
@@ -113,6 +124,7 @@ module Warden
       when :custom
         proxy.custom_response
       else
+        options[:message] ||= proxy.message
         call_failure_app(env, options)
       end
     end

data/lib/warden/mixins/common.rb

@@ -3,7 +3,7 @@ module Warden
   module Mixins
     module Common
 
-      # Convinience method to access the session
+      # Convenience method to access the session
       # :api: public
       def session
         env['rack.session']

data/lib/warden/proxy.rb

@@ -69,7 +69,7 @@ module Warden
     #
     # :api: public
     def clear_strategies_cache!(*args)
-      scope, opts = _retrieve_scope_and_opts(args)
+      scope, _opts = _retrieve_scope_and_opts(args)
 
       @winning_strategies.delete(scope)
       @strategies[scope].each do |k, v|
@@ -87,7 +87,7 @@ module Warden
       @locked = true
     end
 
-    # Run the authentiation strategies for the given strategies.
+    # Run the authentication strategies for the given strategies.
     # If there is already a user logged in for a given scope, the strategies are not run
     # This does not halt the flow of control and is a passive attempt to authenticate only
     # When scope is not specified, the default_scope is assumed.
@@ -101,7 +101,7 @@ module Warden
     #
     # :api: public
     def authenticate(*args)
-      user, opts = _perform_authentication(*args)
+      user, _opts = _perform_authentication(*args)
       user
     end
 
@@ -181,7 +181,7 @@ module Warden
       @users[scope]
     end
 
-    # Provides acccess to the user object in a given scope for a request.
+    # Provides access to the user object in a given scope for a request.
     # Will be nil if not logged in. Please notice that this method does not
     # perform strategies.
     #
@@ -280,7 +280,7 @@ module Warden
       winning_strategy && winning_strategy.message
     end
 
-    # Provides a way to return a 401 without warden defering to the failure app
+    # Provides a way to return a 401 without warden deferring to the failure app
     # The result is a direct passthrough of your own response
     # :api: public
     def custom_failure!
@@ -290,7 +290,11 @@ module Warden
     # Check to see if the custom failure flag has been set
     # :api: public
     def custom_failure?
-      !!@custom_failure
+      if instance_variable_defined?(:@custom_failure)
+        !!@custom_failure
+      else
+        false
+      end
     end
 
     # Check to see if this is an asset request
@@ -318,7 +322,7 @@ module Warden
       return user, opts if user = user(opts.merge(:scope => scope))
       _run_strategies_for(scope, args)
 
-      if winning_strategy && winning_strategy.user
+      if winning_strategy && winning_strategy.successful?
         opts[:store] = opts.fetch(:store, winning_strategy.store?)
         set_user(winning_strategy.user, opts.merge!(:event => :authentication))
       end
@@ -356,7 +360,7 @@ module Warden
       end
     end
 
-    # Fetchs strategies and keep them in a hash cache.
+    # Fetches strategies and keep them in a hash cache.
     def _fetch_strategy(name, scope)
       @strategies[scope][name] ||= if klass = Warden::Strategies[name]
         klass.new(@env, scope)

data/lib/warden/strategies/base.rb

@@ -9,11 +9,11 @@ module Warden
     # You _may_ provide a @valid?@ method.
     # The valid method should return true or false depending on if the strategy is a valid one for the request.
     #
-    # The parameters for Warden::Strategies.add method is:
+    # The parameters for Warden::Strategies.add method are:
     #   <label: Symbol> The label is the name given to a strategy.  Use the label to refer to the strategy when authenticating
-    #   <strategy: Class|nil> The optional stragtegy argument if set _must_ be a class that inherits from Warden::Strategies::Base and _must_
+    #   <strategy: Class|nil> The optional strategy argument if set _must_ be a class that inherits from Warden::Strategies::Base and _must_
     #                         implement an @authenticate!@ method
-    #   <block> The block acts as a convinient way to declare your strategy.  Inside is the class definition of a strategy.
+    #   <block> The block acts as a convenient way to declare your strategy.  Inside is the class definition of a strategy.
     #
     # Examples:
     #
@@ -108,8 +108,13 @@ module Warden
       # :api: public
       def pass; end
 
+      # Returns true only if the result is a success and a user was assigned.
+      def successful?
+        @result == :success && !user.nil?
+      end
+
       # Whenever you want to provide a user object as "authenticated" use the +success!+ method.
-      # This will halt the strategy, and set the user in the approprieate scope.
+      # This will halt the strategy, and set the user in the appropriate scope.
       # It is the "login" method
       #
       # Parameters:
@@ -133,7 +138,7 @@ module Warden
         @result = :failure
       end
 
-      # Casuses the strategy to fail, but not halt.  The strategies will cascade after this failure and warden will check the next strategy.  The last strategy to fail will have it's message displayed.
+      # Causes the strategy to fail, but not halt.  The strategies will cascade after this failure and warden will check the next strategy.  The last strategy to fail will have it's message displayed.
       # :api: public
       def fail(message = "Failed to Login")
         @message = message
@@ -144,8 +149,8 @@ module Warden
       #
       # Parameters:
       #  url <String> - The string representing the URL to be redirected to
-      #  pararms <Hash> - Any parameters to encode into the URL
-      #  opts <Hash> - Any options to recirect with.
+      #  params <Hash> - Any parameters to encode into the URL
+      #  opts <Hash> - Any options to redirect with.
       #    available options: permanent => (true || false)
       #
       # :api: public

data/lib/warden/test/helpers.rb

@@ -1,5 +1,7 @@
 # encoding: utf-8
 
+require 'rack'
+
 module Warden
   module Test
     # A collection of test helpers for testing full stack rack applications using Warden
@@ -10,7 +12,7 @@ module Warden
         ::Warden.test_mode!
       end
 
-      # A helper method that will peform a login of a user in warden for the next request
+      # A helper method that will perform a login of a user in warden for the next request.
       # Provide it the same options as you would to Warden::Proxy#set_user
       # @see Warden::Proxy#set_user
       # @api public
@@ -31,6 +33,59 @@ module Warden
           proxy.logout(*scopes)
         end
       end
+
+      # A helper method that provides the warden object by mocking the env variable.
+      # @api public
+      def warden
+        @warden ||= begin
+          env['warden']
+        end
+      end
+
+      private
+
+      def env
+        @env ||= begin
+          request = Rack::MockRequest.env_for(
+            "/?#{Rack::Utils.build_query({})}",
+            { 'HTTP_VERSION' => '1.1', 'REQUEST_METHOD' => 'GET' }
+          )
+          app.call(request)
+
+          request
+        end
+      end
+
+      def app
+        @app ||= begin
+          opts = {
+            failure_app: lambda {
+              [401, { 'Content-Type' => 'text/plain' }, ['You Fail!']]
+            },
+            default_strategies: :password,
+            default_serializers: :session
+          }
+          Rack::Builder.new do
+            use Warden::Test::Helpers::Session
+            use Warden::Manager, opts, &proc {}
+            run lambda { |e|
+              [200, { 'Content-Type' => 'text/plain' }, ['You Win']]
+            }
+          end
+        end
+      end
+
+      class Session
+        attr_accessor :app
+        def initialize(app,configs = {})
+          @app = app
+        end
+
+        def call(e)
+          e['rack.session'] ||= {}
+          @app.call(e)
+        end
+      end # session
     end
   end
 end

data/lib/warden/test/warden_helpers.rb

@@ -32,7 +32,7 @@ module Warden
         _on_next_request.clear
       end
 
-      # A containter for the on_next_request items.
+      # A container for the on_next_request items.
       # @api private
       def _on_next_request
         @_on_next_request ||= []

data/lib/warden/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module Warden
-  VERSION = "1.2.3".freeze
+  VERSION = "1.2.5".freeze
 end

data/spec/helpers/strategies/fail_with_user.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+Warden::Strategies.add(:fail_with_user) do
+  def authenticate!
+    request.env['warden.spec.strategies'] ||= []
+    request.env['warden.spec.strategies'] << :fail_with_user
+    self.user = 'Valid User'
+    fail!
+  end
+end
+

data/spec/helpers/strategies/invalid.rb

@@ -5,4 +5,4 @@ Warden::Strategies.add(:invalid) do
   end
 
   def authenticate!; end
-end
+end

data/spec/warden/authenticated_data_store_spec.rb

@@ -16,16 +16,16 @@ describe "authenticated data store" do
     app = lambda do |e|
       e['warden'].authenticate(:pass)
       e['warden'].authenticate(:pass, :scope => :foo)
-      e['warden'].should be_authenticated
-      e['warden'].should be_authenticated(:foo)
+      expect(e['warden']).to be_authenticated
+      expect(e['warden']).to be_authenticated(:foo)
 
       # Store the data for :default
       e['warden'].session[:key] = "value"
       valid_response
     end
     setup_rack(app).call(@env)
-    @env['rack.session']['warden.user.default.session'].should == {:key => "value"}
-    @env['rack.session']['warden.user.foo.session'].should be_nil
+    expect(@env['rack.session']['warden.user.default.session']).to eq(key: "value")
+    expect(@env['rack.session']['warden.user.foo.session']).to be_nil
   end
 
   it "should store data for the foo user" do
@@ -34,18 +34,18 @@ describe "authenticated data store" do
       valid_response
     end
     setup_rack(app).call(@env)
-    @env['rack.session']['warden.user.foo.session'].should == {:key => "value"}
+    expect(@env['rack.session']['warden.user.foo.session']).to eq(key: "value")
   end
 
-  it "should store the data seperately" do
+  it "should store the data separately" do
     app = lambda do |e|
       e['warden'].session[:key] = "value"
       e['warden'].session(:foo)[:key] = "another value"
       valid_response
     end
     setup_rack(app).call(@env)
-    @env['rack.session']['warden.user.default.session'].should == {:key => "value"}
-    @env['rack.session']['warden.user.foo.session'    ].should == {:key => "another value"}
+    expect(@env['rack.session']['warden.user.default.session']).to eq(key: "value")
+    expect(@env['rack.session']['warden.user.foo.session'    ]).to eq(key: "another value")
   end
 
   it "should clear the foo scoped data when foo logs out" do
@@ -56,8 +56,8 @@ describe "authenticated data store" do
       valid_response
     end
     setup_rack(app).call(@env)
-    @env['rack.session']['warden.user.default.session'].should == {:key => "value"}
-    @env['rack.session']['warden.user.foo.session'    ].should be_nil
+    expect(@env['rack.session']['warden.user.default.session']).to eq(key: "value")
+    expect(@env['rack.session']['warden.user.foo.session'    ]).to be_nil
   end
 
   it "should clear out the default data when :default logs out" do
@@ -68,8 +68,8 @@ describe "authenticated data store" do
       valid_response
     end
     setup_rack(app).call(@env)
-    @env['rack.session']['warden.user.default.session'].should be_nil
-    @env['rack.session']['warden.user.foo.session'    ].should == {:key => "another value"}
+    expect(@env['rack.session']['warden.user.default.session']).to be_nil
+    expect(@env['rack.session']['warden.user.foo.session'    ]).to eq(key: "another value")
   end
 
   it "should clear out all data when a general logout is performed" do
@@ -80,11 +80,11 @@ describe "authenticated data store" do
       valid_response
     end
     setup_rack(app).call(@env)
-    @env['rack.session']['warden.user.default.session'].should be_nil
-    @env['rack.session']['warden.user.foo.session'    ].should be_nil
+    expect(@env['rack.session']['warden.user.default.session']).to be_nil
+    expect(@env['rack.session']['warden.user.foo.session'    ]).to be_nil
   end
 
-  it "should logout multuiple personas at once" do
+  it "should logout multiple persons at once" do
     @env['rack.session']['warden.user.bar.key'] = "bar user"
 
     app = lambda do |e|
@@ -95,9 +95,9 @@ describe "authenticated data store" do
       valid_response
     end
     setup_rack(app).call(@env)
-    @env['rack.session']['warden.user.default.session'].should be_nil
-    @env['rack.session']['warden.user.foo.session'    ].should == {:key => "another value"}
-    @env['rack.session']['warden.user.bar.session'    ].should be_nil
+    expect(@env['rack.session']['warden.user.default.session']).to be_nil
+    expect(@env['rack.session']['warden.user.foo.session'    ]).to eq(key: "another value")
+    expect(@env['rack.session']['warden.user.bar.session'    ]).to be_nil
   end
 
   it "should not store data for a user who is not logged in" do
@@ -107,8 +107,8 @@ describe "authenticated data store" do
       valid_response
     end
 
-    lambda do
+    expect {
       setup_rack(app).call(@env)
-    end.should raise_error(Warden::NotAuthenticated)
+    }.to raise_error(Warden::NotAuthenticated)
   end
 end

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