omniauth-rightsignature 0.0.1 → 0.0.2

data/lib/omniauth/test.rb

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,3 @@
+module OmniAuth
+  VERSION = '1.2.2'
+end

data/lib/omniauth-rightsignature.rb

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

data/lib/omniauth.rb

@@ -0,0 +1,170 @@
+require 'rack'
+require 'singleton'
+require 'logger'
+
+module OmniAuth
+  class Error < StandardError; end
+
+  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'
+  autoload :FailureEndpoint, 'omniauth/failure_endpoint'
+
+  def self.strategies
+    @strategies ||= []
+  end
+
+  class Configuration
+    include Singleton
+
+    def self.default_logger
+      logger = Logger.new(STDOUT)
+      logger.progname = 'omniauth'
+      logger
+    end
+
+    def self.defaults
+      @defaults ||= {
+        :camelizations => {},
+        :path_prefix => '/auth',
+        :on_failure => OmniAuth::FailureEndpoint,
+        :failure_raise_out_environments => ['development'],
+        :before_request_phase   => nil,
+        :before_callback_phase  => nil,
+        :before_options_phase   => nil,
+        :form_css => Form::DEFAULT_CSS,
+        :test_mode => false,
+        :logger => default_logger,
+        :allowed_request_methods => [:get, :post],
+        :mock_auth => {:default => AuthHash.new('provider' => 'default', 'uid' => '1234', 'info' => {'name' => 'Example User'})},
+      }
+    end
+
+    def initialize
+      self.class.defaults.each_pair { |k, v| send("#{k}=", v) }
+    end
+
+    def on_failure(&block)
+      if block_given?
+        @on_failure = block
+      else
+        @on_failure
+      end
+    end
+
+    def before_callback_phase(&block)
+      if block_given?
+        @before_callback_phase = block
+      else
+        @before_callback_phase
+      end
+    end
+
+    def before_options_phase(&block)
+      if block_given?
+        @before_options_phase = block
+      else
+        @before_options_phase
+      end
+    end
+
+    def before_request_phase(&block)
+      if block_given?
+        @before_request_phase = block
+      else
+        @before_request_phase
+      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
+        else
+          next
+        end
+      end
+
+      # Merge with the default mock and ensure provider is correct.
+      mock = mock_auth[:default].dup.merge(mock)
+      mock['provider'] = provider.to_s
+
+      # Add it to the mocks.
+      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)
+      camelizations[name.to_s] = camelized.to_s
+    end
+
+    attr_writer :on_failure, :before_callback_phase, :before_options_phase, :before_request_phase
+    attr_accessor :failure_raise_out_environments, :path_prefix, :allowed_request_methods, :form_css, :test_mode, :mock_auth, :full_host, :camelizations, :logger
+  end
+
+  def self.config
+    Configuration.instance
+  end
+
+  def self.configure
+    yield config
+  end
+
+  def self.logger
+    config.logger
+  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) && 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(/\/(.?)/) { '::' + Regexp.last_match[1].upcase }.gsub(/(^|_)(.)/) { Regexp.last_match[2].upcase }
+      else
+        word.first + camelize(word)[1..-1]
+      end
+    end
+  end
+end

data/omniauth-rightsignature.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+require File.expand_path('../lib/omniauth/rightsignature/version', __FILE__)
+
+
+Gem::Specification.new do |gem|
+gem.name = 'omniauth-rightsignature'
+gem.version = OmniAuth::Rightsignature::VERSION
+gem.homepage = 'https://github.com/DeepikaaSubramaniam21/omniauth-rightsignature/'
+gem.author = "Deepikaa Subramaniam"
+gem.email = 'deepikaa.subramaniam@citrix.com'
+gem.description = 'RightSignature strategy for OmniAuth 1.0'
+gem.summary = gem.description
+gem.add_dependency "omniauth-oauth", "~> 1.0"
+gem.add_development_dependency 'rake', '~> 0.9'
+gem.add_development_dependency 'rdiscount', '~> 1.6'
+gem.add_development_dependency 'rspec', '~> 2.7'
+gem.add_development_dependency 'simplecov', '~> 0.5'
+gem.add_development_dependency 'yard', '~> 0.7'
+gem.add_development_dependency 'webmock', '~> 1.7'
+gem.executables = `git ls-files -- bin/*`.split("\n").map{|f| File.basename(f)}
+gem.files = `git ls-files`.split("\n")
+#gem.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+gem.require_paths = ['lib']
+end

