warden 1.2.5 → 1.2.8

data/spec/warden/scoped_session_serializer.rb

@@ -1,123 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe Warden::Manager do
-  before(:each) do
-    @env = env_with_params
-    @env['rack.session'] ||= {}
-    Warden::Manager.serialize_from_session { |k| k }
-    Warden::Manager.serialize_into_session { |u| u }
-    begin
-      Warden::SessionSerializer.send :remove_method, :admin_serialize
-    rescue
-    end
-    begin
-      Warden::SessionSerializer.send :remove_method, :admin_deserialize
-    rescue
-    end
-  end
-  after(:each) do
-    Warden::Manager.serialize_from_session { |k| k }
-    Warden::Manager.serialize_into_session { |u| u }
-    begin
-      Warden::SessionSerializer.send :remove_method, :admin_deserialize
-      Warden::SessionSerializer.send :remove_method, :admin_serialize
-    rescue
-    end
-  end
-
-  def serializer_respond_to?(name)
-    Warden::SessionSerializer.new(@env).respond_to? name
-  end
-
-  it "should respond to :serialize" do
-    serializer_respond_to?(:serialize).should be_true
-  end
-
-  it "should respond to :deserialize" do
-    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 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 be_true
-  end
-
-  def initialize_with_scope(scope, &block)
-    Rack::Builder.new do
-      Warden::Manager.serialize_into_session(scope, &block)
-    end
-  end
-
-  it "should execute serialize if no {scope}_serialize is present" do
-    serialized_object = nil
-    initialize_with_scope(nil) do |user|
-      serialized_object = user
-      user
-    end
-    serializer = Warden::SessionSerializer.new(@env)
-    serializer.store("user", :admin)
-    serialized_object.should eq("user")
-  end
-
-  it "should not have a {scope}_serialize by default" do
-    serializer_respond_to?(:admin_serialize).should be_false
-  end
-
-  it "should execute {scope}_serialize when calling store with a scope" do
-    serialized_object = nil
-    initialize_with_scope(:admin) do |user|
-      serialized_object = user
-      user
-    end
-
-    serializer = Warden::SessionSerializer.new(@env)
-    serializer.store("user", :admin)
-    serialized_object.should eq("user")
-  end
-
-
-  it "should execute {scope}_deserialize when calling store with a scope" do
-    serialized_object = nil
-
-    Rack::Builder.new do
-      Warden::Manager.serialize_from_session(:admin) do |key|
-        serialized_object = key
-        key
-      end
-    end
-
-    serializer = Warden::SessionSerializer.new(@env)
-    @env['rack.session'][serializer.key_for(:admin)] = "test"
-    serializer.fetch(:admin)
-
-    serialized_object.should eq("test")
-  end
-
-  it "should execute deserialize if {scope}_deserialize is not present" do
-    serialized_object = nil
-
-    Rack::Builder.new do
-      Warden::Manager.serialize_from_session do |key|
-        serialized_object = key
-        key
-      end
-    end
-
-    serializer = Warden::SessionSerializer.new(@env)
-    @env['rack.session'][serializer.key_for(:admin)] = "test"
-    serializer.fetch(:admin)
-
-    serialized_object.should eq("test")
-  end
-
-end

data/spec/warden/session_serializer_spec.rb

@@ -1,53 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe Warden::SessionSerializer do
-  before(:each) do
-    @env = env_with_params
-    @env['rack.session'] ||= {}
-    @session = Warden::SessionSerializer.new(@env)
-  end
-
-  it "should store data for the default scope" do
-    @session.store("user", :default)
-    expect(@env['rack.session']).to eq({ "warden.user.default.key"=>"user" })
-  end
-
-  it "should check if a data is stored or not" do
-    expect(@session).not_to be_stored(:default)
-    @session.store("user", :default)
-    expect(@session).to be_stored(:default)
-  end
-
-  it "should load an user from store" do
-    expect(@session.fetch(:default)).to be_nil
-    @session.store("user", :default)
-    expect(@session.fetch(:default)).to eq("user")
-  end
-
-  it "should store data based on the scope" do
-    @session.store("user", :default)
-    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)
-    expect(@session.fetch(:default)).to eq("user")
-    @session.delete(:default)
-    expect(@session.fetch(:default)).to be_nil
-  end
-
-  it "should delete information from store if user cannot be retrieved" do
-    @session.store("user", :default)
-    expect(@env['rack.session']).to have_key("warden.user.default.key")
-    allow(@session).to receive(:deserialize).and_return(nil)
-    @session.fetch(:default)
-    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
-    expect(@session.fetch(:default)).to be_nil
-  end
-end

