omniauth-elitmus 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5a61135ea30aa7e31fee8b6148f523528ce3b1f2
+  data.tar.gz: d67c251b4c8919dac678f917bf7b3d5549999169
+SHA512:
+  metadata.gz: 36a77f728fffc6a111902dff01b54c7158626e4516c74d400fa9df58266d0a6fd799f4185f5369471624060c0487327e4b803f593d068a4012f73e362f353046
+  data.tar.gz: f9d7de27c351439796d13a6327e0df586873158e857cbeded5d2a07334ace85fb8c05d4919b8773c171d3cabe2d5e14fcf77f9ae6a26fcb64e3ad153b2f1e468

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.DS_Store

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 2.1.5
+  - ruby-head
+  - jruby-head
+  - rbx-2
+script: CODECLIMATE_REPO_TOKEN=839fe72d55965fb683962d15badc954d2723d28f3cddde142cd75a55e6bf9580 ruby -I./test ./test/test.rb

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ..gemspec
+gemspec
+
+platforms :rbx do
+  gem 'rubysl', '~> 2.0'
+end
+
+gem "codeclimate-test-reporter", group: :test, require: nil

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Shrey Patel
+
+MIT License
+
+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/README.md

@@ -0,0 +1,126 @@
+# Omniauth Elitmus
+
+[![Build Status](https://travis-ci.org/elitmus/omniauth-elitmus.svg?branch=master)](https://travis-ci.org/elitmus/omniauth-elitmus)
+
+[![Code Climate](https://codeclimate.com/github/elitmus/omniauth-elitmus/badges/gpa.svg)](https://codeclimate.com/github/elitmus/omniauth-elitmus)
+
+[![Test Coverage](https://codeclimate.com/github/elitmus/omniauth-elitmus/badges/coverage.svg)](https://codeclimate.com/github/elitmus/omniauth-elitmus)
+
+[![Gem Version](https://badge.fury.io/rb/omniauth-elitmus.svg)](http://badge.fury.io/rb/omniauth-elitmus)
+
+## eLitmus OAuth2 Strategy for OmniAuth
+
+This is official OmniAuth strategy for authenticating to eLitmus.com. To use it, you'll need to register your consumer application on elitmus.com to get pair of OAuth2 Application ID and Secret.   It supports the OAuth 2.0 server-side and client-side flows for 3rd party OAuth consumer applications 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'omniauth-elitmus'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install omniauth-elitmus
+
+## Usage
+
+OmniAuth::Strategies::Elitmus is simply a Rack middleware.
+
+ First, register your application at 'www.elitmus.com/oauth/applications' with valid callback url to get app_id and secret (elitmus.com uses callback url to redirect to your app). Create environement variables 'ELITMUS_KEY', 'ELITMUS_SECRET' to store your app_id, secret respectively. Here's a quick example, adding the middleware to a Rails app in config/initializers/omniauth.rb.
+
+
+```ruby
+Rails.application.config.middleware.use OmniAuth::Builder do
+  provider :elitmus, ENV['ELITMUS_KEY'], ENV['ELITMUS_SECRET']
+end
+```
+
+## Configuration
+
+You can configure several options, which you can pass in to the `provider` method via a `Hash`. also refer 'Examples' section accordingly.
+
+Option name | Default | Explanation
+--- | --- | ---
+`scope` | `public` | lets you set scope to provide granular access to different types of data. If not provided, scope defaults to 'public' for users. you can use any one of "write", "public" and "admin" values for scope.
+`auth_type` | nil | Optionally specifies the requested authentication feature. Valid value is 'reauthenticate' (asks the user to re-authenticate unconditionally). If not specified, default value is nil. (reuses the existing session of last authenticated user if any).
+`callback_path` | '/auth/:provider/callback' | Specify a custom callback URL used during the server-side flow. Note this must be same as specified at the time of your applicaiton registration at www.elitmus.com/oauth/applications. Execution flow returns back to this point at consumer application after authencitcation flow finishes at server-side. If not specified, default is '/auth/:provider/callback'. Make an entry for this end point in config/routes.rb of your consumer application. Strategy automatically replaces ':provider' by provider name as specified in config/initializers/omniauth.rb.
+
+### Examples 
+
+#### scope
+
+```ruby
+Rails.application.config.middleware.use OmniAuth::Builder do
+  provider :elitmus, ENV['ELITMUS_KEY'], ENV['ELITMUS_SECRET'], { :scope => "admin" }
+end
+```
+If not specified, default scope is 'public'
+
+#### auth_type
+
+```ruby
+Rails.application.config.middleware.use OmniAuth::Builder do
+  provider :elitmus, ENV['ELITMUS_KEY'], ENV['ELITMUS_SECRET'], 
+  		{ :scope => "admin", :authorize_params => { :auth_type => "reauthenticate" }}
+end
+```
+If not specified, default is nil.
+
+#### callback_path
+
+```ruby
+Rails.application.config.middleware.use OmniAuth::Builder do
+  provider :elitmus, ENV['ELITMUS_KEY'], ENV['ELITMUS_SECRET'], 
+      { :scope => "admin", :authorize_params => { :auth_type => "reauthenticate" }, 
+        :callback_path => '/your/custom/callback/path'}
+end
+```
+If not specified, default callback_path is '/auth/:provider/callback'.Here, finally it would be '/auth/elitmus/callback' as per explained in configuration table.
+
+## Auth Hash
+
+Here's an example *Auth Hash* available in `request.env['omniauth.auth']`:
+
+```ruby
+{
+  :provider => 'elitmus',
+  :uid => '98979695',
+  :info => {
+    :email => 'kishoredaa@evergreen.com',
+    :name => 'Kishore Kumar'
+  },
+  :credentials => {
+    :token => 'ABCDEF...', # OAuth 2.0 access_token, which you may wish to store
+    :expires_at => 1321747205, # when the access token expires (it always will)
+    :expires => true # this will always be true
+  },
+  :extra => {
+    :raw_info => {
+      :id => '98979695',
+      :channel => 'Through a friend',
+      :email => 'kishoredaa@evergreen.com',
+      :name => 'Kishore Kumar'
+      :email_lower => 'kishoredaa@evergreen.com',
+      :first_login => 'Y',
+      :registered_on => '2012-01-17T00:37:29+05:30',
+      :source_campus => '0',
+      :status => 'active'
+    }
+  }
+}
+```
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/omniauth-elitmus/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/omniauth-elitmus.rb

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

data/lib/omniauth/elitmus.rb

@@ -0,0 +1,2 @@
+require 'omniauth/elitmus/version'
+require 'omniauth/strategies/elitmus'

data/lib/omniauth/elitmus/version.rb

@@ -0,0 +1,5 @@
+module Omniauth
+  module Elitmus
+    VERSION = "0.0.3"
+  end
+end

data/lib/omniauth/strategies/elitmus.rb

@@ -0,0 +1,61 @@
+require 'omniauth/strategies/oauth2'
+require 'uri'
+
+module OmniAuth
+	module Strategies
+		class Elitmus < OmniAuth::Strategies::OAuth2
+			# class NoAuthorizationCodeError < StandardError; en				
+			DEFAULT_SCOPE = 'public'
+
+			#OATUH2_PROVIDER_URL = "https://www.elitmus.com"
+			option :name, :elitmus
+
+			option :client_options, {
+				:site => "https://www.elitmus.com"
+			}
+
+			option :authorize_options, [:scope, :auth_type]
+
+			uid {  raw_info['id']  }
+		
+			info do
+				prune!({
+					'email' => raw_info['email'],
+					'name' => raw_info['name']
+			 	})
+			end
+
+			extra do 
+				hash = {}
+      			hash['raw_info'] = raw_info unless skip_info?
+        		prune! hash
+			end 
+
+			def raw_info
+				@raw_info ||= access_token.get('/api/v1/me').parsed
+			end
+
+			def authorize_params
+				super.tap do |params|
+					%w[scope auth_type].each do |v|
+							if request.params[v]
+								params[v.to_sym] = request.params[v]
+							end
+					end
+					params[:scope] ||= DEFAULT_SCOPE
+				end
+			end	
+
+			def callback_url
+				options[:callback_url] || super
+			end
+
+			def prune!(hash)
+				hash.delete_if do |_, value|
+					prune!(value) if value.is_a?(Hash)
+					value.nil? || (value.respond_to?(:empty?) && value.empty?)
+        		end
+     		end
+		end
+	end
+end

data/omniauth-elitmus.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+$:.push File.expand_path('../lib', __FILE__)
+require 'omniauth/elitmus/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "omniauth-elitmus"
+  spec.version       = Omniauth::Elitmus::VERSION
+  spec.authors       = ["Shrey Patel","Shireesh Jayashetty"]
+  spec.email         = ["aws@elitmus.com"]
+  spec.summary       = 'eLitmus OAuth2 Strategy for OmniAuth'
+  spec.homepage      = "https://github.com/elitmus/omniauth-elitmus"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split("\n")
+  spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  spec.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'omniauth-oauth2', '~> 1.2'
+
+  spec.add_development_dependency 'minitest', '~> 5.5.1'
+  spec.add_development_dependency 'mocha', '~>1.1.0'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'simplecov'
+end

data/test/helper.rb

@@ -0,0 +1,62 @@
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'mocha/setup'
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+require 'simplecov'
+SimpleCov.start
+
+require 'omniauth/strategies/elitmus'
+
+OmniAuth.config.test_mode = true
+
+module BlockTestHelper
+  def test(name, &blk)
+    method_name = "test_#{name.gsub(/\s+/, '_')}"
+    raise "Method already defined: #{method_name}" if instance_methods.include?(method_name.to_sym)
+    define_method method_name, &blk
+  end
+end
+
+module CustomAssertions
+  def assert_has_key(key, hash, msg = nil)
+    msg = message(msg) { "Expected #{hash.inspect} to have key #{key.inspect}" }
+    assert hash.has_key?(key), msg
+  end
+
+  def refute_has_key(key, hash, msg = nil)
+    msg = message(msg) { "Expected #{hash.inspect} not to have key #{key.inspect}" }
+    refute hash.has_key?(key), msg
+  end
+end
+
+class TestCase < Minitest::Test
+  extend BlockTestHelper
+  include CustomAssertions
+end
+
+class StrategyTestCase < TestCase
+  def setup
+    @request = stub('Request')
+    @request.stubs(:params).returns({})
+    @request.stubs(:cookies).returns({})
+    @request.stubs(:env).returns({})
+    @request.stubs(:scheme).returns('http')
+    @request.stubs(:ssl?).returns(false)
+
+    @client_id = '123'
+    @client_secret = '53cr3tz'
+  end
+
+  def strategy
+    @strategy ||= begin
+      args = [@client_id, @client_secret, @options].compact
+      OmniAuth::Strategies::Elitmus.new(nil, *args).tap do |strategy|
+        strategy.stubs(:request).returns(@request)
+      end
+    end
+  end
+end
+
+Dir[File.expand_path('../support/**/*', __FILE__)].each &method(:require)

data/test/support/shared_example.rb

@@ -0,0 +1,85 @@
+# NOTE it would be useful if this lived in omniauth-oauth2 eventually
+module OAuth2StrategyTests
+  def self.included(base)
+    base.class_eval do
+      include ClientTests
+      include AuthorizeParamsTests
+      include CSRFAuthorizeParamsTests
+      include TokenParamsTests
+    end
+  end
+  
+  module ClientTests
+    extend BlockTestHelper
+    
+    test 'should be initialized with symbolized client_options' do
+      @options = { :client_options => { 'authorize_url' => 'https://example.com' } }
+      assert_equal 'https://example.com', strategy.client.options[:authorize_url]
+    end
+  end
+
+  module AuthorizeParamsTests
+    extend BlockTestHelper
+    
+    test 'should include any authorize params passed in the :authorize_params option' do
+      @options = { :authorize_params => { :foo => 'bar', :baz => 'zip' } }
+      assert_equal 'bar', strategy.authorize_params['foo']
+      assert_equal 'zip', strategy.authorize_params['baz']
+    end
+
+    test 'should include top-level options that are marked as :authorize_options' do
+      @options = { :authorize_options => [:scope, :foo], :scope => 'bar', :foo => 'baz' }
+      assert_equal 'bar', strategy.authorize_params['scope']
+      assert_equal 'baz', strategy.authorize_params['foo']
+    end
+    
+    test 'should exclude top-level options that are not passed' do
+      @options = { :authorize_options => [:bar] }
+      refute_has_key :bar, strategy.authorize_params
+      refute_has_key 'bar', strategy.authorize_params
+    end
+  end
+
+  module CSRFAuthorizeParamsTests
+    extend BlockTestHelper
+
+    test 'should store random state in the session when none is present in authorize or request params' do
+      assert_includes strategy.authorize_params.keys, 'state'
+      refute_empty strategy.authorize_params['state']
+      refute_empty strategy.session['omniauth.state']
+      assert_equal strategy.authorize_params['state'], strategy.session['omniauth.state']
+    end
+
+    test 'should not store state in the session when present in authorize params vs. a random one' do
+      @options = { :authorize_params => { :state => 'bar' } }
+      refute_empty strategy.authorize_params['state']
+      refute_equal 'bar', strategy.authorize_params[:state]
+      refute_empty strategy.session['omniauth.state']
+      refute_equal 'bar', strategy.session['omniauth.state']
+    end
+
+    test 'should not store state in the session when present in request params vs. a random one' do
+      @request.stubs(:params).returns({ 'state' => 'foo' })
+      refute_empty strategy.authorize_params['state']
+      refute_equal 'foo', strategy.authorize_params[:state]
+      refute_empty strategy.session['omniauth.state']
+      refute_equal 'foo', strategy.session['omniauth.state']
+    end
+  end
+
+  module TokenParamsTests
+    extend BlockTestHelper
+    
+    test 'should include any authorize params passed in the :token_params option' do
+      @options = { :token_params => { :foo => 'bar', :baz => 'zip' } }
+      assert_equal 'bar', strategy.token_params['foo']
+      assert_equal 'zip', strategy.token_params['baz']
+    end
+
+    test 'should include top-level options that are marked as :token_options' do
+      @options = { :token_options => [:scope, :foo], :scope => 'bar', :foo => 'baz' }
+      assert_equal 'bar', strategy.token_params['scope']
+      assert_equal 'baz', strategy.token_params['foo']
+    end
+  end
+end

data/test/test.rb

@@ -0,0 +1,255 @@
+require 'helper'
+require 'omniauth-elitmus'
+
+class StrategyTest < StrategyTestCase
+  include OAuth2StrategyTests
+end
+
+class ClientTest < StrategyTestCase
+  test 'has correct default Elitmus site' do
+    assert_equal 'https://www.elitmus.com', strategy.client.site
+  end
+
+  test 'has correct default authorize url' do
+    assert_equal '/oauth/authorize', strategy.client.options[:authorize_url]
+  end
+
+  test 'has correct default token url' do
+    assert_equal '/oauth/token', strategy.client.options[:token_url]
+  end
+
+  test 'should be initialized with only site option in symbolized client_options' do
+    @options = { :client_options => { 'site' => 'https://codephode.com' } }
+    assert_equal 'https://codephode.com', strategy.client.site
+    assert_equal '/oauth/authorize', strategy.client.options[:authorize_url]
+    assert_equal '/oauth/token', strategy.client.options[:token_url]
+  end
+
+  test 'should be initialized with site and authorize_url in symbolized client_options' do
+    @options = { :client_options => { 'site' => 'https://codephode.com', 'authorize_url' => '/custom/auth' } }
+    assert_equal 'https://codephode.com', strategy.client.site
+    assert_equal '/custom/auth', strategy.client.options[:authorize_url]
+    assert_equal '/oauth/token', strategy.client.options[:token_url]
+  end
+
+
+  test 'should be initialized with site and token_url in symbolized client_options' do
+    @options = { :client_options => { 'site' => 'https://codephode.com', 'token_url' => '/custom/token' } }
+    assert_equal 'https://codephode.com', strategy.client.site
+    assert_equal '/oauth/authorize', strategy.client.options[:authorize_url]
+    assert_equal '/custom/token', strategy.client.options[:token_url]
+  end
+
+  test 'should be initialized with symbolized client_options' do
+    @options = { :client_options => { 'site' => 'https://staging.shrey.com', 'authorize_url' => '/custom/auth', 'token_url' => '/custom/token' } }
+    assert_equal 'https://staging.shrey.com', strategy.client.site
+    assert_equal '/custom/auth', strategy.client.options[:authorize_url]
+    assert_equal '/custom/token', strategy.client.options[:token_url]
+  end
+
+end
+
+class CallbackUrlTest < StrategyTestCase
+  test "returns the default callback url" do
+    url_base = 'http://myconsumerapp.authrequest.com'
+    @request.stubs(:url).returns("#{url_base}/some/page")
+    strategy.stubs(:script_name).returns('') # as not to depend on Rack env
+    assert_equal "#{url_base}/auth/elitmus/callback", strategy.callback_url
+  end
+
+  test "returns path from callback_path option" do
+    @options = { :callback_path => "/auth/some/custom/path/callback"}
+    url_base = 'http://myconsumerapp.authrequest.com'
+    @request.stubs(:url).returns("#{url_base}/page/path")
+    strategy.stubs(:script_name).returns('') # as not to depend on Rack env
+    assert_equal "#{url_base}/auth/some/custom/path/callback", strategy.callback_url
+  end
+
+  test "returns url from callback_url option" do
+    url = 'http://myconsumerapp.authrequest.com/auth/elitmus/callback'
+    @options = { :callback_url => url }
+    assert_equal url, strategy.callback_url
+  end
+end
+
+class AuthorizeParamsTest < StrategyTestCase
+
+
+  test 'should include top-level options with their default values if marked as :authorize_options' do
+    @options = { :authorize_options => [:scope, :foo], :foo => 'baz' }
+    assert_equal 'public', strategy.authorize_params['scope']
+    assert_equal 'baz', strategy.authorize_params['foo']
+  end
+    
+  test 'includes default scope for public' do
+    assert strategy.authorize_params.is_a?(Hash)
+    assert_equal 'public', strategy.authorize_params[:scope]
+  end
+
+  test 'includes auth_type parameter from request when present' do
+    @request.stubs(:params).returns({ 'auth_type' => 'reauthenticate' })
+    assert strategy.authorize_params.is_a?(Hash)
+    assert_equal 'reauthenticate', strategy.authorize_params[:auth_type]
+  end
+
+  test 'overrides default scope with parameter passed from request' do
+    @request.stubs(:params).returns({ 'scope' => 'admin' })
+    assert strategy.authorize_params.is_a?(Hash)
+    assert_equal 'admin', strategy.authorize_params[:scope]
+  end
+end
+
+class UidTest < StrategyTestCase
+  def setup
+    super
+    strategy.stubs(:raw_info).returns({ 'id' => '123' })
+  end
+
+  test 'returns the id from raw_info' do
+    assert_equal '123', strategy.uid
+  end
+end
+
+class InfoTestOptionalDataPresent < StrategyTestCase
+   def setup
+    super
+    @raw_info ||= { 'name' => 'Fred Smith' }
+    strategy.stubs(:raw_info).returns(@raw_info)
+  end
+
+  test 'returns the name' do
+    assert_equal 'Fred Smith', strategy.info['name']
+  end
+
+  test 'returns the email' do
+    @raw_info['email'] = 'fred@smith.com'
+    assert_equal 'fred@smith.com', strategy.info['email']
+  end
+
+end
+
+class InfoTestOptionalDataNotPresent < StrategyTestCase
+  def setup
+    super
+    @raw_info = { 'name' => 'Fred Smith' }
+    strategy.stubs(:raw_info).returns(@raw_info)
+  end
+
+  test 'has no email key' do
+    refute_has_key 'email', strategy.info
+  end
+
+  test 'has no nickname key' do
+    refute_has_key 'nickname', strategy.info
+  end
+
+  test 'has no first name key' do
+    refute_has_key 'first_name', strategy.info
+  end
+
+  test 'has no last name key' do
+    refute_has_key 'last_name', strategy.info
+  end
+
+  test 'has no location key' do
+    refute_has_key 'location', strategy.info
+  end
+
+  test 'has no description key' do
+    refute_has_key 'description', strategy.info
+  end
+
+  test 'has no urls' do
+    refute_has_key 'urls', strategy.info
+  end
+
+  test 'has no verified key' do
+    refute_has_key 'verified', strategy.info
+  end
+end
+
+class RawInfoTest < StrategyTestCase
+  def setup
+    super
+    @access_token = stub('OAuth2::AccessToken')
+    @appsecret_proof = 'appsecret_proof'
+    @options = {:appsecret_proof => @appsecret_proof}
+  end
+
+  test 'should not include raw_info in extras hash when skip_info is specified' do
+    @options = { :skip_info => true }
+    strategy.stubs(:raw_info).returns({:foo => 'bar' })
+    refute_has_key 'raw_info', strategy.extra
+  end
+end
+
+
+
+class CredentialsTest < StrategyTestCase
+  def setup
+    super
+    @access_token = stub('OAuth2::AccessToken')
+    @access_token.stubs(:token)
+    @access_token.stubs(:expires?)
+    @access_token.stubs(:expires_at)
+    @access_token.stubs(:refresh_token)
+    strategy.stubs(:access_token).returns(@access_token)
+  end
+
+  test 'returns a Hash' do
+    assert_kind_of Hash, strategy.credentials
+  end
+
+  test 'returns the token' do
+    @access_token.stubs(:token).returns('123')
+    assert_equal '123', strategy.credentials['token']
+  end
+
+  test 'returns the expiry status' do
+    @access_token.stubs(:expires?).returns(true)
+    assert strategy.credentials['expires']
+
+    @access_token.stubs(:expires?).returns(false)
+    refute strategy.credentials['expires']
+  end
+
+  test 'returns the refresh token and expiry time when expiring' do
+    ten_mins_from_now = (Time.now + 600).to_i
+    @access_token.stubs(:expires?).returns(true)
+    @access_token.stubs(:refresh_token).returns('321')
+    @access_token.stubs(:expires_at).returns(ten_mins_from_now)
+    assert_equal '321', strategy.credentials['refresh_token']
+    assert_equal ten_mins_from_now, strategy.credentials['expires_at']
+  end
+
+  test 'does not return the refresh token when test is nil and expiring' do
+    @access_token.stubs(:expires?).returns(true)
+    @access_token.stubs(:refresh_token).returns(nil)
+    assert_nil strategy.credentials['refresh_token']
+    refute_has_key 'refresh_token', strategy.credentials
+  end
+
+  test 'does not return the refresh token when not expiring' do
+    @access_token.stubs(:expires?).returns(false)
+    @access_token.stubs(:refresh_token).returns('XXX')
+    assert_nil strategy.credentials['refresh_token']
+    refute_has_key 'refresh_token', strategy.credentials
+  end
+end
+
+class ExtraTest < StrategyTestCase
+  def setup
+    super
+    @raw_info = { 'name' => 'Fred Smith', 'email' => 'fred@smith.com', 'city' => 'bangalore' }
+    strategy.stubs(:raw_info).returns(@raw_info)
+  end
+
+  test 'returns a Hash' do
+    assert_kind_of Hash, strategy.extra
+  end
+
+  test 'contains raw info' do
+    assert_equal({ 'raw_info' => @raw_info }, strategy.extra)
+  end
+
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: omniauth-elitmus
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Shrey Patel
+- Shireesh Jayashetty
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: omniauth-oauth2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.5.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.5.1
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- aws@elitmus.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/omniauth-elitmus.rb
+- lib/omniauth/elitmus.rb
+- lib/omniauth/elitmus/version.rb
+- lib/omniauth/strategies/elitmus.rb
+- omniauth-elitmus.gemspec
+- test/helper.rb
+- test/support/shared_example.rb
+- test/test.rb
+homepage: https://github.com/elitmus/omniauth-elitmus
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: eLitmus OAuth2 Strategy for OmniAuth
+test_files:
+- test/helper.rb
+- test/support/shared_example.rb
+- test/test.rb