aker-confident 0.1.1

data/lib/aker/confident/aker_slice.rb

@@ -0,0 +1,13 @@
+module Aker
+  module Confident
+    class AkerSlice < Aker::Configuration::Slice
+      def initialize
+        super do
+          after_authentication_middleware do |builder|
+            builder.use Confident::Rack
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aker/confident/aker_user_ext.rb

@@ -0,0 +1,12 @@
+module Aker
+  module Confident
+    module AkerUserExt
+      def sign
+        @signed = Confident.sign(self)
+      end
+      def signed?
+        @signed ||= Confident.signed?(self)
+      end
+    end
+  end
+end

data/lib/aker/confident/configuration.rb

@@ -0,0 +1,131 @@
+module Aker
+  module Confident
+    class ConfigurationError < RuntimeError
+    end
+
+    class Configuration
+      attr_accessor :agreement, :root_url, :host_hook
+      attr_reader :pass_through_hooks
+      def initialize(options_hash={})
+        @pass_through_hooks = []
+        conf_model(options_hash[:conf_model])
+        conf_file(options_hash[:conf_file])
+        set_url options_hash[:root_url]
+        if options_hash[:conf_host_hook]
+          conf_host_hook options_hash[:conf_host_hook]
+        end
+      end
+
+      def define &block
+        instance_eval &block
+        self
+      end
+
+      def conf_model(model_name)
+        if model_name == :default
+          @model = Confident::DefaultSignature
+        else
+          @model = model_name
+        end
+      end
+
+      def set_url(url)
+        @root_url = url
+      end
+
+      def conf_file(file_name)
+        @agreement_file = file_name
+      end
+
+      def conf_host_hook(callable)
+        @pass_through_hooks << callable
+      end
+
+      def verify!
+        validate_agreement_file!
+        load_agreement_file
+        validate_hook!
+        validate_model!
+      end
+
+      def agreement
+        @agreement ||= load_agreement_file
+      end
+
+      def model
+        if @model.is_a? String
+          @model.constantize
+        else
+          @model
+        end
+      end
+
+      private
+
+      def validate_agreement_file!
+        raise Aker::Confident::ConfigurationError unless @agreement_file.present?
+      end
+
+      def load_agreement_file
+        begin
+          @agreement = File.read(@agreement_file)
+        rescue Errno::ENOENT => e
+          raise Aker::Confident::ConfigurationError.new "The specified file does not exist"
+        end
+      end
+
+      def valid_option_keys?(options_hash)
+        options_hash.keys.include?(:conf_model) &&
+          options_hash.keys.include?(:conf_file)
+      end
+      private :valid_option_keys?
+
+      def valid_conf_model_value?(options_hash)
+        if options_hash[:conf_model].is_a? Symbol
+          options_hash[:conf_model] == :default
+        elsif options_hash[:conf_model].is_a? String
+          !options_hash[:conf_model].empty?  
+        else
+          !options_hash[:conf_model].nil?
+        end
+      end
+      private :valid_conf_model_value?
+
+      def valid_conf_file_value?(options_hash)
+        if options_hash[:conf_file].is_a? String
+          !options_hash[:conf_file].empty?
+        else
+          !options_hash[:conf_file].nil?
+        end
+      end
+      private :valid_conf_file_value?
+
+      def validate_model!
+        unless model.respond_to?(:signed?)
+          raise Aker::Confident::ConfigurationError.new "Confidentiality must respond to signed? method."
+        end
+        unless model.respond_to?(:sign)
+          raise Aker::Confident::ConfigurationError.new "Confidentiality must respond to sign method."
+        end
+      end
+
+      def validate_hook!
+        unless pass_through_hooks.empty? 
+          unless pass_through_hooks.all?{ |hook| hook.respond_to?(:call)}
+            raise Aker::Confident::ConfigurationError.new "Host hook must respond to call"
+          end
+        end
+      end
+
+      def validate_options(options_hash)
+        unless valid_option_keys?(options_hash)
+          raise Aker::Confident::ConfigurationError.new "Valid Configurations require a conf_model and a conf_file!" 
+        end
+        unless valid_conf_model_value?(options_hash) && valid_conf_file_value?(options_hash)
+          raise Aker::Confident::ConfigurationError.new "Valid Configuration conf_model and conf_file cannot be nil or blank"
+        end
+      end
+      private :validate_options
+    end
+  end
+end

