omniauth 0.2.6 → 0.3.0

data/oa-core/spec/omniauth/strategy_spec.rb

@@ -1,363 +0,0 @@
-require File.expand_path('../../spec_helper', __FILE__)
-
-class ExampleStrategy
-  include OmniAuth::Strategy
-  def call(env); self.call!(env) end
-  attr_reader :last_env
-  def request_phase
-    @fail = fail!(options[:failure]) if options[:failure]
-    @last_env = env
-    return @fail if @fail
-    raise "Request Phase"
-  end
-  def callback_phase
-    @fail = fail!(options[:failure]) if options[:failure]
-    @last_env = env
-    return @fail if @fail
-    raise "Callback Phase"
-  end
-end
-
-def make_env(path = '/auth/test', props = {})
-  {
-    'REQUEST_METHOD' => 'GET',
-    'PATH_INFO' => path,
-    'rack.session' => {},
-    'rack.input' => StringIO.new('test=true')
-  }.merge(props)
-end
-
-describe OmniAuth::Strategy do
-  let(:app){ lambda{|env| [404, {}, ['Awesome']]}}
-  describe '#initialize' do
-    context 'options extraction' do
-      it 'should be the last argument if the last argument is a Hash' do
-        ExampleStrategy.new(app, 'test', :abc => 123).options[:abc].should == 123
-      end
-
-      it 'should be a blank hash if none are provided' do
-        ExampleStrategy.new(app, 'test').options.should == {}
-      end
-    end
-  end
-
-  describe '#full_host' do
-    let(:strategy){ ExampleStrategy.new(app, 'test', {}) }
-    it 'should not freak out if there is a pipe in the URL' do
-      strategy.call!(make_env('/whatever', 'rack.url_scheme' => 'http', 'SERVER_NAME' => 'facebook.lame', 'QUERY_STRING' => 'code=asofibasf|asoidnasd', 'SCRIPT_NAME' => '', 'SERVER_PORT' => 80))
-      lambda{ strategy.full_host }.should_not raise_error
-    end
-  end
-
-  describe '#call' do
-    let(:strategy){ ExampleStrategy.new(app, 'test', @options) }
-
-    context 'omniauth.origin' do
-      it 'should be set on the request phase' do
-        lambda{ strategy.call(make_env('/auth/test', 'HTTP_REFERER' => 'http://example.com/origin')) }.should raise_error("Request Phase")
-        strategy.last_env['rack.session']['omniauth.origin'].should == 'http://example.com/origin'
-      end
-
-      it 'should be turned into an env variable on the callback phase' do
-        lambda{ strategy.call(make_env('/auth/test/callback', 'rack.session' => {'omniauth.origin' => 'http://example.com/origin'})) }.should raise_error("Callback Phase")
-        strategy.last_env['omniauth.origin'].should == 'http://example.com/origin'
-      end
-
-      it 'should set from the params if provided' do
-        lambda{ strategy.call(make_env('/auth/test', 'QUERY_STRING' => 'origin=/foo')) }.should raise_error('Request Phase')
-        strategy.last_env['rack.session']['omniauth.origin'].should == '/foo'
-      end
-
-      it 'should be set on the failure env' do
-        OmniAuth.config.should_receive(:on_failure).and_return(lambda{|env| env})
-        @options = {:failure => :forced_fail}
-        strategy.call(make_env('/auth/test/callback', 'rack.session' => {'omniauth.origin' => '/awesome'}))
-      end
-
-      context "with script_name" do
-        it 'should be set on the request phase, containing full path' do
-          env = {'HTTP_REFERER' => 'http://example.com/sub_uri/origin', 'SCRIPT_NAME' => '/sub_uri' }
-          lambda{ strategy.call(make_env('/auth/test', env)) }.should raise_error("Request Phase")
-          strategy.last_env['rack.session']['omniauth.origin'].should == 'http://example.com/sub_uri/origin'
-        end
-
-        it 'should be turned into an env variable on the callback phase, containing full path' do
-          env = {
-            'rack.session' => {'omniauth.origin' => 'http://example.com/sub_uri/origin'},
-            'SCRIPT_NAME' => '/sub_uri'
-          }
-
-          lambda{ strategy.call(make_env('/auth/test/callback', env)) }.should raise_error("Callback Phase")
-          strategy.last_env['omniauth.origin'].should == 'http://example.com/sub_uri/origin'
-        end
-
-      end
-    end
-
-    context 'default paths' do
-      it 'should use the default request path' do
-        lambda{ strategy.call(make_env) }.should raise_error("Request Phase")
-      end
-
-      it 'should be case insensitive on request path' do
-        lambda{ strategy.call(make_env('/AUTH/Test'))}.should raise_error("Request Phase")
-      end
-
-      it 'should be case insensitive on callback path' do
-        lambda{ strategy.call(make_env('/AUTH/TeSt/CaLlBAck'))}.should raise_error("Callback Phase")
-      end
-
-      it 'should use the default callback path' do
-        lambda{ strategy.call(make_env('/auth/test/callback')) }.should raise_error("Callback Phase")
-      end
-
-      it 'should strip trailing spaces on request' do
-        lambda{ strategy.call(make_env('/auth/test/')) }.should raise_error("Request Phase")
-      end
-
-      it 'should strip trailing spaces on callback' do
-        lambda{ strategy.call(make_env('/auth/test/callback/')) }.should raise_error("Callback Phase")
-      end
-
-      context 'callback_url' do
-        it 'uses the default callback_path' do
-          strategy.should_receive(:full_host).and_return('http://example.com')
-
-          lambda{ strategy.call(make_env) }.should raise_error("Request Phase")
-
-          strategy.callback_url.should == 'http://example.com/auth/test/callback'
-        end
-
-        it 'preserves the query parameters' do
-          strategy.stub(:full_host).and_return('http://example.com')
-          begin
-            strategy.call(make_env('/auth/test', 'QUERY_STRING' => 'id=5'))
-          rescue RuntimeError; end
-          strategy.callback_url.should == 'http://example.com/auth/test/callback?id=5'
-        end
-
-        it 'consider script name' do
-          strategy.stub(:full_host).and_return('http://example.com')
-          begin
-            strategy.call(make_env('/auth/test', 'SCRIPT_NAME' => '/sub_uri'))
-          rescue RuntimeError; end
-          strategy.callback_url.should == 'http://example.com/sub_uri/auth/test/callback'
-        end
-      end
-    end
-
-    context 'pre-request call through' do
-      subject { ExampleStrategy.new(app, 'test') }
-      let(:app){ lambda{|env| env['omniauth.boom'] = true; [env['test.status'] || 404, {}, ['Whatev']] } }
-      it 'should be able to modify the env on the fly before the request_phase' do
-        lambda{ subject.call(make_env) }.should raise_error("Request Phase")
-        subject.response.status.should == 404
-        subject.last_env.should be_key('omniauth.boom')
-      end
-
-      it 'should call through to the app instead if a non-404 response is received' do
-        lambda{ subject.call(make_env('/auth/test', 'test.status' => 200)) }.should_not raise_error
-        subject.response.body.should == ['Whatev']
-      end
-    end
-
-    context 'custom paths' do
-      it 'should use a custom request_path if one is provided' do
-        @options = {:request_path => '/awesome'}
-        lambda{ strategy.call(make_env('/awesome')) }.should raise_error("Request Phase")
-      end
-
-      it 'should use a custom callback_path if one is provided' do
-        @options = {:callback_path => '/radical'}
-        lambda{ strategy.call(make_env('/radical')) }.should raise_error("Callback Phase")
-      end
-
-      context 'callback_url' do
-        it 'uses a custom callback_path if one is provided' do
-          @options = {:callback_path => '/radical'}
-          strategy.should_receive(:full_host).and_return('http://example.com')
-
-          lambda{ strategy.call(make_env('/radical')) }.should raise_error("Callback Phase")
-
-          strategy.callback_url.should == 'http://example.com/radical'
-        end
-
-        it 'preserves the query parameters' do
-          @options = {:callback_path => '/radical'}
-          strategy.stub(:full_host).and_return('http://example.com')
-          begin
-            strategy.call(make_env('/auth/test', 'QUERY_STRING' => 'id=5'))
-          rescue RuntimeError; end
-          strategy.callback_url.should == 'http://example.com/radical?id=5'
-        end
-      end
-    end
-
-    context 'custom prefix' do
-      before do
-        @options = {:path_prefix => '/wowzers'}
-      end
-
-      it 'should use a custom prefix for request' do
-        lambda{ strategy.call(make_env('/wowzers/test')) }.should raise_error("Request Phase")
-      end
-
-      it 'should use a custom prefix for callback' do
-        lambda{ strategy.call(make_env('/wowzers/test/callback')) }.should raise_error("Callback Phase")
-      end
-
-      context 'callback_url' do
-        it 'uses a custom prefix' do
-          strategy.should_receive(:full_host).and_return('http://example.com')
-
-          lambda{ strategy.call(make_env('/wowzers/test')) }.should raise_error("Request Phase")
-
-          strategy.callback_url.should == 'http://example.com/wowzers/test/callback'
-        end
-
-        it 'preserves the query parameters' do
-          strategy.stub(:full_host).and_return('http://example.com')
-          begin
-            strategy.call(make_env('/auth/test', 'QUERY_STRING' => 'id=5'))
-          rescue RuntimeError; end
-          strategy.callback_url.should == 'http://example.com/wowzers/test/callback?id=5'
-        end
-      end
-    end
-
-    context 'request method restriction' do
-      before do
-        OmniAuth.config.allowed_request_methods = [:post]
-      end
-
-      it 'should not allow a request method of the wrong type' do
-        lambda{ strategy.call(make_env)}.should_not raise_error
-      end
-
-      it 'should allow a request method of the correct type' do
-        lambda{ strategy.call(make_env('/auth/test', 'REQUEST_METHOD' => 'POST'))}.should raise_error("Request Phase")
-      end
-
-      after do
-        OmniAuth.config.allowed_request_methods = [:get, :post]
-      end
-    end
-
-    context 'test mode' do
-      before do
-        OmniAuth.config.test_mode = true
-      end
-
-      it 'should short circuit the request phase entirely' do
-        response = strategy.call(make_env)
-        response[0].should == 302
-        response[1]['Location'].should == '/auth/test/callback'
-      end
-
-      it 'should be case insensitive on request path' do
-        strategy.call(make_env('/AUTH/Test'))[0].should == 302
-      end
-
-      it 'should respect SCRIPT_NAME (a.k.a. BaseURI)' do
-        response = strategy.call(make_env('/auth/test', 'SCRIPT_NAME' => '/sub_uri'))
-        response[1]['Location'].should == '/sub_uri/auth/test/callback'
-      end
-
-      it 'should be case insensitive on callback path' do
-        strategy.call(make_env('/AUTH/TeSt/CaLlBAck')).should == strategy.call(make_env('/auth/test/callback'))
-      end
-
-      it 'should not short circuit requests outside of authentication' do
-        strategy.call(make_env('/')).should == app.call(make_env('/'))
-      end
-
-      it 'should respond with the default hash if none is set' do
-        strategy.call make_env('/auth/test/callback')
-        strategy.env['omniauth.auth']['uid'].should == '1234'
-      end
-
-      it 'should respond with a provider-specific hash if one is set' do
-        OmniAuth.config.mock_auth[:test] = {
-          'uid' => 'abc'
-        }
-
-        strategy.call make_env('/auth/test/callback')
-        strategy.env['omniauth.auth']['uid'].should == 'abc'
-      end
-
-      it 'should simulate login failure if mocked data is set as a symbol' do
-        OmniAuth.config.mock_auth[:test] = :invalid_credentials
-
-        strategy.call make_env('/auth/test/callback')
-        strategy.env['omniauth.error.type'].should == :invalid_credentials
-      end
-
-      it 'should set omniauth.origin on the request phase' do
-        strategy.call(make_env('/auth/test', 'HTTP_REFERER' => 'http://example.com/origin'))
-        strategy.env['rack.session']['omniauth.origin'].should == 'http://example.com/origin'
-      end
-
-      it 'should set omniauth.origin from the params if provided' do
-        strategy.call(make_env('/auth/test', 'QUERY_STRING' => 'origin=/foo'))
-        strategy.env['rack.session']['omniauth.origin'].should == '/foo'
-      end
-
-      it 'should turn omniauth.origin into an env variable on the callback phase' do
-        OmniAuth.config.mock_auth[:test] = {}
-
-        strategy.call(make_env('/auth/test/callback', 'rack.session' => {'omniauth.origin' => 'http://example.com/origin'}))
-        strategy.env['omniauth.origin'].should == 'http://example.com/origin'
-      end
-    end
-
-    context 'custom full_host' do
-      it 'should be the string when a string is there' do
-        OmniAuth.config.full_host = 'my.host.com'
-        strategy.full_host.should == 'my.host.com'
-      end
-
-      it 'should run the proc with the env when it is a proc' do
-        OmniAuth.config.full_host = Proc.new{|env| env['HOST']}
-        strategy.call(make_env('/auth/test', 'HOST' => 'my.host.net'))
-        strategy.full_host.should == 'my.host.net'
-      end
-    end
-  end
-
-  context 'setup phase' do
-    context 'when options[:setup] = true' do
-      let(:strategy){ ExampleStrategy.new(app, 'test', :setup => true) }
-      let(:app){lambda{|env| env['omniauth.strategy'].options[:awesome] = 'sauce' if env['PATH_INFO'] == '/auth/test/setup'; [404, {}, 'Awesome'] }}
-
-      it 'should call through to /auth/:provider/setup' do
-        strategy.call(make_env('/auth/test'))
-        strategy.options[:awesome].should == 'sauce'
-      end
-
-      it 'should not call through on a non-omniauth endpoint' do
-        strategy.call(make_env('/somewhere/else'))
-        strategy.options[:awesome].should_not == 'sauce'
-      end
-    end
-
-    context 'when options[:setup] is an app' do
-      let(:setup_proc) do
-        Proc.new do |env|
-          env['omniauth.strategy'].options[:awesome] = 'sauce'
-        end
-      end
-
-      let(:strategy){ ExampleStrategy.new(app, 'test', :setup => setup_proc) }
-
-      it 'should not call the app on a non-omniauth endpoint' do
-        strategy.call(make_env('/somehwere/else'))
-        strategy.options[:awesome].should_not == 'sauce'
-      end
-
-      it 'should call the rack app' do
-        strategy.call(make_env('/auth/test'))
-        strategy.options[:awesome].should == 'sauce'
-      end
-    end
-  end
-end