data/spec/warden/strategies/base_spec.rb

@@ -1,313 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe Warden::Strategies::Base do
-
-  before(:each) do
-    RAS = Warden::Strategies unless defined?(RAS)
-    Warden::Strategies.clear!
-  end
-
-  describe "headers" do
-    it "should have headers" do
-      Warden::Strategies.add(:foo) do
-        def authenticate!
-          headers("foo" => "bar")
-        end
-      end
-      strategy = Warden::Strategies[:foo].new(env_with_params)
-      strategy._run!
-      expect(strategy.headers["foo"]).to eq("bar")
-    end
-
-    it "should allow us to clear the headers" do
-      Warden::Strategies.add(:foo) do
-        def authenticate!
-          headers("foo" => "bar")
-        end
-      end
-      strategy = Warden::Strategies[:foo].new(env_with_params)
-      strategy._run!
-      expect(strategy.headers["foo"]).to eq("bar")
-      strategy.headers.clear
-      expect(strategy.headers).to be_empty
-    end
-  end
-
-  it "should have a user object" do
-    RAS.add(:foobar) do
-      def authenticate!
-        success!("foo")
-      end
-    end
-    strategy = RAS[:foobar].new(env_with_params)
-    strategy._run!
-    expect(strategy.user).to eq("foo")
-  end
-
-  it "should be performed after run" do
-    RAS.add(:foobar) do
-      def authenticate!; end
-    end
-    strategy = RAS[:foobar].new(env_with_params)
-    expect(strategy).not_to be_performed
-    strategy._run!
-    expect(strategy).to be_performed
-    strategy.clear!
-    expect(strategy).not_to be_performed
-  end
-
-  it "should set the scope" do
-    RAS.add(:foobar) do
-      def authenticate!
-        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)
-  end
-
-  it "should allow you to set a message" do
-    RAS.add(:foobar) do
-      def authenticate!
-        self.message = "foo message"
-      end
-    end
-    strategy = RAS[:foobar].new(env_with_params)
-    strategy._run!
-    expect(strategy.message).to eq("foo message")
-  end
-
-  it "should provide access to the errors" do
-    RAS.add(:foobar) do
-      def authenticate!
-        errors.add(:foo, "foo has an error")
-      end
-    end
-    env = env_with_params
-    env['warden'] = Warden::Proxy.new(env, Warden::Manager.new({}))
-    strategy = RAS[:foobar].new(env)
-    strategy._run!
-    expect(strategy.errors.on(:foo)).to eq(["foo has an error"])
-  end
-
-  describe "halting" do
-    it "should allow you to halt a strategy" do
-      RAS.add(:foobar) do
-        def authenticate!
-          halt!
-        end
-      end
-      str = RAS[:foobar].new(env_with_params)
-      str._run!
-      expect(str).to be_halted
-    end
-
-    it "should not be halted if halt was not called" do
-      RAS.add(:foobar) do
-        def authenticate!
-          "foo"
-        end
-      end
-      str = RAS[:foobar].new(env_with_params)
-      str._run!
-      expect(str).not_to be_halted
-    end
-
-  end
-
-  describe "pass" do
-    it "should allow you to pass" do
-      RAS.add(:foobar) do
-        def authenticate!
-          pass
-        end
-      end
-      str = RAS[:foobar].new(env_with_params)
-      str._run!
-      expect(str).not_to be_halted
-      expect(str.user).to be_nil
-    end
-  end
-
-  describe "redirect" do
-    it "should allow you to set a redirection" do
-      RAS.add(:foobar) do
-        def authenticate!
-          redirect!("/foo/bar")
-        end
-      end
-      str = RAS[:foobar].new(env_with_params)
-      str._run!
-      expect(str.user).to be_nil
-    end
-
-    it "should mark the strategy as halted when redirecting" do
-      RAS.add(:foobar) do
-        def authenticate!
-          redirect!("/foo/bar")
-        end
-      end
-      str = RAS[:foobar].new(env_with_params)
-      str._run!
-      expect(str).to be_halted
-    end
-
-    it "should escape redirected url parameters" do
-      RAS.add(:foobar) do
-        def authenticate!
-          redirect!("/foo/bar", :foo => "bar")
-        end
-      end
-      str = RAS[:foobar].new(env_with_params)
-      str._run!
-      expect(str.headers["Location"]).to eq("/foo/bar?foo=bar")
-    end
-
-    it "should allow you to set a message" do
-      RAS.add(:foobar) do
-        def authenticate!
-          redirect!("/foo/bar", {:foo => "bar"}, :message => "You are being redirected foo")
-        end
-      end
-      str = RAS[:foobar].new(env_with_params)
-      str._run!
-      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
-      RAS.add(:foobar) do
-        def authenticate!
-          redirect!("/foo/bar", {:foo => "bar"}, :message => "foo")
-        end
-      end
-      str = RAS[:foobar].new(env_with_params)
-      str._run!
-      expect(str.result).to be(:redirect)
-    end
-  end
-
-  describe "failure" do
-
-    before(:each) do
-      RAS.add(:hard_fail) do
-        def authenticate!
-          fail!("You are not cool enough")
-        end
-      end
-
-      RAS.add(:soft_fail) do
-        def authenticate!
-          fail("You are too soft")
-        end
-      end
-      @hard = RAS[:hard_fail].new(env_with_params)
-      @soft = RAS[:soft_fail].new(env_with_params)
-    end
-
-    it "should allow you to fail hard" do
-      @hard._run!
-      expect(@hard.user).to be_nil
-    end
-
-    it "should halt the strategies when failing hard" do
-      @hard._run!
-      expect(@hard).to be_halted
-    end
-
-    it "should allow you to set a message when failing hard" do
-      @hard._run!
-      expect(@hard.message).to eq("You are not cool enough")
-    end
-
-    it "should set the action as :failure when failing hard" do
-      @hard._run!
-      expect(@hard.result).to be(:failure)
-    end
-
-    it "should allow you to fail soft" do
-      @soft._run!
-      expect(@soft.user).to be_nil
-    end
-
-    it "should not halt the strategies when failing soft" do
-      @soft._run!
-      expect(@soft).not_to be_halted
-    end
-
-    it "should allow you to set a message when failing soft" do
-      @soft._run!
-      expect(@soft.message).to eq("You are too soft")
-    end
-
-    it "should set the action as :failure when failing soft" do
-      @soft._run!
-      expect(@soft.result).to be(:failure)
-    end
-  end
-
-  describe "success" do
-    before(:each) do
-      RAS.add(:foobar) do
-        def authenticate!
-          success!("Foo User", "Welcome to the club!")
-        end
-      end
-      @str = RAS[:foobar].new(env_with_params)
-    end
-
-    it "should allow you to succeed" do
-      @str._run!
-    end
-
-    it "should be authenticated after success" do
-      @str._run!
-      expect(@str.user).not_to be_nil
-    end
-
-    it "should allow you to set a message when succeeding" do
-      @str._run!
-      expect(@str.message).to eq("Welcome to the club!")
-    end
-
-    it "should store the user" do
-      @str._run!
-      expect(@str.user).to eq("Foo User")
-    end
-
-    it "should set the action as :success" do
-      @str._run!
-      expect(@str.result).to be(:success)
-    end
-  end
-
-  describe "custom response" do
-    before(:each) do
-      RAS.add(:foobar) do
-        def authenticate!
-          custom!([521, {"foo" => "bar"}, ["BAD"]])
-        end
-      end
-      @str = RAS[:foobar].new(env_with_params)
-      @str._run!
-    end
-
-    it "should allow me to set a custom rack response" do
-      expect(@str.user).to be_nil
-    end
-
-    it "should halt the strategy" do
-      expect(@str).to be_halted
-    end
-
-    it "should provide access to the custom rack response" do
-      expect(@str.custom_response).to eq([521, {"foo" => "bar"}, ["BAD"]])
-    end
-
-    it "should set the action as :custom" do
-      @str._run!
-      expect(@str.result).to eq(:custom)
-    end
-  end
-
-end

