aker 3.0.0.pre

data/spec/aker/form/a_form_mode.rb

@@ -0,0 +1,129 @@
+require File.expand_path("../../../spec_helper", __FILE__)
+require File.expand_path("../../modes/a_aker_mode", __FILE__)
+require "rack"
+
+module Aker::Form
+  shared_examples 'a form mode' do
+    let(:config) { Aker::Configuration.new(:slices => [Aker::Rack::Slice.new]) }
+
+    before do
+      @env = ::Rack::MockRequest.env_for("/")
+      @env['aker.configuration'] = config
+      @scope = mock
+      @mode = Mode.new(@env, @scope)
+    end
+
+    it_should_behave_like "a aker mode"
+
+    describe "#kind" do
+      it "is :user" do
+        @mode.kind.should == :user
+      end
+    end
+
+    describe "#credentials" do
+      it "contains username and password" do
+        set_params("username" => "foo", "password" => "bar")
+
+        @mode.credentials.should == ["foo", "bar"]
+      end
+
+      it "is an empty array if neither username nor password were given" do
+        @mode.credentials.should == []
+      end
+    end
+
+    describe "#valid?" do
+      it "returns true if a username and password are present" do
+        set_params("username" => "foo", "password" => "bar")
+
+        @mode.should be_valid
+      end
+
+      it "returns false if a username or password are missing" do
+        @mode.should_not be_valid
+      end
+    end
+
+    describe "#authenticate!" do
+      before do
+        set_params("username" => "foo", "password" => "bar")
+
+        @authority = mock
+        @mode.stub!(:authority => @authority)
+      end
+
+      it "signals success if the username and password are good" do
+        user = stub
+        @authority.should_receive(:valid_credentials?).with(:user, "foo", "bar").and_return(user)
+        @mode.should_receive(:success!).with(user)
+
+        @mode.authenticate!
+      end
+
+      it "does not signal success if the username or password are bad" do
+        @authority.stub!(:valid_credentials? => nil)
+        @mode.should_not_receive(:success!)
+
+        @mode.authenticate!
+      end
+    end
+
+    describe "#login_url" do
+      it "uses '/login' as its path" do
+        URI.parse(@mode.login_url).path.should == "/login"
+      end
+
+      it "respects SCRIPT_NAME" do
+        @env["SCRIPT_NAME"] = "/app"
+
+        URI.parse(@mode.login_url).path.should == "/app/login"
+      end
+
+      it 'uses another path if one is specified in the configuration' do
+        @env['SCRIPT_NAME'] = '/banjo'
+        config.parameters_for(:rack)[:login_path] = '/auth/login'
+
+        URI.parse(@mode.login_url).path.should == "/banjo/auth/login"
+      end
+    end
+
+    describe "#on_ui_failure" do
+      include Rack::Utils
+
+      it "redirects to the login form" do
+        response = @mode.on_ui_failure
+
+        response.should be_redirect
+        URI.parse(response.location).path.should == "/login"
+      end
+
+      it 'redirects to a different login form path if specified in the configuration' do
+        config.parameters_for(:rack)[:login_path] = '/auth/login'
+        response = @mode.on_ui_failure
+
+        URI.parse(response.location).path.should == '/auth/login'
+      end
+
+      it "puts the URL the user was trying to reach in the query string" do
+        @env["warden.options"] = { :attempted_path => "http://www.example.edu" }
+
+        response = @mode.on_ui_failure
+
+        URI.parse(response.location).query.should == "url=" + escape("http://www.example.edu")
+      end
+
+      it 'puts the session expiration parameter in the URL if the has to log in due to session expiration' do
+        @env['aker.session_expired'] = true
+
+        response = @mode.on_ui_failure
+
+        URI.parse(response.location).query.should == "url=&session_expired=true"
+      end
+    end
+
+    def set_params(params)
+      @env.update(::Rack::MockRequest.env_for("/", :params => params))
+    end
+  end
+end

