warden 1.2.5 → 1.2.8

data/spec/helpers/request_helper.rb

@@ -1,51 +0,0 @@
-# encoding: utf-8
-module Warden::Spec
-  module Helpers
-    FAILURE_APP = lambda{|e|[401, {"Content-Type" => "text/plain"}, ["You Fail!"]] }
-
-    def env_with_params(path = "/", params = {}, env = {})
-      method = params.delete(:method) || "GET"
-      env = { 'HTTP_VERSION' => '1.1', 'REQUEST_METHOD' => "#{method}" }.merge(env)
-      Rack::MockRequest.env_for("#{path}?#{Rack::Utils.build_query(params)}", env)
-    end
-
-    def setup_rack(app = nil, opts = {}, &block)
-      app ||= block if block_given?
-
-      opts[:failure_app]         ||= failure_app
-      opts[:default_strategies]  ||= [:password]
-      opts[:default_serializers] ||= [:session]
-      blk = opts[:configurator] || proc{}
-
-      Rack::Builder.new do
-        use opts[:session] || Warden::Spec::Helpers::Session unless opts[:nil_session]
-        use Warden::Manager, opts, &blk
-        run app
-      end
-    end
-
-    def valid_response
-      Rack::Response.new("OK").finish
-    end
-
-    def failure_app
-      Warden::Spec::Helpers::FAILURE_APP
-    end
-
-    def success_app
-      lambda{|e| [200, {"Content-Type" => "text/plain"}, ["You Win"]]}
-    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

data/spec/helpers/strategies/fail_with_user.rb

@@ -1,10 +0,0 @@
-# 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/failz.rb

@@ -1,8 +0,0 @@
-# encoding: utf-8
-Warden::Strategies.add(:failz) do
-  def authenticate!
-    request.env['warden.spec.strategies'] ||= []
-    request.env['warden.spec.strategies'] << :failz
-    fail!("The Fails Strategy Has Failed You")
-  end
-end

data/spec/helpers/strategies/invalid.rb

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

data/spec/helpers/strategies/pass.rb

@@ -1,8 +0,0 @@
-# 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

@@ -1,8 +0,0 @@
-# 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

@@ -1,13 +0,0 @@
-# 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

@@ -1,12 +0,0 @@
-# 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

@@ -1,24 +0,0 @@
-# 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

@@ -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