loyal_warden 0.0.5

data/spec/helpers/strategies/invalid.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+Warden::Strategies.add(:invalid) do
+  def valid?
+    false
+  end
+
+  def authenticate!; end
+end

data/spec/helpers/strategies/pass.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+Warden::Strategies.add(:pass) do
+  def authenticate!
+    request.env['warden.spec.strategies'] ||= []
+    request.env['warden.spec.strategies'] << :pass
+    success!("Valid User") unless scope == :failz
+  end
+end

data/spec/helpers/strategies/pass_with_message.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+Warden::Strategies.add(:pass_with_message) do
+  def authenticate!
+    request.env['warden.spec.strategies'] ||= []
+    request.env['warden.spec.strategies'] << :pass_with_message
+    success!("Valid User", "The Success Strategy Has Accepted You") unless scope == :failz
+  end
+end

data/spec/helpers/strategies/password.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+Warden::Strategies.add(:password) do
+  def authenticate!
+    request.env['warden.spec.strategies'] ||= []
+    request.env['warden.spec.strategies'] << :password
+    if params["password"] || params["username"]
+      params["password"] == "sekrit" && params["username"] == "fred" ?
+        success!("Authenticated User") : fail!("Username or password is incorrect")
+    else
+      pass
+    end
+  end
+end

data/spec/helpers/strategies/single.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+Warden::Strategies.add(:single) do
+  def authenticate!
+    request.env['warden.spec.strategies'] ||= []
+    request.env['warden.spec.strategies'] << :single
+    success!("Valid User")
+  end
+
+  def store?
+    false
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+$TESTING=true
+
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__)))
+require 'warden'
+
+require 'rubygems'
+require 'rack'
+
+Dir[File.join(File.dirname(__FILE__), "helpers", "**/*.rb")].each do |f|
+  require f
+end
+
+RSpec.configure do |config|
+  config.include(Warden::Spec::Helpers)
+  config.include(Warden::Test::Helpers)
+
+  def load_strategies
+    Dir[File.join(File.dirname(__FILE__), "helpers", "strategies", "**/*.rb")].each do |f|
+      load f
+    end
+  end
+end

data/spec/warden/authenticated_data_store_spec.rb

@@ -0,0 +1,114 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe "authenticated data store" do
+
+  before(:each) do
+    @env = env_with_params
+    @env['rack.session'] = {
+      "warden.user.foo.key"     => "foo user",
+      "warden.user.default.key" => "default user",
+      :foo => "bar"
+    }
+  end
+
+  it "should store data for the default scope" 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)
+
+      # 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
+  end
+
+  it "should store data for the foo user" do
+    app = lambda do |e|
+      e['warden'].session(:foo)[:key] = "value"
+      valid_response
+    end
+    setup_rack(app).call(@env)
+    @env['rack.session']['warden.user.foo.session'].should == {:key => "value"}
+  end
+
+  it "should store the data seperately" 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"}
+  end
+
+  it "should clear the foo scoped data when foo logs out" do
+    app = lambda do |e|
+      e['warden'].session[:key] = "value"
+      e['warden'].session(:foo)[:key] = "another value"
+      e['warden'].logout(:foo)
+      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
+  end
+
+  it "should clear out the default data when :default logs out" do
+    app = lambda do |e|
+      e['warden'].session[:key] = "value"
+      e['warden'].session(:foo)[:key] = "another value"
+      e['warden'].logout(:default)
+      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"}
+  end
+
+  it "should clear out all data when a general logout is performed" do
+    app = lambda do |e|
+      e['warden'].session[:key] = "value"
+      e['warden'].session(:foo)[:key] = "another value"
+      e['warden'].logout
+      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
+  end
+
+  it "should logout multuiple personas at once" do
+    @env['rack.session']['warden.user.bar.key'] = "bar user"
+
+    app = lambda do |e|
+      e['warden'].session[:key] = "value"
+      e['warden'].session(:foo)[:key] = "another value"
+      e['warden'].session(:bar)[:key] = "yet another"
+      e['warden'].logout(:bar, :default)
+      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
+  end
+
+  it "should not store data for a user who is not logged in" do
+    @env['rack.session']
+    app = lambda do |e|
+      e['warden'].session(:not_here)[:key] = "value"
+      valid_response
+    end
+
+    lambda do
+      setup_rack(app).call(@env)
+    end.should raise_error(Warden::NotAuthenticated)
+  end
+end