data/spec/aker/form/custom_views_mode_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path("../../../spec_helper", __FILE__)
+require File.expand_path("../a_form_mode", __FILE__)
+require "rack"
+
+module Aker::Form
+  describe CustomViewsMode do
+    it_should_behave_like "a form mode"
+
+    describe "#key" do
+      it "is :custom_form" do
+        CustomViewsMode.key.should == :custom_form
+      end
+    end
+
+    describe "middleware" do
+      let(:builder) { Aker::Spec::MockBuilder.new }
+
+      it "prepends nothing" do
+        CustomViewsMode.prepend_middleware(builder)
+        builder.uses.should be_empty
+      end
+
+      it 'appends only one piece of middleware' do
+        CustomViewsMode.append_middleware(builder)
+        builder.should have(1).uses
+      end
+
+      it "appends its own login responder" do
+        CustomViewsMode.append_middleware(builder)
+        builder.should be_using(Middleware::CustomViewLoginResponder)
+      end
+    end
+  end
+end

data/spec/aker/form/login_form_asset_provider_spec.rb

@@ -0,0 +1,80 @@
+require File.expand_path("../../../spec_helper", __FILE__)
+require 'nokogiri'
+
+module Aker::Form
+  describe LoginFormAssetProvider do
+    let(:vessel) do
+      Object.new.tap { |o| o.extend(LoginFormAssetProvider) }
+    end
+
+    let(:configuration) do
+      Aker::Configuration.new do
+        rack_parameters :login_path => '/auth/login'
+      end
+    end
+
+    describe "#login_html" do
+      let(:env) { { 'SCRIPT_NAME' => '/foo', 'aker.configuration' => configuration } }
+
+      before do
+        @doc = Nokogiri.HTML(vessel.login_html(env))
+      end
+
+      it "includes SCRIPT_NAME in the postback URL" do
+        (@doc/'form').first.attributes["action"].value.should == "/foo/auth/login"
+      end
+
+      it "includes SCRIPT_NAME in the CSS URL" do
+        (@doc/'link[rel="stylesheet"]').first.attributes["href"].value.should == "/foo/auth/login/login.css"
+      end
+
+      it "can render a 'login failed' message" do
+        @doc = Nokogiri.HTML(vessel.login_html(env, { :login_failed => true }))
+
+        (@doc/'.error').first.inner_html.should == 'Login failed'
+      end
+
+      it "can render a 'logged out' message" do
+        @doc = Nokogiri.HTML(vessel.login_html(env, { :logged_out => true }))
+
+        (@doc/'h1').first.inner_html.should == 'Logged out'
+      end
+
+      it "can render a 'session expired' message" do
+        @doc = Nokogiri.HTML(vessel.login_html(env, { :session_expired => true }))
+
+        (@doc/'.error').first.inner_html.should == 'Session expired'
+      end
+
+      it "can render text in the username text field" do
+        @doc = Nokogiri.HTML(vessel.login_html(env, { :username => "user" }))
+
+        (@doc/'input[name="username"]').first['value'].should == 'user'
+      end
+
+      it "can store a URL to go to after login succeeds" do
+        @doc = Nokogiri.HTML(vessel.login_html(env, { :url => 'http://www.example.edu' }))
+
+        (@doc/'input[name="url"]').first['value'].should == 'http://www.example.edu'
+      end
+
+      it "escapes HTML in usernames" do
+        html = vessel.login_html(env, { :username => "user<a/>" })
+
+        # Annoyingly, Nokogiri.HTML automatically unescapes escaped entities in
+        # attribute values.
+        html.should include("user&lt;a&#x2F;&gt;");
+        html.should_not include("user<a/>")
+      end
+    end
+
+    describe "#login_css" do
+      it "provides CSS for the login form" do
+        expected_css = File.read(File.join(File.dirname(__FILE__),
+                                           %w(.. .. .. assets aker form login.css)))
+
+        vessel.login_css.should == expected_css
+      end
+    end
+  end
+end

data/spec/aker/form/middleware/a_form_login_responder.rb

