g5_authentication_client 0.2.0

data/spec/g5_authentication_client/configuration_spec.rb

@@ -0,0 +1,210 @@
+require 'spec_helper'
+
+describe G5AuthenticationClient::Configuration do
+  let(:test_module) do
+    module TestModule
+      extend G5AuthenticationClient::Configuration
+    end
+  end
+
+  subject { test_module }
+
+  let(:logger) { double() }
+  let(:username) {'username'}
+  let(:password) {'password'}
+  let(:client_id) {'client id'}
+  let(:client_secret) {'client secret'}
+  let(:redirect_uri) {'/stuff'}
+  let(:endpoint){ 'http://endpoint.com' }
+  let(:authorization_code){ 'code' }
+  let(:access_token) { 'access_token_test' }
+  let(:allow_password_credentials) { 'false' }
+
+  after { test_module.reset }
+
+  it { should respond_to(:configure) }
+
+  context 'with default configuration' do
+    it { should_not be_debug }
+    its(:logger) { should be_an_instance_of(Logger) }
+    its(:username) {should be_nil}
+    its(:password) {should be_nil}
+    its(:client_id) {should == G5AuthenticationClient::DEFAULT_CLIENT_ID}
+    its(:client_secret) {should == G5AuthenticationClient::DEFAULT_CLIENT_SECRET}
+    its(:redirect_uri) {should == G5AuthenticationClient::DEFAULT_REDIRECT_URI}
+    its(:endpoint){should == G5AuthenticationClient::DEFAULT_ENDPOINT}
+    its(:authorization_code){ should be_nil }
+    its(:access_token) { should be_nil }
+    its(:allow_password_credentials) { should eq('true') }
+  end
+
+  context 'with environment variable configuration' do
+    before do
+      ENV['G5_AUTH_CLIENT_ID'] = client_id
+      ENV['G5_AUTH_CLIENT_SECRET'] = client_secret
+      ENV['G5_AUTH_REDIRECT_URI'] = redirect_uri
+      ENV['G5_AUTH_ENDPOINT'] = endpoint
+      ENV['G5_AUTH_USERNAME'] = 'foo'
+      ENV['G5_AUTH_ALLOW_PASSWORD_CREDENTIALS'] = 'false'
+    end
+
+    after do
+      ENV['G5_AUTH_CLIENT_ID'] = nil
+      ENV['G5_AUTH_CLIENT_SECRET'] = nil
+      ENV['G5_AUTH_REDIRECT_URI'] = nil
+      ENV['G5_AUTH_ENDPOINT'] = nil
+    end
+
+    it { should_not be_debug }
+    its(:logger) { should be_an_instance_of(Logger) }
+    its(:username) { should eq('foo')}
+    its(:password) { should be_nil }
+    its(:client_id) { should == client_id }
+    its(:client_secret) { should == client_secret }
+    its(:redirect_uri) { should == redirect_uri }
+    its(:endpoint) { should == endpoint }
+    its(:authorization_code) { should be_nil }
+    its(:access_token) { should be_nil }
+    its(:allow_password_credentials) { should == allow_password_credentials }
+
+  end
+
+  describe '.configure' do
+    subject { test_module.configure(&config_block) }
+
+    context 'with full configuration' do
+      let(:config_block) do
+        lambda do |config|
+          config.debug = true
+          config.logger = logger
+          config.username = username
+          config.password = password
+          config.client_id = client_id
+          config.client_secret = client_secret
+          config.redirect_uri = redirect_uri
+          config.endpoint = endpoint
+          config.authorization_code = authorization_code
+          config.access_token = access_token
+          config.allow_password_credentials = allow_password_credentials
+        end
+      end
+
+      it { should == test_module }
+      it { should be_debug }
+      its(:logger) { should == logger }
+      its(:username){ should == username }
+      its(:password){ should == password }
+      its(:client_id){ should == client_id }
+      its(:client_secret){ should == client_secret }
+      its(:redirect_uri){ should == redirect_uri}
+      its(:endpoint){ should == endpoint}
+      its(:authorization_code){ should == authorization_code}
+      its(:access_token) { should == access_token }
+      its(:allow_password_credentials) { should == allow_password_credentials }
+    end
+
+    context 'with partial configuration' do
+      let(:config_block) do
+        lambda do |config|
+          config.debug = true
+          config.username = 'foo'
+          config.password = 'bar'
+        end
+      end
+
+      it { should == test_module }
+
+      it { should be_debug }
+      its(:logger) { should be_an_instance_of(Logger) }
+      its(:username) { should == 'foo' }
+      its(:password) { should == 'bar' }
+      its(:client_id){ should == G5AuthenticationClient::DEFAULT_CLIENT_ID }
+      its(:client_secret){ should == G5AuthenticationClient::DEFAULT_CLIENT_SECRET }
+      its(:redirect_uri){ should == G5AuthenticationClient::DEFAULT_REDIRECT_URI }
+      its(:endpoint){ should == G5AuthenticationClient::DEFAULT_ENDPOINT}
+      its(:authorization_code){ should be_nil}
+      its(:access_token) { should be_nil }
+
+      context 'when there is an env variable default' do
+
+        let(:access_token_value) { 'test' }
+
+        before do
+          ENV['G5_AUTH_ACCESS_TOKEN']=access_token_value
+        end
+
+        after do
+          ENV['G5_AUTH_ACCESS_TOKEN']=nil
+        end
+
+        its(:access_token) { should eq(access_token_value) }
+
+      end
+    end
+  end
+
+  it { should respond_to(:reset) }
+
+  describe '.reset' do
+    before do
+      test_module.configure do |config|
+        config.debug = true
+        config.logger = logger
+        config.username = 'foo'
+        config.password = 'bar'
+        config.endpoint = 'blah'
+        config.client_id = 'blah'
+        config.client_secret = 'blah'
+        config.redirect_uri = 'blah'
+        config.authorization_code = 'blah'
+        config.access_token = 'blah'
+        config.allow_password_credentials = 'false'
+      end
+    end
+
+    subject { test_module.reset;test_module }
+
+    its(:username) {should be_nil}
+    its(:password) {should be_nil}
+    its(:endpoint) {should == G5AuthenticationClient::DEFAULT_ENDPOINT}
+    its(:client_id) {should == G5AuthenticationClient::DEFAULT_CLIENT_ID}
+    its(:client_secret) {should == G5AuthenticationClient::DEFAULT_CLIENT_SECRET}
+    its(:redirect_uri) {should == G5AuthenticationClient::DEFAULT_REDIRECT_URI}
+    its(:debug?){ should be_false }
+    its(:logger){ should be_instance_of(Logger) }
+    its(:access_token) { should be_nil }
+    its(:allow_password_credentials) { should == 'true' }
+  end
+
+  describe '.options' do
+    before do
+      test_module.configure do |config|
+        config.debug = true
+        config.logger = logger
+        config.username = username
+        config.password = password
+        config.endpoint = endpoint
+        config.client_id = client_id
+        config.client_secret = client_secret
+        config.redirect_uri = redirect_uri
+        config.authorization_code = authorization_code
+        config.access_token = access_token
+        config.allow_password_credentials = allow_password_credentials
+      end
+    end
+
+    subject { test_module.options }
+
+    its([:debug]) { should be_true }
+    its([:logger]) { should == logger }
+    its([:username]) { should == username } 
+    its([:password]) { should == password }
+    its([:endpoint]) { should == endpoint }
+    its([:client_id]) { should == client_id }
+    its([:client_secret]) { should == client_secret }
+    its([:redirect_uri]) { should == redirect_uri}
+    its([:authorization_code]){ should == authorization_code }
+    its([:access_token]) { should == access_token }
+    its([:allow_password_credentials]) { should == allow_password_credentials }
+  end
+end

