omniauth 0.3.0.rc3 → 1.0.0.beta1

data/lib/omniauth/test/strategy_macros.rb

@@ -0,0 +1,34 @@
+module OmniAuth
+
+  module Test
+
+    module StrategyMacros
+
+      def sets_an_auth_hash
+        it 'should set an auth hash' do
+          last_request.env['omniauth.auth'].should be_kind_of(Hash)
+        end
+      end
+
+      def sets_provider_to(provider)
+        it "should set the provider to #{provider}" do
+          (last_request.env['omniauth.auth'] || {})['provider'].should == provider
+        end
+      end
+
+      def sets_uid_to(uid)
+        it "should set the UID to #{uid}" do
+          (last_request.env['omniauth.auth'] || {})['uid'].should == uid
+        end
+      end
+
+      def sets_user_info_to(user_info)
+        it "should set the user_info to #{user_info}" do
+          (last_request.env['omniauth.auth'] || {})['user_info'].should == user_info
+        end
+      end
+    end
+
+  end
+
+end

data/lib/omniauth/test/strategy_test_case.rb

@@ -0,0 +1,49 @@
+require 'rack'
+require 'omniauth/test'
+
+module OmniAuth
+
+  module Test
+
+    # Support for testing OmniAuth strategies.
+    #
+    # @example Usage
+    #   class MyStrategyTest < Test::Unit::TestCase
+    #     include OmniAuth::Test::StrategyTestCase
+    #     def strategy
+    #       # return the parameters to a Rack::Builder map call:
+    #       [MyStrategy.new, :some, :configuration, :options => 'here']
+    #     end
+    #     setup do
+    #       post '/auth/my_strategy/callback', :user => { 'name' => 'Dylan', 'id' => '445' }
+    #     end
+    #   end
+    module StrategyTestCase
+
+      def app
+        strat = self.strategy
+        resp = self.app_response
+        Rack::Builder.new {
+          use OmniAuth::Test::PhonySession
+          use *strat
+          run lambda {|env| [404, {'Content-Type' => 'text/plain'}, [resp || env.key?('omniauth.auth').to_s]] }
+        }.to_app
+      end
+
+      def app_response
+        nil
+      end
+
+      def session
+        last_request.env['rack.session']
+      end
+
+      def strategy
+        raise NotImplementedError.new('Including specs must define #strategy')
+      end
+
+    end
+
+  end
+
+end

data/lib/omniauth/test.rb

@@ -0,0 +1,12 @@
+module OmniAuth
+
+  # Support for testing OmniAuth strategies.
+  module Test
+
+    autoload :PhonySession,     'omniauth/test/phony_session'
+    autoload :StrategyMacros,   'omniauth/test/strategy_macros'
+    autoload :StrategyTestCase, 'omniauth/test/strategy_test_case'
+
+  end
+
+end

data/lib/omniauth/version.rb

@@ -1,19 +1,3 @@
 module OmniAuth
-  module Version
-    unless defined?(::OmniAuth::Version::MAJOR)
-      MAJOR = 0
-    end
-    unless defined?(::OmniAuth::Version::MINOR)
-      MINOR = 3
-    end
-    unless defined?(::OmniAuth::Version::PATCH)
-      PATCH = 0
-    end
-    unless defined?(::OmniAuth::Version::PRE)
-      PRE   = "rc3"
-    end
-    unless defined?(::OmniAuth::Version::STRING)
-      STRING = [MAJOR, MINOR, PATCH, PRE].compact.join('.')
-    end
-  end
+  VERSION = "1.0.0.beta1"
 end

data/lib/omniauth.rb

