warden 1.2.4 → 1.2.9

data/spec/warden/authenticated_data_store_spec.rb

@@ -1,114 +0,0 @@
-# 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)
-      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)
-    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
-    app = lambda do |e|
-      e['warden'].session(:foo)[:key] = "value"
-      valid_response
-    end
-    setup_rack(app).call(@env)
-    expect(@env['rack.session']['warden.user.foo.session']).to eq(key: "value")
-  end
-
-  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)
-    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
-    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)
-    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
-    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)
-    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
-    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)
-    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 multiple persons 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)
-    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
-    @env['rack.session']
-    app = lambda do |e|
-      e['warden'].session(:not_here)[:key] = "value"
-      valid_response
-    end
-
-    expect {
-      setup_rack(app).call(@env)
-    }.to raise_error(Warden::NotAuthenticated)
-  end
-end

data/spec/warden/config_spec.rb

@@ -1,48 +0,0 @@
-# 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
-    expect(@config[:foo]).to eq(:bar)
-  end
-
-  it "should provide hash accessors" do
-    @config.failure_app = :foo
-    expect(@config[:failure_app]).to eq(:foo)
-    @config[:failure_app] = :bar
-    expect(@config.failure_app).to eq(:bar)
-  end
-
-  it "should allow to read and set default strategies" do
-    @config.default_strategies :foo, :bar
-    expect(@config.default_strategies).to eq([:foo, :bar])
-  end
-
-  it "should allow to silence missing strategies" do
-    @config.silence_missing_strategies!
-    expect(@config.silence_missing_strategies?).to eq(true)
-  end
-
-  it "should set the default_scope" do
-    expect(@config.default_scope).to eq(:default)
-    @config.default_scope = :foo
-    expect(@config.default_scope).to eq(:foo)
-  end
-
-  it "should merge given options on initialization" do
-    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
-    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

@@ -1,47 +0,0 @@
-# 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
-    expect(@errors).to be_empty
-  end
-
-  it "should continue to report that it is empty even after being checked" do
-    @errors.on(:foo)
-    expect(@errors).to be_empty
-  end
-
-  it "should add an error" do
-    @errors.add(:login, "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")
-    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|
-      expect(@errors.full_messages).to include(msg)
-    end
-  end
-
-  it "should return the error for a specific field / label" do
-    @errors.add(:login, "wrong")
-    expect(@errors.on(:login)).to eq(["wrong"])
-  end
-
-  it "should return nil for a specific field if it's not been set" do
-    expect(@errors.on(:not_there)).to be_nil
-  end
-
-end

data/spec/warden/hooks_spec.rb

@@ -1,373 +0,0 @@
-# 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
-      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"}
-      expect(RAM._after_set_user.length).to eq(2)
-    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)
-      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
-      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)
-      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| 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)
-        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
-        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)
-        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
-        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)
-        expect(env['warden']).not_to be_authenticated
-      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| 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"
-        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
-        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
-        expect(env['warden'].user).to 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)
-        expect(env['warden.spec.order']).to eq([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"
-      expect(env['warden'].user).to eq("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)
-      expect(env['warden'].user).to be_nil
-      expect(calls).to eq(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"}
-      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"}
-      expect(RAM._before_failure.length).to eq(2)
-    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)
-      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
-      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)
-      expect(env['warden.spec.order']).to eq([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"}
-      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"}
-      expect(RAM._before_logout.length).to eq(2)
-    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
-      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
-      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)
-      expect(env['warden.spec.hook.a']).to eq([:scope1])
-      expect(env['warden.spec.hook.b']).to eq([])
-
-      env['warden'].logout(: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
-      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)
-      expect(env['warden.spec.order']).to eq([1,2,3])
-    end
-  end
-
-  describe "on_request" do
-    before(:each) do
-      RAM = Warden::Manager unless defined?(RAM)
-      @old_on_request = RAM._on_request.dup
-      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"}
-      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"}
-      expect(RAM._on_request.length).to eq(2)
-    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)
-      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
-      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)
-      expect(env['warden.spec.order']).to eq([1,2,3])
-    end
-  end
-end