data/spec/warden/strategies_spec.rb

@@ -1,94 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe Warden::Strategies do
-  it "should let me add a strategy via a block" do
-    Warden::Strategies.add(:strategy1) do
-      def authenticate!
-        success("foo")
-      end
-    end
-    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
-    expect {
-      Warden::Strategies.add(:strategy2) do
-      end
-    }.to raise_error(NoMethodError)
-  end
-
-  it "should raise an error if I add a strategy that does not extend Warden::Strategies::Base" do
-    non_base = Class.new do
-      def authenticate!
-      end
-    end
-    expect do
-      Warden::Strategies.add(:strategy_non_base, non_base)
-    end.to raise_error(/is not a Warden::Strategies::Base/)
-  end
-
-  it "should allow me to get access to a particular strategy" do
-    Warden::Strategies.add(:strategy3) do
-      def authenticate!; end
-    end
-    strategy = Warden::Strategies[:strategy3]
-    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
-
-    expect {
-      Warden::Strategies.add(:strategy4, MyStrategy)
-    }.not_to raise_error
-  end
-
-  it "should not allow a strategy that does not have an authenticate! method" do
-    class MyOtherStrategy
-    end
-    expect {
-      Warden::Strategies.add(:strategy5, MyOtherStrategy)
-    }.to raise_error(NoMethodError)
-  end
-
-  it "should allow me to change a class when providing a block and class" do
-    class MyStrategy < Warden::Strategies::Base
-    end
-
-    Warden::Strategies.add(:foo, MyStrategy) do
-      def authenticate!; end
-    end
-
-    expect(Warden::Strategies[:foo].ancestors).to include(MyStrategy)
-  end
-
-  it "should allow me to update a previously given strategy" do
-    class MyStrategy < Warden::Strategies::Base
-      def authenticate!; end
-    end
-
-    Warden::Strategies.add(:strategy6, MyStrategy)
-
-    new_module = Module.new
-    Warden::Strategies.update(:strategy6) do
-      include new_module
-    end
-
-    expect(Warden::Strategies[:strategy6].ancestors).to include(new_module)
-  end
-
-  it "should allow me to clear the strategies" do
-    Warden::Strategies.add(:foobar) do
-      def authenticate!
-        :foo
-      end
-    end
-    expect(Warden::Strategies[:foobar]).not_to be_nil
-    Warden::Strategies.clear!
-    expect(Warden::Strategies[:foobar]).to be_nil
-  end
-end