data/spec/g5_authentication_client/token_info_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe G5AuthenticationClient::TokenInfo do
+  subject { token_info }
+  let(:token_info) { described_class.new(attributes) }
+
+  let(:attributes) do
+    {
+      resource_owner_id: resource_owner_id,
+      scopes: scopes,
+      expires_in_seconds: expires_in_seconds,
+      application: { uid: application_uid }
+    }
+  end
+
+  let(:resource_owner_id) { 42 }
+  let(:scopes) { ['leads','calls'] }
+  let(:expires_in_seconds) { '3600' }
+  let(:application_uid) { 'application-uid-42' }
+
+  context 'with default initialization' do
+    let(:attributes) {}
+
+    its(:resource_owner_id) { should be_nil }
+    its(:scopes) { should be_empty }
+    its(:expires_in_seconds) { should be_nil }
+    its(:application_uid) { should be_nil }
+  end
+
+  context 'with full initialization' do
+    its(:resource_owner_id) { should == resource_owner_id.to_s }
+    its(:scopes) { should == scopes }
+    its(:expires_in_seconds) { should == expires_in_seconds.to_i }
+    its(:application_uid) { should == application_uid }
+  end
+end

data/spec/g5_authentication_client/user_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe G5AuthenticationClient::User do
+  subject { user }
+  let(:user){G5AuthenticationClient::User.new(attributes)}
+
+  let(:attributes) do
+    {email: email,
+    password: password,
+    password_confirmation: password_confirmation,
+    id: id
+    }
+  end
+
+  let(:email) { 'foo@blah.com' }
+  let(:password) { 'foobarbaz' }
+  let(:password_confirmation) { 'notamatch' }
+  let(:id) {1}
+
+  context 'with default initialization' do
+    let(:attributes){}
+
+    its(:email) { should be_nil}
+    its(:password) { should be_nil}
+    its(:id){ should be_nil}
+    its(:password_confirmation) { should be_nil }
+  end
+
+  context 'with full initialization' do
+    its(:email) { should == email }
+    its(:password){ should == password }
+    its(:password_confirmation) { should == password_confirmation }
+    its(:id) { should == id}
+  end
+
+  describe '#validate!' do
+    subject(:validate!) { user.validate! }
+
+    context 'without email' do
+      let(:email){}
+
+      it 'should raise an error' do
+        expect { validate! }.to raise_error
+      end
+    end
+
+    context 'without password' do
+      let(:password){}
+
+      it 'should not raise an error' do
+        expect { validate! }.to_not raise_error
+      end
+    end
+
+    context 'without id' do
+      let(:id){}
+
+      it 'should not raise an error' do
+        expect { validate! }.to_not raise_error
+      end
+    end
+
+    context 'without password_confirmation' do
+      let(:password_confirmation) {}
+
+      it 'should not raise an error' do
+        expect { validate! }.to_not raise_error
+      end
+    end
+  end
+
+  describe '#validate_for_create!' do
+    subject(:validate_for_create) {user.validate_for_create!}
+
+    context 'without a password' do
+      let(:password){}
+
+      it 'should be invalid' do
+        expect { validate_for_create }.to raise_error
+      end
+    end
+
+    context 'without an email' do
+      let(:email){}
+      let(:password){'foo'}
+
+      it 'should be invalid' do
+        expect { validate_for_create }.to raise_error
+      end
+    end
+  end
+end