data/spec/helper.rb

@@ -0,0 +1,55 @@
+if RUBY_VERSION >= '1.9'
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatters = [SimpleCov::Formatter::HTMLFormatter, Coveralls::SimpleCov::Formatter]
+
+  SimpleCov.start do
+    add_filter '/spec'
+    minimum_coverage(93.05)
+  end
+end
+
+require 'rspec'
+require 'rack/test'
+require 'omniauth'
+require 'omniauth/test'
+
+OmniAuth.config.logger = Logger.new('/dev/null')
+
+RSpec.configure do |config|
+  config.include Rack::Test::Methods
+  config.extend OmniAuth::Test::StrategyMacros, :type => :strategy
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end
+
+class ExampleStrategy
+  include OmniAuth::Strategy
+  attr_reader :last_env
+  option :name, 'test'
+
+  def call(env)
+    self.call!(env)
+  end
+
+  def initialize(*args, &block)
+    super
+    @fail = nil
+  end
+
+  def request_phase
+    @fail = fail!(options[:failure]) if options[:failure]
+    @last_env = env
+    return @fail if @fail
+    fail('Request Phase')
+  end
+
+  def callback_phase
+    @fail = fail!(options[:failure]) if options[:failure]
+    @last_env = env
+    return @fail if @fail
+    fail('Callback Phase')
+  end
+end

data/spec/omniauth/auth_hash_spec.rb

@@ -0,0 +1,109 @@
+require 'helper'
+
+describe OmniAuth::AuthHash do
+  subject { OmniAuth::AuthHash.new }
+  it 'converts a supplied info key into an InfoHash object' do
+    subject.info = {:first_name => 'Awesome'}
+    expect(subject.info).to be_kind_of(OmniAuth::AuthHash::InfoHash)
+    expect(subject.info.first_name).to eq('Awesome')
+  end
+
+  describe '#valid?' do
+    subject { OmniAuth::AuthHash.new(:uid => '123', :provider => 'example', :info => {:name => 'Steven'}) }
+
+    it 'is valid with the right parameters' do
+      expect(subject).to be_valid
+    end
+
+    it 'requires a uid' do
+      subject.uid = nil
+      expect(subject).not_to be_valid
+    end
+
+    it 'requires a provider' do
+      subject.provider = nil
+      expect(subject).not_to be_valid
+    end
+
+    it 'requires a name in the user info hash' do
+      subject.info.name = nil
+      expect(subject).not_to be_valid
+    end
+  end
+
+  describe '#name' do
+    subject do
+      OmniAuth::AuthHash.new(:info => {
+                               :name => 'Phillip J. Fry',
+                               :first_name => 'Phillip',
+                               :last_name => 'Fry',
+                               :nickname => 'meatbag',
+                               :email => 'fry@planetexpress.com',
+                             })
+    end
+
+    it 'defaults to the name key' do
+      expect(subject.info.name).to eq('Phillip J. Fry')
+    end
+
+    it 'falls back to go to first_name last_name concatenation' do
+      subject.info.name = nil
+      expect(subject.info.name).to eq('Phillip Fry')
+    end
+
+    it 'displays only a first or last name if only that is available' do
+      subject.info.name = nil
+      subject.info.first_name = nil
+      expect(subject.info.name).to eq('Fry')
+    end
+
+    it 'displays 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 }
+      expect(subject.info.name).to eq('meatbag')
+    end
+
+    it 'displays 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 }
+      expect(subject.info.name).to eq('fry@planetexpress.com')
+    end
+  end
+
+  describe '#to_hash' do
+    subject { OmniAuth::AuthHash.new(:uid => '123', :provider => 'test', :name => 'Example User') }
+    let(:hash) { subject.to_hash }
+
+    it 'is a plain old hash' do
+      expect(hash.class).to eq(::Hash)
+    end
+
+    it 'has string keys' do
+      expect(hash.keys).to be_include('uid')
+    end
+
+    it 'converts an info hash as well' do
+      subject.info = {:first_name => 'Example', :last_name => 'User'}
+      expect(subject.info.class).to eq(OmniAuth::AuthHash::InfoHash)
+      expect(subject.to_hash['info'].class).to eq(::Hash)
+    end
+
+    it 'supplies the calculated name in the converted hash' do
+      subject.info = {:first_name => 'Examplar', :last_name => 'User'}
+      expect(hash['info']['name']).to eq('Examplar User')
+    end
+
+    it "does not pollute the URL hash with 'name' etc" do
+      subject.info = {'urls' => {'Homepage' => 'http://homepage.com'}}
+      expect(subject.to_hash['info']['urls']).to eq('Homepage' => 'http://homepage.com')
+    end
+  end
+
+  describe OmniAuth::AuthHash::InfoHash do
+    describe '#valid?' do
+      it 'is valid if there is a name' do
+        expect(OmniAuth::AuthHash::InfoHash.new(:name => 'Awesome')).to be_valid
+      end
+    end
+  end
+end

