loyal_warden 0.0.5

data/spec/warden/scoped_session_serializer.rb

@@ -0,0 +1,123 @@
+# 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 == true
+  end
+
+  it "should respond to :deserialize" do
+    serializer_respond_to?(:deserialize).should == 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 == 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 == 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 == "user"
+  end
+
+  it "should not have a {scope}_serialize by default" do
+    serializer_respond_to?(:admin_serialize).should == 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 == "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 == "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 == "test"
+  end
+
+end

data/spec/warden/session_serializer_spec.rb

@@ -0,0 +1,53 @@
+# 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)
+    @env['rack.session'].should == { "warden.user.default.key"=>"user" }
+  end
+
+  it "should check if a data is stored or not" do
+    @session.should_not be_stored(:default)
+    @session.store("user", :default)
+    @session.should be_stored(:default)
+  end
+
+  it "should load an user from store" do
+    @session.fetch(:default).should be_nil
+    @session.store("user", :default)
+    @session.fetch(:default).should == "user"
+  end
+
+  it "should store data based on the scope" do
+    @session.store("user", :default)
+    @session.fetch(:default).should == "user"
+    @session.fetch(:another).should be_nil
+  end
+
+  it "should delete data from store" do
+    @session.store("user", :default)
+    @session.fetch(:default).should == "user"
+    @session.delete(:default)
+    @session.fetch(:default).should be_nil
+  end
+
+  it "should delete information from store if user cannot be retrieved" do
+    @session.store("user", :default)
+    @env['rack.session'].should have_key("warden.user.default.key")
+    @session.instance_eval "def deserialize(key); nil; end"
+    @session.fetch(:default)
+    @env['rack.session'].should_not have_key("warden.user.default.key")
+  end
+
+  it "should support a nil session store" do
+    @env['rack.session'] = nil
+    @session.fetch(:default).should be_nil
+  end
+end

data/spec/warden/strategies/base_spec.rb

@@ -0,0 +1,313 @@
+# 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!
+      strategy.headers["foo"].should == "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!
+      strategy.headers["foo"].should == "bar"
+      strategy.headers.clear
+      strategy.headers.should 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!
+    strategy.user.should == "foo"
+  end
+
+  it "should be performed after run" do
+    RAS.add(:foobar) do
+      def authenticate!; end
+    end
+    strategy = RAS[:foobar].new(env_with_params)
+    strategy.should_not be_performed
+    strategy._run!
+    strategy.should be_performed
+    strategy.clear!
+    strategy.should_not be_performed
+  end
+
+  it "should set the scope" do
+    RAS.add(:foobar) do
+      def authenticate!
+        self.scope.should == :user
+      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!
+    strategy.message.should == "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!
+    strategy.errors.on(:foo).should == ["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!
+      str.should 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!
+      str.should_not 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!
+      str.should_not be_halted
+      str.user.should 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!
+      str.user.should 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!
+      str.should 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!
+      str.headers["Location"].should == "/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!
+      str.headers["Location"].should == "/foo/bar?foo=bar"
+      str.message.should == "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!
+      str.result.should == :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!
+      @hard.user.should be_nil
+    end
+
+    it "should halt the strategies when failing hard" do
+      @hard._run!
+      @hard.should be_halted
+    end
+
+    it "should allow you to set a message when failing hard" do
+      @hard._run!
+      @hard.message.should == "You are not cool enough"
+    end
+
+    it "should set the action as :failure when failing hard" do
+      @hard._run!
+      @hard.result.should == :failure
+    end
+
+    it "should allow you to fail soft" do
+      @soft._run!
+      @soft.user.should be_nil
+    end
+
+    it "should not halt the strategies when failing soft" do
+      @soft._run!
+      @soft.should_not be_halted
+    end
+
+    it "should allow you to set a message when failing soft" do
+      @soft._run!
+      @soft.message.should == "You are too soft"
+    end
+
+    it "should set the action as :failure when failing soft" do
+      @soft._run!
+      @soft.result.should == :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!
+      @str.user.should_not be_nil
+    end
+
+    it "should allow you to set a message when succeeding" do
+      @str._run!
+      @str.message.should == "Welcome to the club!"
+    end
+
+    it "should store the user" do
+      @str._run!
+      @str.user.should == "Foo User"
+    end
+
+    it "should set the action as :success" do
+      @str._run!
+      @str.result.should == :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
+      @str.user.should be_nil
+    end
+
+    it "should halt the strategy" do
+      @str.should be_halted
+    end
+
+    it "should provide access to the custom rack response" do
+      @str.custom_response.should == [521, {"foo" => "bar"}, ["BAD"]]
+    end
+
+    it "should set the action as :custom" do
+      @str._run!
+      @str.result.should == :custom
+    end
+  end
+
+end