data/oa-core/spec/spec_helper.rb

@@ -1,12 +0,0 @@
-require 'simplecov'
-SimpleCov.start
-require 'rspec'
-require 'rack/test'
-require 'omniauth/core'
-require 'omniauth/test'
-
-RSpec.configure do |config|
-  config.include Rack::Test::Methods
-  config.extend  OmniAuth::Test::StrategyMacros, :type => :strategy
-end
-

data/oa-enterprise/.rspec

@@ -1,3 +0,0 @@
---color
---format=nested
---backtrace

data/oa-enterprise/.yardopts

@@ -1,4 +0,0 @@
---markup markdown
---markup-provider maruku
--
-LICENSE

data/oa-enterprise/Gemfile

@@ -1,7 +0,0 @@
-source 'http://rubygems.org'
-
-platforms :jruby do
-  gem 'jruby-openssl', '~> 0.7'
-end
-
-gemspec

data/oa-enterprise/LICENSE

@@ -1,19 +0,0 @@
-Copyright (c) 2010-2011 Michael Bleigh and Intridea, Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

data/oa-enterprise/README.rdoc

@@ -1,82 +0,0 @@
-= OmniAuth::Enterprise
-
-OmniAuth strategies for use in your intranet.
-
-== Installation
-
-To get just enterprise functionality:
-
-    gem install oa-enterprise
-    
-For the full auth suite:
-
-    gem install omniauth
-
-== CAS
-
-Use the CAS strategy as a middleware in your application:
-
-    require 'omniauth/enterprise'
-    
-    use OmniAuth::Strategies::CAS, :server => 'http://cas.mycompany.com/cas'
-    
-Then simply direct users to '/auth/cas' to have them sign in via your company's CAS server.
-See OmniAuth::Strategies::CAS::Configuration for more configuration options.
-
-== LDAP
-
-Use the LDAP strategy as a middleware in your application:
-
-    require 'omniauth/enterprise'
-    use OmniAuth::Strategies::LDAP, 
-        :title => "My LDAP", 
-        :host => '10.101.10.1',
-        :port => 389,
-        :method => :plain,
-        :base => 'dc=intridea, dc=com',
-        :uid => 'sAMAccountName',
-        :name_proc => Proc.new {|name| name.gsub(/@.*$/,'')}
-        :bind_dn => 'default_bind_dn'
-        :password => 'password'
-
-All of the listed options are required, with the exception of :name_proc, :bind_dn, and :password
-Allowed values of :method are: :plain, :ssl, :tls.
-
-:bind_dn and :password are used to perform the initial binding if user lookup is
-needed. If the user lookup returns result, the DN attribute from the result set is used
-to perform the final binding. This is needed only when the LDAP server requires 
-DN to be used for binding and you may only want user to using email or username
-in the login form.
-
-:uid is the LDAP attribute name for the user name in the login form. typically
-AD would be 'sAMAccountName' or 'UserPrincipalName', while OpenLDAP is 'uid'.
-You can also use 'dn', if your user choose the put in the dn in the login form
-(but usually is too long for user to remember or know).
-
-:name_proc allows you to match the user name entered with the format of the
-:uid attributes. For example, value of 'sAMAccountName' in AD contains only the
-windows user name. If your user prefers use email to login, a name_proc as
-above will trim the email string down to just the windows name. In summary,
-:name_proc helps you to fill the gap between the authentication and user lookup
-process.
- 
-:try_sasl and :sasl_mechanisms are optional. Use them to initialize a SASL
-connection to server. Allowed values are 'DIGEST-MD5' and 'GSS-SPNEGO'. If you
-are not familiar with these authentication methods, please just avoid them.
-
-Direct users to '/auth/ldap' to have them authenticated via your
-company's LDAP server.
-    
-== Multiple Strategies
-
-If you're using multiple strategies together, use OmniAuth's Builder. That's
-what it's there for:
-
-    require 'omniauth/enterprise'
-    require 'omniauth/oauth'  # for Campfire
-    require 'openid/store/filesystem'
-    
-    use OmniAuth::Builder do
-      provider :cas, :server => 'http://cas.mycompany.com/cas'
-      provider :campfire
-    end

