warden 1.2.6 → 1.2.9

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,93 +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
-
-  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

data/spec/warden/test/mock_spec.rb

@@ -1,15 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe Warden::Test::Mock do
-  before{ $captures = [] }
-  after{ Warden.test_reset! }
-
-  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
-end

data/spec/warden/test/test_mode_spec.rb

@@ -1,75 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe Warden::Test::WardenHelpers do
-  before :all do
-    Warden.test_mode!
-  end
-
-  before do
-    $captures = []
-    @app = lambda{|e| valid_response }
-  end
-
-  after do
-    Warden.test_reset!
-  end
-
-  it{ expect(Warden).to respond_to(:test_mode!)       }
-  it{ expect(Warden).to respond_to(:on_next_request)  }
-  it{ expect(Warden).to respond_to(:test_reset!)      }
-
-  it "should execute the on_next_request block on the next request" do
-    Warden.on_next_request do |warden|
-      $captures << warden
-    end
-
-    setup_rack(@app).call(env_with_params)
-    expect($captures.length).to eq(1)
-    expect($captures.first).to be_an_instance_of(Warden::Proxy)
-  end
-
-  it "should execute many on_next_request blocks on the next request" do
-    Warden.on_next_request{|w| $captures << :first    }
-    Warden.on_next_request{|w| $captures << :second   }
-    setup_rack(@app).call(env_with_params)
-    expect($captures).to eq([:first, :second])
-  end
-
-  it "should not execute on_next_request blocks on subsequent requests" do
-    app = setup_rack(@app)
-    Warden.on_next_request{|w| $captures << :first }
-    app.call(env_with_params)
-    expect($captures).to eq([:first])
-    $captures.clear
-    app.call(env_with_params)
-    expect($captures).to be_empty
-  end
-
-  it "should allow me to set new_on_next_request items to execute in the same test" do
-    app = setup_rack(@app)
-    Warden.on_next_request{|w| $captures << :first }
-    app.call(env_with_params)
-    expect($captures).to eq([:first])
-    Warden.on_next_request{|w| $captures << :second }
-    app.call(env_with_params)
-    expect($captures).to eq([:first, :second])
-  end
-
-  it "should remove the on_next_request items when test is reset" do
-    app = setup_rack(@app)
-    Warden.on_next_request{|w| $captures << :first }
-    Warden.test_reset!
-    app.call(env_with_params)
-    expect($captures).to eq([])
-  end
-
-  context "asset requests" do
-    it "should not execute on_next_request blocks if this is an asset request" do
-      app = setup_rack(@app)
-      Warden.on_next_request{|w| $captures << :first }
-      app.call(env_with_params("/assets/fun.gif"))
-      expect($captures).to eq([])
-    end
-  end
-end