data/spec/g5_authentication_client_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe G5AuthenticationClient do
+  it "should have a version" do
+    subject::VERSION.should be
+  end
+
+  it { should respond_to(:configure) }
+  it { should respond_to(:reset) }
+  it { should respond_to(:options) }
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require 'simplecov'
+SimpleCov.start 'test_frameworks'
+
+require 'codeclimate-test-reporter'
+CodeClimate::TestReporter.start
+
+require 'rspec'
+
+require 'webmock/rspec'
+require 'fakefs/spec_helpers'
+
+Dir[File.join(File.dirname(__FILE__), 'support', '*.rb')].each { |f| require f }
+
+RSpec.configure do |config|
+  config.include FakeFS::SpecHelpers
+
+  # We need to explicitly disable webmock to report
+  # coverage data to Code Climate
+  config.after(:suite) { WebMock.disable! }
+end
+
+require 'g5_authentication_client'

data/spec/support/module_configured_attribute.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+shared_examples_for 'a module configured attribute' do |attribute_name,default_value|
+
+    describe "##{attribute_name.to_s}=" do
+      subject do
+        client.send "#{attribute_name.to_s}=", new_value
+        client
+      end
+
+      context "with nil #{attribute_name.to_s}" do
+        let(:new_value){nil}
+
+        context "with module configured #{attribute_name}" do
+          let(:configured_value){'other thing'}
+
+          before do
+            G5AuthenticationClient.configure do |t|
+              t.send "#{attribute_name.to_s}=", configured_value
+            end
+          end
+
+          its(attribute_name){ should == configured_value }
+        end
+
+        context 'without module configured #{attribute_name}' do
+          its(attribute_name){ should == default_value }
+        end
+      end
+
+      context 'with new #{attribute_name.to_s}' do
+        let(:new_value){ 'userdude' }
+
+        its(attribute_name){ should == new_value }
+      end
+    end
+end

data/spec/support/oauth_protected_resource.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+# Requires the following to be defined in the surrounding context
+# access_token_value
+# token_type
+# client_id
+# client_secret
+# authorization_code
+# redirect_uri
+# username
+# password
+shared_examples_for 'an oauth protected resource' do |resource_type|
+  let(:oauth_access_token) do
+    {
+      'access_token' => access_token_value,
+      'token_type' => token_type,
+      'expires_in' => 7200,
+      'refresh_token' => 'refresh_token'
+    }
+  end
+
+  context 'when there is an access token' do
+    let(:authorization_code) { nil }
+    let(:username) { nil }
+    let(:password) { nil }
+
+    it { should be_an_instance_of resource_type }
+  end
+
+  context 'when there is an authorization code' do
+    let(:access_token) { nil }
+    let(:username) { nil }
+    let(:password) { nil }
+
+    let(:token_request_by_auth_code) do
+      {
+        'client_id' => client_id,
+        'client_secret' => client_secret,
+        'code' => authorization_code,
+        'grant_type' => 'authorization_code',
+        'redirect_uri' => redirect_uri
+      }
+    end
+
+    before do
+      stub_request(:post, "#{endpoint}/oauth/token").
+        with(body: token_request_by_auth_code).
+        to_return(status: 200,
+                  body: oauth_access_token.to_json,
+                  headers: {'Content-Type' => 'application/json'})
+    end
+
+    it { should be_an_instance_of resource_type }
+  end
+
+  context 'when there is a username and password' do
+    let(:access_token) { nil }
+    let(:authorization_code) { nil }
+    let(:allow_password_credentials) {'true'}
+
+    let(:token_request_by_password) do
+      {
+        'client_id' => client_id,
+        'client_secret' => client_secret,
+        'grant_type' => 'password',
+        'username' => username,
+        'password' => password
+      }
+    end
+
+    before do
+      stub_request(:post, "#{endpoint}/oauth/token").
+        with(body: token_request_by_password).
+        to_return(status: 200,
+                  body: oauth_access_token.to_json,
+                  headers: {'Content-Type' => 'application/json'})
+    end
+
+    it { should be_an_instance_of resource_type }
+  end
+end