data/oa-enterprise/Rakefile

@@ -1,6 +0,0 @@
-require 'bundler'
-Bundler::GemHelper.install_tasks
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec)
-task :default => :spec
-task :test => :spec

data/oa-enterprise/lib/oa-enterprise.rb

@@ -1 +0,0 @@
-require 'omniauth/enterprise'

data/oa-enterprise/lib/omniauth/enterprise.rb

@@ -1,8 +0,0 @@
-require 'omniauth/core'
-
-module OmniAuth
-  module Strategies
-    autoload :CAS, 'omniauth/strategies/cas'
-    autoload :LDAP, 'omniauth/strategies/ldap'
-  end
-end

data/oa-enterprise/lib/omniauth/strategies/cas/configuration.rb

@@ -1,98 +0,0 @@
-require 'rack'
-
-module OmniAuth
-  module Strategies
-    class CAS
-      class Configuration
-
-        DEFAULT_LOGIN_URL = "%s/login"
-
-        DEFAULT_SERVICE_VALIDATE_URL = "%s/serviceValidate"
-
-        # @param [Hash] params configuration options
-        # @option params [String, nil] :cas_server the CAS server root URL; probably something like
-        #         `http://cas.mycompany.com` or `http://cas.mycompany.com/cas`; optional.
-        # @option params [String, nil] :cas_login_url (:cas_server + '/login') the URL to which to
-        #         redirect for logins; options if `:cas_server` is specified,
-        #         required otherwise.
-        # @option params [String, nil] :cas_service_validate_url (:cas_server + '/serviceValidate') the
-        #         URL to use for validating service tickets; optional if `:cas_server` is
-        #         specified, requred otherwise.
-        # @option params [Boolean, nil] :disable_ssl_verification disable verification for SSL cert,
-        #         helpful when you developing with a fake cert.
-        def initialize(params)
-          parse_params params
-        end
-
-        # Build a CAS login URL from +service+.
-        #
-        # @param [String] service the service (a.k.a. return-to) URL
-        #
-        # @return [String] a URL like `http://cas.mycompany.com/login?service=...`
-        def login_url(service)
-          append_service @login_url, service
-        end
-
-        # Build a service-validation URL from +service+ and +ticket+.
-        # If +service+ has a ticket param, first remove it. URL-encode
-        # +service+ and add it and the +ticket+ as paraemters to the
-        # CAS serviceValidate URL.
-        #
-        # @param [String] service the service (a.k.a. return-to) URL
-        # @param [String] ticket the ticket to validate
-        #
-        # @return [String] a URL like `http://cas.mycompany.com/serviceValidate?service=...&ticket=...`
-        def service_validate_url(service, ticket)
-          service = service.sub(/[?&]ticket=[^?&]+/, '')
-          url = append_service(@service_validate_url, service)
-          url << '&ticket=' << Rack::Utils.escape(ticket)
-        end
-
-        def disable_ssl_verification?
-          @disable_ssl_verification
-        end
-
-        private
-
-        def parse_params(params)
-          if params[:cas_server].nil? && params[:cas_login_url].nil?
-            raise ArgumentError.new(":cas_server or :cas_login_url MUST be provided")
-          end
-          @login_url   = params[:cas_login_url]
-          @login_url ||= DEFAULT_LOGIN_URL % params[:cas_server]
-          validate_is_url 'login URL', @login_url
-
-          if params[:cas_server].nil? && params[:cas_service_validate_url].nil?
-            raise ArgumentError.new(":cas_server or :cas_service_validate_url MUST be provided")
-          end
-          @service_validate_url   = params[:cas_service_validate_url]
-          @service_validate_url ||= DEFAULT_SERVICE_VALIDATE_URL % params[:cas_server]
-          validate_is_url 'service-validate URL', @service_validate_url
-
-          @disable_ssl_verification = params[:disable_ssl_verification]
-        end
-
-        IS_NOT_URL_ERROR_MESSAGE = "%s is not a valid URL"
-
-        def validate_is_url(name, possibly_a_url)
-          url = URI.parse(possibly_a_url) rescue nil
-          raise ArgumentError.new(IS_NOT_URL_ERROR_MESSAGE % name) unless url.kind_of?(URI::HTTP)
-        end
-
-        # Adds +service+ as an URL-escaped parameter to +base+.
-        #
-        # @param [String] base the base URL
-        # @param [String] service the service (a.k.a. return-to) URL.
-        #
-        # @return [String] the new joined URL.
-        def append_service(base, service)
-          result = base.dup
-          result << (result.include?('?') ? '&' : '?')
-          result << 'service='
-          result << Rack::Utils.escape(service)
-        end
-
-      end
-    end
-  end
-end