data/spec/warden/test/helpers_spec.rb

@@ -1,101 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe Warden::Test::Helpers do
-  before{ $captures = [] }
-  after{ Warden.test_reset! }
-
-  it "should log me in as a user" do
-    user = "A User"
-    login_as user
-    app = lambda{|e|
-      $captures << :run
-      expect(e['warden']).to be_authenticated
-      expect(e['warden'].user).to eq("A User")
-      valid_response
-    }
-    setup_rack(app).call(env_with_params)
-    expect($captures).to eq([:run])
-  end
-
-  it "should log me in as a user of a given scope" do
-    user = {:some => "user"}
-    login_as user, :scope => :foo_scope
-    app = lambda{|e|
-      $captures << :run
-      w = e['warden']
-      expect(w).to be_authenticated(:foo_scope)
-      expect(w.user(:foo_scope)).to eq(some: "user")
-    }
-    setup_rack(app).call(env_with_params)
-    expect($captures).to eq([:run])
-  end
-
-  it "should login multiple users with different scopes" do
-    user      = "A user"
-    foo_user  = "A foo user"
-    login_as user
-    login_as foo_user, :scope => :foo
-    app = lambda{|e|
-      $captures << :run
-      w = e['warden']
-      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)
-    expect($captures).to eq([:run])
-  end
-
-  it "should log out all users" do
-    user = "A user"
-    foo  = "Foo"
-    login_as user
-    login_as foo, :scope => :foo
-    app = lambda{|e|
-      $captures << :run
-      w = e['warden']
-      expect(w.user).to eq("A user")
-      expect(w.user(:foo)).to eq("Foo")
-      w.logout
-      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)
-    expect($captures).to eq([:run])
-  end
-
-  it "should logout a specific user" do
-    user = "A User"
-    foo  = "Foo"
-    login_as user
-    login_as foo, :scope => :foo
-    app = lambda{|e|
-      $captures << :run
-      w = e['warden']
-      w.logout :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)
-    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
-      expect(Warden.asset_paths).to eq([/^\/assets\//]      )
-    end
-  end
-end