@@ -0,0 +1,89 @@
+require File.expand_path('../../../../spec_helper.rb', __FILE__)
+
+shared_context 'login responder context' do
+  include Rack::Test::Methods
+
+  let(:app) do
+    mw = responder_middleware_class
+    capture = captured_env
+    Rack::Builder.new do
+      use mw
+
+      app = lambda do |env|
+        capture << env
+        [200, {"Content-Type" => "text/html"}, ["Hello"]]
+      end
+
+      run app
+    end
+  end
+
+  let(:login_path) { '/auth/login' }
+
+  let(:configuration) do
+    path = login_path;
+    Aker::Configuration.new { rack_parameters :login_path => path }
+  end
+
+  let(:env) do
+    { 'aker.configuration' => configuration }
+  end
+
+  let(:captured_env) { [] }
+end
+
+shared_examples 'a form login responder' do
+  include_context 'login responder context'
+
+  it "does not intercept GETs to the login path" do
+    get login_path, {}, env
+
+    last_response.should be_ok
+    last_response.body.should == "Hello"
+  end
+
+  it "does not intercept POSTs to paths that are not the login path" do
+    post "/foo", {}, env
+
+    last_response.should be_ok
+    last_response.body.should == "Hello"
+  end
+
+  describe "#call" do
+    let(:warden) { mock }
+
+    before do
+      env.update("warden" => warden, "REQUEST_METHOD" => "POST")
+    end
+
+    describe "when authentication succeeded" do
+      it "redirects to a given URL" do
+        warden.should_receive(:authenticated?).and_return(true)
+
+        post login_path, { :url => "/protected" }, env
+
+        last_response.should be_redirect
+        last_response.location.should == "/protected"
+      end
+
+      it "redirects to the application's root if no URL was given" do
+        warden.should_receive(:authenticated?).and_return(true)
+        env['SCRIPT_NAME'] = "/foo"
+
+        post login_path, {}, env
+
+        last_response.should be_redirect
+        last_response.location.should == "/foo/"
+      end
+
+      it "redirects to the application's root if the URL given is a blank string" do
+        warden.should_receive(:authenticated?).and_return(true)
+
+        post login_path, { :url => "" }, env
+
+        last_response.should be_redirect
+        last_response.location.should == "/"
+      end
+    end
+  end
+end

data/spec/aker/form/middleware/custom_view_login_responder_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path("../../../../spec_helper", __FILE__)
+require File.expand_path('../a_form_login_responder', __FILE__)
+require "rack/test"
+
+module Aker::Form::Middleware
+  describe CustomViewLoginResponder do
+    let(:responder_middleware_class) { Aker::Form::Middleware::CustomViewLoginResponder }
+
+    it_behaves_like 'a form login responder'
+
+    include_context 'login responder context'
+
+    describe "#call" do
+      let(:warden) { mock }
+
+      before do
+        env.update("warden" => warden, "REQUEST_METHOD" => "POST")
+      end
+
+      describe "when authentication failed" do
+        before do
+          warden.stub(:authenticated? => false, :custom_failure! => nil)
+
+          post login_path,
+            {'username' => 'jo', 'password' => 'wrong'},
+            env
+        end
+
+        def recorded_env
+          captured_env.first
+        end
+
+        it "adds the login failed flag to the environment" do
+          recorded_env['aker.form.login_failed'].should == true
+        end
+
+        it "adds the attempted username to the environment" do
+          recorded_env['aker.form.username'].should == 'jo'
+        end
+
+        it 'calls the app' do
+          last_response.body.should == "Hello"
+        end
+      end
+    end
+  end
+end