data/spec/warden/config_spec.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Warden::Config do
+
+  before(:each) do
+    @config = Warden::Config.new
+  end
+
+  it "should behave like a hash" do
+    @config[:foo] = :bar
+    @config[:foo].should == :bar
+  end
+
+  it "should provide hash accessors" do
+    @config.failure_app = :foo
+    @config[:failure_app].should == :foo
+    @config[:failure_app] = :bar
+    @config.failure_app.should == :bar
+  end
+
+  it "should allow to read and set default strategies" do
+    @config.default_strategies :foo, :bar
+    @config.default_strategies.should == [:foo, :bar]
+  end
+
+  it "should allow to silence missing strategies" do
+    @config.silence_missing_strategies!
+    @config.silence_missing_strategies?.should be_true
+  end
+
+  it "should set the default_scope" do
+    @config.default_scope.should == :default
+    @config.default_scope = :foo
+    @config.default_scope.should == :foo
+  end
+
+  it "should merge given options on initialization" do
+    Warden::Config.new(:foo => :bar)[:foo].should == :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}
+  end
+end

data/spec/warden/errors_spec.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Warden::Proxy::Errors do
+
+  before(:each) do
+    @errors = Warden::Proxy::Errors.new
+  end
+
+  it "should report that it is empty on first creation" do
+    @errors.empty?.should == true
+  end
+
+  it "should continue to report that it is empty even after being checked" do
+    @errors.on(:foo)
+    @errors.empty?.should == true
+  end
+
+  it "should add an error" do
+    @errors.add(:login, "Login or password incorrect")
+    @errors[:login].should == ["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"]
+  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)
+    end
+  end
+
+  it "should return the error for a specific field / label" do
+    @errors.add(:login, "wrong")
+    @errors.on(:login).should == ["wrong"]
+  end
+
+  it "should return nil for a specific field if it's not been set" do
+    @errors.on(:not_there).should be_nil
+  end
+
+end

data/spec/warden/hooks_spec.rb