data/lib/aker/confident/rack.rb

@@ -0,0 +1,24 @@
+require 'rack/request'
+module Aker
+  module Confident
+    class Rack
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if Aker::Confident.pass_through?(env)
+          @app.call(env)
+        else
+          if env['REQUEST_METHOD'] == 'POST'
+            env['aker.check'].user.sign
+            req = ::Rack::Request.new(env)
+            [303, {"Location" => "#{req[:original]}"}, ""]
+          else
+            Aker::Confident::Sinatra.call(env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aker/confident/signer.rb

@@ -0,0 +1,24 @@
+module Aker
+  module Confident
+    module Signer
+      
+      def signed?(user)
+        validate_argument!(user)
+        configuration.model.signed?(user)
+      end
+      
+      def sign(user)
+        validate_argument!(user)
+        configuration.model.sign(user)
+      end
+      
+      
+      def validate_argument!(arg)
+        unless arg.is_a? Aker::User
+          raise ArgumentError.new("Requires an instance of Aker::User as argument")
+        end
+      end
+      private :validate_argument!
+    end
+  end
+end

data/lib/aker/confident/sinatra.rb

@@ -0,0 +1,15 @@
+require 'sinatra/base'
+require 'haml'
+module Aker
+  module Confident
+    class Sinatra < Sinatra::Base
+      set :views, File.dirname(__FILE__) + '/../../../assets/templates'
+      get // do
+        @original_target = request.url
+        @conf_agreement = Aker::Confident.configuration.agreement
+        @root_url = request.scheme + "://" + request.host_with_port + request.script_name
+        haml :agreement
+      end
+    end
+  end
+end

data/lib/aker/confident/version.rb

@@ -0,0 +1,5 @@
+module Aker
+  module Confident
+    VERSION = "0.1.1"
+  end
+end

data/spec/aker_user_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+module Aker
+  class User
+    #add this for convenience in testing
+    attr_accessor :signed
+  end
+end
+
+describe Aker::User do
+  before(:all) do
+    Aker::User.send(:include, Aker::Confident::AkerUserExt)
+  end
+  before(:each) do
+    @user = Aker::User.new(1)
+  end
+  describe "#signed?" do
+    it "is true if confident.signed? is true" do
+      Aker::Confident.stub(:signed?).and_return(true)
+      @user.signed?.should be_true
+    end
+    it "sets the users signed attribute" do
+      Aker::Confident.stub(:signed?).and_return(false)
+      @user.signed.should be_false
+    end
+  end
+  describe "#sign" do
+    it "calls confidents sign method" do
+      Aker::Confident.should_receive(:sign).with(@user).and_return(true)
+      @user.sign
+    end
+    it "updates the users signed attribute" do
+      Aker::Confident.should_receive(:sign).with(@user).and_return(true)
+      @user.sign
+      @user.signed.should == true
+    end
+  end
+end

data/spec/assets/test-users.yml

@@ -0,0 +1,5 @@
+users:
+  wakibbe:
+    password: password
+    portals:
+      - test

data/spec/assets/test_agreement.txt

@@ -0,0 +1 @@
+This is an agreement

data/spec/conf_rack_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+describe Aker::Confident::Rack do 
+  include Rack::Test::Methods
+  
+  class MockApp
+    def call(env)
+      [200, {}, 'Hello from Mock App!']
+    end
+  end
+  
+  def app
+    configure_conf
+    @app = Rack::Builder.new {
+      use Aker::Confident::Rack
+      run MockApp.new
+    }
+    @app.to_app
+  end
+  
+  context "a non-interactive request" do
+    let(:env){ {"aker.interactive" => false} }
+    it "should ignore all non-interactive requests" do
+      get '/foo', {}, env
+      last_response.body.should include "Hello from Mock App!"
+    end
+  end
+
+  context "there is a pass_through_hook defined" do
+    let(:env){ {"aker.check" => stub(:user => stub(:signed? => false)), "aker.interactive" => true} }
+    let(:mock_app){ mock(:call => [200, {}, 'ok']) }
+    it 'calls the host hook with the rack env' do
+      host_hook = stub
+      Aker::Confident.stub(:configuration).
+        and_return (stub(:pass_through_hooks => [host_hook]))
+      host_hook.should_receive(:call)
+      get '/foo', {}, env
+    end
+    context 'the hook is true' do
+      let(:host_hook){ lambda{ |env| true } }
+      before do
+        MockApp.stub(:new).
+          and_return mock_app
+        Aker::Confident.stub(:configuration).
+         and_return stub(:pass_through_hooks => [host_hook])
+      end
+      it 'skips confident' do 
+        mock_app.should_receive(:call)
+        get '/foo', {}, env
+      end
+    end
+    context 'the hook is false' do
+      let(:host_hook){ lambda{ |env| false } }
+      before do
+        MockApp.stub(:new).
+          and_return mock_app
+        Aker::Confident.stub(:configuration).
+          and_return stub(:pass_through_hooks => [host_hook])
+      end
+      it 'calls sinatra' do
+        Aker::Confident::Sinatra.should_receive(:call).and_return [200, {}, 'ok']
+        get '/foo', {}, env
+      end
+    end
+  end
+
+  context "an interactive request" do
+    let(:mock_user){ stub(:signed? => false) }
+    let(:env){
+      {"aker.check" => stub(:user => mock_user),
+       "aker.interactive" => true}
+    }
+    context "post /sign_agreement" do
+      it "should call aker user sign method" do
+        mock_user.should_receive(:sign).and_return true
+        post '/sign_agreement', {:original => "/foo"}, env
+      end
+      it "should redirect to url in params" do
+        mock_user.stub(:sign).and_return true
+        post '/sign_agreement', {:original => "/foo"}, env 
+        last_response.should be_redirect
+        last_response.headers['Location'].should == "/foo" 
+      end
+    end
+
+    context "post elsewhere" do
+      before do
+        @mock_app = mock(:call => [200, {}, 'ok'])
+        MockApp.stub(:new).
+          and_return @mock_app
+      end
+      it "should call the app" do
+        @mock_app.should_receive(:call)
+        post '/junk', {}, env
+      end
+    end
+    context "get logout" do
+      before do
+        @mock_app = mock(:call => [200, {}, 'ok'])
+        MockApp.stub(:new).
+          and_return @mock_app
+      end
+      it "calls the app" do
+        @mock_app.should_receive(:call)
+        get '/logout', {}, env
+      end
+    end
+  
+  
+    context "when agreement is not signed" do
+      before(:each) do
+        mock_user.stub(:signed?).and_return false
+      end
+      it "should call the confident sinatra" do
+        Aker::Confident::Sinatra.should_receive(:call).
+          and_return [200, {}, 'Foo']
+        get '/foo', {}, env 
+      end
+    end
+  
+    context "when agreement is signed" do
+      before(:each) do
+        mock_user.stub(:signed?).and_return true
+      end
+      it "should call the app" do
+        get '/foo', {}, env
+        last_response.should be_ok
+        last_response.body.should include "Hello from Mock App!"
+      end
+    end
+  end
+end

data/spec/conf_sinatra_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Aker::Confident::Sinatra do
+  include Rack::Test::Methods
+  def app
+    configure_conf
+    @app = Aker::Confident::Sinatra
+  end
+  
+  it "should respond to /sign_agreement" do
+    get '/sign_agreement'
+    last_response.should be_ok
+  end
+  
+  it "should render the agreement from the configuration" do
+    get '/sign_agreement'
+    last_response.body.should include "This is an agreement"
+  end
+
+  describe "capybara tests" do
+    
+  end
+  
+end

data/spec/confident_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Aker::Confident do
+  describe "#configure" do
+    let(:dummy_conf){ stub.as_null_object }
+    it "builds a new config object" do
+      Aker::Confident::Configuration.should_receive(:new).and_return dummy_conf
+      Aker::Confident.configure
+    end
+    it "uses a block to define the configuration" do
+      Signature = Class.new
+      def Signature.signed? ; end
+      def Signature.sign ; end
+      Aker::Confident.configure do
+        conf_file  __FILE__
+        conf_model Signature
+      end
+      Aker::Confident.configuration.model.should == Signature
+      Aker::Confident.configuration.agreement.should == File.read(__FILE__)
+    end
+    it "verifys the configuration" do
+      Aker::Confident::Configuration.stub(:new).and_return dummy_conf
+      dummy_conf.stub(:define).and_return dummy_conf
+      dummy_conf.should_receive(:verify!)
+      Aker::Confident.configure do ; end 
+    end
+  end
+end