data/spec/omniauth/builder_spec.rb

@@ -0,0 +1,50 @@
+require 'helper'
+
+describe OmniAuth::Builder do
+  describe '#provider' do
+    it 'translates a symbol to a constant' do
+      expect(OmniAuth::Strategies).to receive(:const_get).with('MyStrategy').and_return(Class.new)
+      OmniAuth::Builder.new(nil) do
+        provider :my_strategy
+      end
+    end
+
+    it 'accepts a class' do
+      class ExampleClass; end
+
+      expect do
+        OmniAuth::Builder.new(nil) do
+          provider ::ExampleClass
+        end
+      end.not_to raise_error
+    end
+
+    it "raises a helpful LoadError message if it can't find the class" do
+      expect do
+        OmniAuth::Builder.new(nil) do
+          provider :lorax
+        end
+      end.to raise_error(LoadError, 'Could not find matching strategy for :lorax. You may need to install an additional gem (such as omniauth-lorax).')
+    end
+  end
+
+  describe '#options' do
+    it 'merges provided options in' do
+      k = Class.new
+      b = OmniAuth::Builder.new(nil)
+      expect(b).to receive(:use).with(k, :foo => 'bar', :baz => 'tik')
+
+      b.options :foo => 'bar'
+      b.provider k, :baz => 'tik'
+    end
+
+    it 'adds an argument if no options are provided' do
+      k = Class.new
+      b = OmniAuth::Builder.new(nil)
+      expect(b).to receive(:use).with(k, :foo => 'bar')
+
+      b.options :foo => 'bar'
+      b.provider k
+    end
+  end
+end

data/spec/omniauth/failure_endpoint_spec.rb

@@ -0,0 +1,58 @@
+require 'helper'
+
+describe OmniAuth::FailureEndpoint do
+  subject { OmniAuth::FailureEndpoint }
+
+  context 'raise-out environment' do
+    before do
+      @rack_env = ENV['RACK_ENV']
+      ENV['RACK_ENV'] = 'test'
+
+      @default = OmniAuth.config.failure_raise_out_environments
+      OmniAuth.config.failure_raise_out_environments = ['test']
+    end
+
+    it 'raises out the error' do
+      expect do
+        subject.call('omniauth.error' => StandardError.new('Blah'))
+      end.to raise_error(StandardError, 'Blah')
+    end
+
+    it 'raises out an OmniAuth::Error if no omniauth.error is set' do
+      expect { subject.call('omniauth.error.type' => 'example') }.to raise_error(OmniAuth::Error, 'example')
+    end
+
+    after do
+      ENV['RACK_ENV'] = @rack_env
+      OmniAuth.config.failure_raise_out_environments = @default
+    end
+  end
+
+  context 'non-raise-out environment' do
+    let(:env) do
+      {'omniauth.error.type' => 'invalid_request', 'omniauth.error.strategy' => ExampleStrategy.new({})}
+    end
+
+    it 'is a redirect' do
+      status, _, _ = *subject.call(env)
+      expect(status).to eq(302)
+    end
+
+    it 'includes the SCRIPT_NAME' do
+      _, head, _ = *subject.call(env.merge('SCRIPT_NAME' => '/random'))
+      expect(head['Location']).to eq('/random/auth/failure?message=invalid_request&strategy=test')
+    end
+
+    it 'respects the configured path prefix' do
+      allow(OmniAuth.config).to receive(:path_prefix).and_return('/boo')
+      _, head, _ = *subject.call(env)
+      expect(head['Location']).to eq('/boo/failure?message=invalid_request&strategy=test')
+    end
+
+    it 'includes the origin (escaped) if one is provided' do
+      env.merge! 'omniauth.origin' => '/origin-example'
+      _, head, _ = *subject.call(env)
+      expect(head['Location']).to be_include('&origin=%2Forigin-example')
+    end
+  end
+end