@@ -1,6 +1,137 @@
-require 'omniauth/core'
-require 'omniauth/basic'
-require 'omniauth/oauth'
-require 'omniauth/openid'
-require 'omniauth/enterprise'
-require 'omniauth/more'
+require 'rack'
+require 'singleton'
+
+module OmniAuth
+  module Strategies
+    autoload :Developer, 'omniauth/strategies/developer'
+  end
+
+  autoload :Builder,  'omniauth/builder'
+  autoload :Strategy, 'omniauth/strategy'
+  autoload :Test,     'omniauth/test'
+  autoload :Form,     'omniauth/form'
+  autoload :AuthHash, 'omniauth/auth_hash'
+
+  def self.strategies
+    @@strategies ||= []
+  end
+
+  class Configuration
+    include Singleton
+
+    @@defaults = {
+      :camelizations => {},
+      :path_prefix => '/auth',
+      :on_failure => Proc.new do |env|
+        message_key = env['omniauth.error.type']
+        new_path = "#{OmniAuth.config.path_prefix}/failure?message=#{message_key}"
+        [302, {'Location' => new_path, 'Content-Type'=> 'text/html'}, []]
+      end,
+      :form_css => Form::DEFAULT_CSS,
+      :test_mode => false,
+      :allowed_request_methods => [:get, :post],
+      :mock_auth => {
+        :default => {
+          'provider' => 'default',
+          'uid' => '1234',
+          'name' => 'Bob Example'
+        }
+      }
+    }
+
+    def self.defaults
+      @@defaults
+    end
+
+    def initialize
+      @@defaults.each_pair{|k,v| self.send("#{k}=",v)}
+    end
+
+    def on_failure(&block)
+      if block_given?
+        @on_failure = block
+      else
+        @on_failure
+      end
+    end
+
+    def add_mock(provider, mock={})
+      # Stringify keys recursively one level.
+      mock.keys.each do |key|
+        mock[key.to_s] = mock.delete(key)
+      end
+      mock.each_pair do |key, val|
+        if val.is_a? Hash
+          val.keys.each do |subkey|
+            val[subkey.to_s] = val.delete(subkey)
+          end
+        end
+      end
+
+      # Merge with the default mock and ensure provider is correct.
+      mock = self.mock_auth[:default].dup.merge(mock)
+      mock["provider"] = provider.to_s
+
+      # Add it to the mocks.
+      self.mock_auth[provider.to_sym] = mock
+    end
+
+    # This is a convenience method to be used by strategy authors
+    # so that they can add special cases to the camelization utility
+    # method that allows OmniAuth::Builder to work.
+    #
+    # @param name [String] The underscored name, e.g. `oauth`
+    # @param camelized [String] The properly camelized name, e.g. 'OAuth'
+    def add_camelization(name, camelized)
+      self.camelizations[name.to_s] = camelized.to_s
+    end
+
+    attr_writer :on_failure
+    attr_accessor :path_prefix, :allowed_request_methods, :form_css, :test_mode, :mock_auth, :full_host, :camelizations
+  end
+
+  def self.config
+    Configuration.instance
+  end
+
+  def self.configure
+    yield config
+  end
+
+  def self.mock_auth_for(provider)
+    config.mock_auth[provider.to_sym] || config.mock_auth[:default]
+  end
+
+  module Utils
+    module_function
+
+    def form_css
+      "<style type='text/css'>#{OmniAuth.config.form_css}</style>"
+    end
+
+    def deep_merge(hash, other_hash)
+      target = hash.dup
+
+      other_hash.keys.each do |key|
+        if other_hash[key].is_a? ::Hash and hash[key].is_a? ::Hash
+          target[key] = deep_merge(target[key],other_hash[key])
+          next
+        end
+
+        target[key] = other_hash[key]
+      end
+
+      target
+    end
+
+    def camelize(word, first_letter_in_uppercase = true)
+      return OmniAuth.config.camelizations[word.to_s] if OmniAuth.config.camelizations[word.to_s]
+
+      if first_letter_in_uppercase
+        word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+      else
+        word.first + camelize(word)[1..-1]
+      end
+    end
+  end
+end

data/omniauth.gemspec