@@ -0,0 +1,373 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe "standard authentication hooks" do
+
+  before(:all) do
+    load_strategies
+  end
+
+  describe "after_set_user" do
+    before(:each) do
+      RAM = Warden::Manager unless defined?(RAM)
+      RAM._after_set_user.clear
+    end
+
+    after(:each) do
+      RAM._after_set_user.clear
+    end
+
+    it "should allow me to add an after_set_user hook" do
+      RAM.after_set_user do |user, auth, opts|
+        "boo"
+      end
+      RAM._after_set_user.should have(1).item
+    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
+    end
+
+    it "should run each after_set_user hook after the user is set" do
+      RAM.after_set_user{|u,a,o| a.env['warden.spec.hook.foo'] = "run foo"}
+      RAM.after_set_user{|u,a,o| a.env['warden.spec.hook.bar'] = "run bar"}
+      RAM.after_set_user{|u,a,o| a.logout}
+      app = lambda do |e|
+        e['warden'].set_user("foo")
+        valid_response
+      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"
+    end
+
+    it "should not run the event specified with except" do
+      RAM.after_set_user(:except => :set_user){|u,a,o| fail}
+      app = lambda do |e|
+        e['warden'].set_user("foo")
+        valid_response
+      end
+      env = env_with_params
+      setup_rack(app).call(env)
+    end
+
+    it "should only run the event specified with only" do
+      RAM.after_set_user(:only => :set_user){|u,a,o| fail}
+      app = lambda do |e|
+        e['warden'].authenticate(:pass)
+        valid_response
+      end
+      env = env_with_params
+      setup_rack(app).call(env)
+    end
+
+    it "should run filters in the given order" do
+      RAM.after_set_user{|u,a,o| a.env['warden.spec.order'] << 2}
+      RAM.after_set_user{|u,a,o| a.env['warden.spec.order'] << 3}
+      RAM.prepend_after_set_user{|u,a,o| a.env['warden.spec.order'] << 1}
+      app = lambda do |e|
+        e['warden.spec.order'] = []
+        e['warden'].set_user("foo")
+        valid_response
+      end
+      env = env_with_params
+      setup_rack(app).call(env)
+      env['warden.spec.order'].should == [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 }
+        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'
+      end
+
+      it "should not be invoked on default after_set_user scenario" do
+        RAM.after_authentication{|u,a,o| fail}
+        app = lambda do |e|
+          e['warden'].set_user("foo")
+          valid_response
+        end
+        env = env_with_params
+        setup_rack(app).call(env)
+      end
+
+      it "should run filters in the given order" do
+        RAM.after_authentication{|u,a,o| a.env['warden.spec.order'] << 2}
+        RAM.after_authentication{|u,a,o| a.env['warden.spec.order'] << 3}
+        RAM.prepend_after_authentication{|u,a,o| a.env['warden.spec.order'] << 1}
+        app = lambda do |e|
+          e['warden.spec.order'] = []
+          e['warden'].authenticate(:pass)
+          valid_response
+        end
+        env = env_with_params
+        setup_rack(app).call(env)
+        env['warden.spec.order'].should == [1,2,3]
+      end
+
+      it "should allow me to log out a user in an after_set_user block" do
+        RAM.after_set_user{|u,a,o| a.logout}
+
+        app = lambda do |e|
+          e['warden'].authenticate(:pass)
+          valid_response
+        end
+        env = env_with_params
+        setup_rack(app).call(env)
+        env['warden'].authenticated?.should be_false
+      end
+    end
+
+    context "after_fetch" 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 }
+        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'
+      end
+
+      it "should not be invoked on default after_set_user scenario" do
+        RAM.after_fetch{|u,a,o| fail}
+        app = lambda do |e|
+          e['warden'].set_user("foo")
+          valid_response
+        end
+        env = env_with_params
+        setup_rack(app).call(env)
+      end
+
+      it "should not be invoked if fetched user is nil" do
+        RAM.after_fetch{|u,a,o| fail}
+        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
+      end
+
+      it "should run filters in the given order" do
+        RAM.after_fetch{|u,a,o| a.env['warden.spec.order'] << 2}
+        RAM.after_fetch{|u,a,o| a.env['warden.spec.order'] << 3}
+        RAM.prepend_after_fetch{|u,a,o| a.env['warden.spec.order'] << 1}
+        app = lambda do |e|
+          e['warden.spec.order'] = []
+          e['rack.session']['warden.user.default.key'] = "Foo"
+          e['warden'].user
+          valid_response
+        end
+        env = env_with_params
+        setup_rack(app).call(env)
+        env['warden.spec.order'].should == [1,2,3]
+      end
+    end
+  end
+
+
+  describe "after_failed_fetch" do
+    before(:each) do
+      RAM = Warden::Manager unless defined?(RAM)
+      RAM._after_failed_fetch.clear
+    end
+
+    after(:each) do
+      RAM._after_failed_fetch.clear
+    end
+
+    it "should not be called when user is fetched" do
+      RAM.after_failed_fetch{|u,a,o| fail }
+      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"
+    end
+
+    it "should be called if fetched user is nil" do
+      calls = 0
+      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
+    end
+  end
+
+  describe "before_failure" do
+    before(:each) do
+      RAM = Warden::Manager unless defined?(RAM)
+      RAM._before_failure.clear
+    end
+
+    after(:each) do
+      RAM._before_failure.clear
+    end
+
+    it "should allow me to add a before_failure hook" do
+      RAM.before_failure{|env, opts| "foo"}
+      RAM._before_failure.should have(1).item
+    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
+    end
+
+    it "should run each before_failure hooks before failing" do
+      RAM.before_failure{|e,o| e['warden.spec.before_failure.foo'] = "foo"}
+      RAM.before_failure{|e,o| e['warden.spec.before_failure.bar'] = "bar"}
+      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"
+    end
+
+    it "should run filters in the given order" do
+      RAM.before_failure{|e,o| e['warden.spec.order'] << 2}
+      RAM.before_failure{|e,o| e['warden.spec.order'] << 3}
+      RAM.prepend_before_failure{|e,o| e['warden.spec.order'] << 1}
+      app = lambda do |e|
+        e['warden.spec.order'] = []
+        e['warden'].authenticate!(:failz)
+        valid_response
+      end
+      env = env_with_params
+      setup_rack(app).call(env)
+      env['warden.spec.order'].should == [1,2,3]
+    end
+  end
+
+  describe "before_logout" do
+    before(:each) do
+      RAM = Warden::Manager unless defined?(RAM)
+      RAM._before_logout.clear
+    end
+
+    after(:each) do
+      RAM._before_logout.clear
+    end
+
+    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
+    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
+    end
+
+    it "should run each before_logout hook before logout is run" do
+      RAM.before_logout{|u,a,o| a.env['warden.spec.hook.lorem'] = "run lorem"}
+      RAM.before_logout{|u,a,o| a.env['warden.spec.hook.ipsum'] = "run ipsum"}
+      app = lambda{|e| e['warden'].authenticate(:pass); valid_response}
+      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'
+    end
+
+    it "should run before_logout hook for a specified scope" do
+      RAM.before_logout(:scope => :scope1){|u,a,o| a.env["warden.spec.hook.a"] << :scope1 }
+      RAM.before_logout(:scope => [:scope2]){|u,a,o| a.env["warden.spec.hook.b"] << :scope2 }
+
+      app = lambda do |e|
+        e['warden'].authenticate(:pass, :scope => :scope1)
+        e['warden'].authenticate(:pass, :scope => :scope2)
+        valid_response
+      end
+      env = env_with_params
+      env["warden.spec.hook.a"] ||= []
+      env["warden.spec.hook.b"] ||= []
+      setup_rack(app).call(env)
+
+      env['warden'].logout(:scope1)
+      env['warden.spec.hook.a'].should == [:scope1]
+      env['warden.spec.hook.b'].should == []
+
+      env['warden'].logout(:scope2)
+      env['warden.spec.hook.a'].should == [:scope1]
+      env['warden.spec.hook.b'].should == [:scope2]
+    end
+
+    it "should run filters in the given order" do
+      RAM.before_logout{|u,a,o| a.env['warden.spec.order'] << 2}
+      RAM.before_logout{|u,a,o| a.env['warden.spec.order'] << 3}
+      RAM.prepend_before_logout{|u,a,o| a.env['warden.spec.order'] << 1}
+      app = lambda do |e|
+        e['warden.spec.order'] = []
+        e['warden'].authenticate(:pass)
+        e['warden'].logout
+        valid_response
+      end
+      env = env_with_params
+      setup_rack(app).call(env)
+      env['warden.spec.order'].should == [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)
+      RAM._on_request.clear
+    end
+
+    after(:each) do
+      RAM._on_request.clear
+      RAM._on_request.replace(@old_on_request)
+    end
+
+    it "should allow me to add an on_request hook" do
+      RAM.on_request{|proxy| "foo"}
+      RAM._on_request.should have(1).item
+    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
+    end
+
+    it "should run each on_request hooks when initializing" do
+      RAM.on_request{|proxy| proxy.env['warden.spec.on_request.foo'] = "foo"}
+      RAM.on_request{|proxy| proxy.env['warden.spec.on_request.bar'] = "bar"}
+      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"
+    end
+
+    it "should run filters in the given order" do
+      RAM.on_request{|proxy| proxy.env['warden.spec.order'] << 2}
+      RAM.on_request{|proxy| proxy.env['warden.spec.order'] << 3}
+      RAM.prepend_on_request{|proxy| proxy.env['warden.spec.order'] << 1}
+      app = lambda do |e|
+        valid_response
+      end
+      env = Rack::MockRequest.env_for("/", "warden.spec.order" => [])
+      setup_rack(app).call(env)
+      env['warden.spec.order'].should == [1,2,3]
+    end
+  end
+end