data/spec/aker/form/middleware/login_renderer_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path("../../../../spec_helper", __FILE__)
+require "rack/test"
+
+module Aker::Form::Middleware
+  describe LoginRenderer do
+    include Rack::Test::Methods
+
+    let(:app) do
+      Rack::Builder.new do
+        use Aker::Form::Middleware::LoginRenderer
+        run lambda { |env| [200, {"Content-Type" => "text/html"}, ["Hello"]] }
+      end
+    end
+
+    let(:env) do
+      { 'aker.configuration' => configuration }
+    end
+
+    let(:configuration) do
+      path = login_path
+      Aker::Configuration.new {
+        rack_parameters :login_path => path
+      }
+    end
+
+    let(:login_path) { '/log-in-here' }
+
+    it "does not intercept POSTs to the login path" do
+      post login_path, {}, env
+
+      last_response.should be_ok
+      last_response.body.should == "Hello"
+    end
+
+    it "does not intercept GETs to paths that are not the login path" do
+      get "/foo", {}, env
+
+      last_response.should be_ok
+      last_response.body.should == "Hello"
+    end
+
+    it "renders login forms for GETs on the login path" do
+      get login_path, {}, env
+
+      last_response.should be_ok
+      last_response.content_type.should == "text/html"
+    end
+
+    it "outputs CSS for GETs on (the login path) + .css" do
+      get "/log-in-here/login.css", {}, env
+
+      last_response.should be_ok
+      last_response.content_type.should == "text/css"
+    end
+  end
+end

data/spec/aker/form/middleware/login_responder_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path("../../../../spec_helper", __FILE__)
+require File.expand_path('../a_form_login_responder', __FILE__)
+require "rack/test"
+
+module Aker::Form::Middleware
+  describe LoginResponder do
+    let(:responder_middleware_class) { Aker::Form::Middleware::LoginResponder }
+
+    it_behaves_like 'a form login responder'
+
+    include_context 'login responder context'
+
+    describe "#call" do
+      let(:warden) { mock }
+
+      before do
+        env.update("warden" => warden, "REQUEST_METHOD" => "POST")
+      end
+
+      describe "when authentication failed" do
+        before do
+          warden.stub(:authenticated? => false, :custom_failure! => nil)
+        end
+
+        it "renders a 'login failed' message" do
+          post login_path, {}, env
+
+          last_response.status.should == 401
+          last_response.body.should include("Login failed")
+        end
+      end
+    end
+  end
+end

data/spec/aker/form/middleware/logout_responder_spec.rb

@@ -0,0 +1,55 @@
+require File.expand_path("../../../../spec_helper", __FILE__)
+require "rack/test"
+
+module Aker::Form::Middleware
+  describe LogoutResponder do
+    include Rack::Test::Methods
+
+    let(:app) do
+      Rack::Builder.new do
+        use Aker::Form::Middleware::LogoutResponder
+
+        app = lambda do |env|
+          if env["REQUEST_METHOD"] == "GET" && env["PATH_INFO"] == "/this/logout"
+            [200, {"Content-Type" => "text/plain"}, ["Logged out"]]
+          else
+            [404, {"Content-Type" => "text/plain"}, []]
+          end
+        end
+
+        run app
+      end
+    end
+
+    let(:configuration) {
+      Aker::Configuration.new do
+        rack_parameters :logout_path => '/this/logout'
+      end
+    }
+
+    let(:env) do
+      { 'aker.configuration' => configuration }
+    end
+
+    describe '#call' do
+      it "responds to GET {configured logout path}" do
+        get "/this/logout", {}, env
+
+        last_response.should be_ok
+        last_response.content_type.should == "text/html"
+      end
+
+      it 'does not respond on other paths' do
+        get "/", {}, env
+
+        last_response.status.should == 404
+      end
+
+      it 'does not respond on other methods' do
+        post "/this/logout", {}, env
+
+        last_response.status.should == 404
+      end
+    end
+  end
+end

data/spec/aker/form/mode_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path("../../../spec_helper", __FILE__)
+require File.expand_path("../a_form_mode", __FILE__)
+require "rack"
+
+module Aker::Form
+  describe Mode do
+    it_should_behave_like "a form mode"
+
+    describe "#key" do
+      it "is :form" do
+        Mode.key.should == :form
+      end
+    end
+  end
+end

data/spec/aker/form_spec.rb

@@ -0,0 +1,11 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+module Aker
+  describe Form::Slice do
+    let(:configuration) { Configuration.new(:slices => [Form::Slice.new]) }
+
+    it 'registers the cas proxy mode' do
+      configuration.registered_modes.should include(Aker::Form::Mode)
+    end
+  end
+end