@@ -0,0 +1,28 @@
+# encoding: utf-8
+require File.expand_path('../lib/omniauth/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name = 'omniauth'
+  gem.description = %q{A generalized Rack framework for multiple-provider authentication.}
+  gem.authors = ['Michael Bleigh', 'Erik Michaels-Ober']
+  gem.email = ['michael@intridea.com', 'sferik@gmail.com']
+
+  gem.add_runtime_dependency 'rack'
+  gem.add_runtime_dependency 'hashie', '~> 1.2'
+
+  gem.add_development_dependency 'maruku', '~> 0.6'
+  gem.add_development_dependency 'simplecov', '~> 0.4'
+  gem.add_development_dependency 'rack-test', '~> 0.5'
+  gem.add_development_dependency 'rake', '~> 0.8'
+  gem.add_development_dependency 'rdiscount', '~> 1.6'
+  gem.add_development_dependency 'rspec', '~> 2.5'
+  gem.add_development_dependency 'yard', '~> 0.7'
+
+  gem.version = OmniAuth::VERSION
+  gem.files = `git ls-files`.split("\n")
+  gem.homepage = 'http://github.com/intridea/omniauth'
+  gem.require_paths = ['lib']
+  gem.required_rubygems_version = Gem::Requirement.new('>= 1.3.6') if gem.respond_to? :required_rubygems_version=
+  gem.summary = gem.description
+  gem.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+end

data/spec/omniauth/auth_hash_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe OmniAuth::AuthHash do
+  subject{ OmniAuth::AuthHash.new }
+  it 'should convert a supplied info key into an InfoHash object' do
+    subject.info = {:first_name => 'Awesome'}
+    subject.info.should be_kind_of(OmniAuth::AuthHash::InfoHash)
+    subject.info.first_name.should == 'Awesome'
+  end
+
+  describe '#valid?' do
+    subject{ OmniAuth::AuthHash.new(:uid => '123', :provider => 'example', :info => {:name => 'Steven'}) }
+
+    it 'should be valid with the right parameters' do
+      subject.should be_valid
+    end
+
+    it 'should require a uid' do
+      subject.uid = nil
+      subject.should_not be_valid
+    end
+
+    it 'should require a provider' do
+      subject.provider = nil
+      subject.should_not be_valid
+    end
+
+    it 'should require a name in the user info hash' do
+      subject.info.name = nil
+      subject.should_not be_valid?
+    end
+  end
+
+  describe '#name' do
+    subject{ OmniAuth::AuthHash.new(
+      :info => {
+        :name => 'Phillip J. Fry',
+        :first_name => 'Phillip',
+        :last_name => 'Fry',
+        :nickname => 'meatbag',
+        :email => 'fry@planetexpress.com'
+    })}
+
+    it 'should default to the name key' do
+      subject.info.name.should == 'Phillip J. Fry'
+    end
+
+    it 'should fall back to go to first_name last_name concatenation' do
+      subject.info.name = nil
+      subject.info.name.should == 'Phillip Fry'
+    end
+
+    it 'should display only a first or last name if only that is available' do
+      subject.info.name = nil
+      subject.info.first_name = nil
+      subject.info.name.should == 'Fry'
+    end
+
+    it 'should display the nickname if no name, first, or last is available' do
+      subject.info.name = nil
+      %w(first_name last_name).each{|k| subject.info[k] = nil}
+      subject.info.name.should == 'meatbag'
+    end
+
+    it 'should display the email if no name, first, last, or nick is available' do
+      subject.info.name = nil
+      %w(first_name last_name nickname).each{|k| subject.info[k] = nil}
+      subject.info.name.should == 'fry@planetexpress.com'
+    end
+  end
+
+  describe '#to_hash' do
+    subject{ OmniAuth::AuthHash.new(:uid => '123', :provider => 'test', :name => 'Bob Example')}
+    let(:hash){ subject.to_hash }
+
+    it 'should be a plain old hash' do
+      hash.class.should == ::Hash
+    end
+
+    it 'should have string keys' do
+      hash.keys.should be_include('uid')
+    end
+
+    it 'should convert an info hash as well' do
+      subject.info = {:first_name => 'Bob', :last_name => 'Example'}
+      subject.info.class.should == OmniAuth::AuthHash::InfoHash
+      subject.to_hash['info'].class.should == ::Hash
+    end
+
+    it 'should supply the calculated name in the converted hash' do
+      subject.info = {:first_name => 'Bob', :last_name => 'Examplar'}
+      hash['info']['name'].should == 'Bob Examplar'
+    end
+
+    it 'should not pollute the URL hash with "name" etc' do
+      subject.info = {'urls' => {'Homepage' => "http://homepage.com"}}
+      subject.to_hash['info']['urls'].should == {'Homepage' => "http://homepage.com"}
+    end
+  end
+
+  describe OmniAuth::AuthHash::InfoHash do
+    describe '#valid?' do
+      it 'should be valid if there is a name' do
+        OmniAuth::AuthHash::InfoHash.new(:name => 'Awesome').should be_valid
+      end
+    end
+  end
+end

data/spec/omniauth/builder_spec.rb

@@ -0,0 +1,20 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe OmniAuth::Builder do
+  describe '#provider' do
+    it 'should translate a symbol to a constant' do
+      OmniAuth::Strategies.should_receive(:const_get).with('MyStrategy').and_return(Class.new)
+      OmniAuth::Builder.new(nil) do
+        provider :my_strategy
+      end
+    end
+
+    it 'should also just accept a class' do
+      class ::ExampleClass; end
+
+      lambda{ OmniAuth::Builder.new(nil) do
+        provider ::ExampleClass
+      end }.should_not raise_error
+    end
+  end
+end

data/spec/omniauth/strategies/developer_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe OmniAuth::Strategies::Developer do
+  let(:app){ Rack::Builder.new do |b|
+    b.use Rack::Session::Cookie
+    b.use OmniAuth::Strategies::Developer
+    b.run lambda{|env| [200, {}, ['Not Found']]}
+  end.to_app }
+
+  context 'request phase' do
+    before(:each){ get '/auth/developer' }
+
+    it 'should display a form' do
+      last_response.status.should == 200
+      last_response.body.should be_include("<form")
+    end
+
+    it 'should have the callback as the action for the form' do
+      last_response.body.should be_include("action='/auth/developer/callback'")
+    end
+
+    it 'should have a text field for each of the fields' do
+      last_response.body.scan('<input').size.should == 2
+    end
+  end
+
+  context 'callback phase' do
+    let(:auth_hash){ last_request.env['omniauth.auth'] }
+
+    context 'with default options' do
+      before do
+        post '/auth/developer/callback', :name => 'Example User', :email => 'user@example.com'
+      end
+
+      it 'should set the name in the auth hash' do
+        auth_hash.info.name.should == 'Example User'
+      end
+
+      it 'should set the email in the auth hash' do
+        auth_hash.info.email.should == 'user@example.com'
+      end
+
+      it 'should set the uid to the email' do
+        auth_hash.uid.should == 'user@example.com'
+      end
+    end
+
+    context 'with custom options' do
+      let(:app){ Rack::Builder.new do |b|
+        b.use Rack::Session::Cookie
+        b.use OmniAuth::Strategies::Developer, :fields => [:first_name, :last_name], :uid_field => :last_name
+        b.run lambda{|env| [200, {}, ['Not Found']]}
+      end.to_app }
+
+      before do
+        @options = {:uid_field => :last_name, :fields => [:first_name, :last_name]}
+        post '/auth/developer/callback', :first_name => 'Example', :last_name => 'User'
+      end
+
+      it 'should set info fields properly' do
+        auth_hash.info.name.should == 'Example User'
+      end
+
+      it 'should set the uid properly' do
+        auth_hash.uid.should == 'User'
+      end
+    end
+  end
+end