g5_authentication_client 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 97c68343930b548666879d796904ea3345cd791b
-  data.tar.gz: 9a41e522f8fd8ab0ded0d797ce29d2292b272dac
+  metadata.gz: 9da8c28deb98850c7e6b1174c64163c2dc694104
+  data.tar.gz: b8530a5eb42cab81dc1ceb2c3cc32a6010f56115
 SHA512:
-  metadata.gz: 8ff4eeaa114f7693c555bffc53a360a762897fb3f60e8dccee176eaf64c82af9d9e957e044f482826ecc33df5242a0692878c59a8b552a354c49bffed3c73290
-  data.tar.gz: 1d377a2678b5435e6f11f8003417cb5a25148fe0889f728d23a266160b09fbeb2dbd4356822a83f9531e3d949da9f5818afd39ef9e1887ae2a4b4c3c05ae8687
+  metadata.gz: d3a70a125ba261f7580db5ba0873c21a3b6c9b12857b80908ee45ed5a6b1324a610261056c3dfb57eb6752ae34597b73bd7a641ffbf23a6ed94d60ec8082c7ad
+  data.tar.gz: 0a5f34d64d22f3194ad5e7b9ec90383c15e305e3c3668125360929b118aa70b2245f667b6561dc54a80dc710b146d92f69461fbd59a1e0432661d91b5ad0e256

data/lib/g5_authentication_client/user.rb

@@ -4,6 +4,7 @@ module G5AuthenticationClient
 
   #A G5 Authentication User
   class User < Modelish::Base
+    ignore_unknown_properties!
     # @!attribute [rw] email
     #   @return [String]
     #   The user's email address.
@@ -24,6 +25,31 @@ module G5AuthenticationClient
     #   The user's id.  Not required to create a user.
     property :id, type: Integer
 
+    # @!attribute [rw] first_name
+    #   @return [String]
+    #   The user's first name.  Not required to create a user.
+    property :first_name, type: String
+
+    # @!attribute [rw] last_name
+    #   @return [String]
+    #   The user's last name.  Not required to create a user.
+    property :last_name, type: String
+
+    # @!attribute [rw] title
+    #   @return [String]
+    #   The user's title.  Not required to create a user.
+    property :title, type: String
+
+    # @!attribute [rw] organization_name
+    #   @return [String]
+    #   The user's organization name.  Not required to create a user.
+    property :organization_name, type: String
+
+    # @!attribute [rw] phone_number
+    #   @return [String]
+    #   The user's phone number.  Not required to create a user.
+    property :phone_number, type: String
+
     def validate_for_create!
       validate!
       raise ArgumentError.new("Password required for new user.") unless !password.nil?

data/lib/g5_authentication_client/version.rb

@@ -1,3 +1,3 @@
 module G5AuthenticationClient
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
 end

data/spec/g5_authentication_client/client_spec.rb

@@ -2,12 +2,10 @@ require 'spec_helper'
 require 'json'
 
 describe G5AuthenticationClient::Client do
-  subject { client }
+  subject(:client) { G5AuthenticationClient::Client.new(options) }
 
   after { G5AuthenticationClient.reset }
 
-  let(:client) { G5AuthenticationClient::Client.new(options) }
-
   let(:debug) { true }
   let(:logger) { double() }
   let(:username) {'username'}
@@ -53,29 +51,63 @@ describe G5AuthenticationClient::Client do
   let(:returned_user){{id: user_id,email: email}}
 
   context 'with default configuration' do
-    let(:client) { G5AuthenticationClient::Client.new }
-
-    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 == 'true'}
+    subject(:client) { G5AuthenticationClient::Client.new }
+
+    it 'should not be debug' do
+      expect(client.debug?).to_not be true
+    end
+
+    it 'should have a logger' do
+      expect(client.logger).to be_an_instance_of(Logger)
+    end
+
+    it 'should not have a user name' do
+      expect(client.username).to be_nil
+    end
+
+    it 'should not have a password' do
+      expect(client.password).to be_nil
+    end
+
+    it 'should have default client id' do
+      expect(client.client_id).to eq(G5AuthenticationClient::DEFAULT_CLIENT_ID)
+    end
+
+    it 'should have default client secret' do
+      expect(client.client_secret).to eq(G5AuthenticationClient::DEFAULT_CLIENT_SECRET)
+    end
+
+    it 'should have default redirect uri' do
+      expect(client.redirect_uri).to eq(G5AuthenticationClient::DEFAULT_REDIRECT_URI)
+    end
+
+    it 'should have default endpoint' do
+      expect(client.endpoint).to eq(G5AuthenticationClient::DEFAULT_ENDPOINT)
+    end
+
+    it 'should have nil authorization code' do
+      expect(client.authorization_code).to be_nil
+    end
+
+    it 'should have nil access token' do
+      expect(client.access_token).to be_nil
+    end
+
+    it 'should have default allow_password_credentials' do
+      expect(client.allow_password_credentials).to eq('true')
+    end
   end
 
   context 'with non-default configuration' do
-    it { should be_debug }
-    its(:logger) { should == logger }
+
+    it 'should have debug' do
+      expect(client.debug).to be true
+    end
 
     describe '#debug=' do
       subject { client.debug = new_debug }
 
-       context 'with nil debug' do
+      context 'with nil debug' do
         let(:new_debug) { nil }
 
         context 'when there is a debug flag configured at the top-level module' do
@@ -135,37 +167,58 @@ describe G5AuthenticationClient::Client do
       end
     end
 
-    its(:username) { should == username }
+    it 'should have username' do
+      expect(client.username).to eq(username)
+    end
 
     it_should_behave_like 'a module configured attribute',:username, nil
 
-    its(:password) { should == password }
+    it 'should have password' do
+      expect(client.password).to eq(password)
+    end
 
     it_should_behave_like 'a module configured attribute', :password, nil
 
-    its(:endpoint){ should == endpoint}
+    it 'should have endpoint' do
+      expect(client.endpoint).to eq(endpoint)
+    end
 
     it_should_behave_like 'a module configured attribute', :endpoint,G5AuthenticationClient::DEFAULT_ENDPOINT
 
-    its(:client_id) { should == client_id}
+    it 'should have client_id' do
+      expect(client.client_id).to eq(client_id)
+    end
 
     it_should_behave_like 'a module configured attribute', :client_id, G5AuthenticationClient::DEFAULT_CLIENT_ID
 
-    its(:client_secret) {should ==client_secret}
+    it 'should have client_secret' do
+      expect(client.client_secret).to eq(client_secret)
+    end
 
     it_should_behave_like 'a module configured attribute', :client_secret, G5AuthenticationClient::DEFAULT_CLIENT_SECRET
 
-    its(:redirect_uri) {should ==redirect_uri}
+    it 'should have redirect_uri' do
+      expect(client.redirect_uri).to eq(redirect_uri)
+    end
 
     it_should_behave_like 'a module configured attribute', :redirect_uri, G5AuthenticationClient::DEFAULT_REDIRECT_URI
 
-    its(:authorization_code) { should == authorization_code}
+    it 'should have authorization_code' do
+      expect(client.authorization_code).to eq(authorization_code)
+    end
+
     it_should_behave_like 'a module configured attribute', :authorization_code, nil
 
-    its(:access_token) { should == access_token_value }
+    it 'should have access_token' do
+      expect(client.access_token).to eq(access_token)
+    end
+
     it_should_behave_like 'a module configured attribute', :access_token, nil
 
-    its(:allow_password_credentials) { should == allow_password_credentials }
+    it 'should have allow_password_credentials' do
+      expect(client.allow_password_credentials).to eq(allow_password_credentials)
+    end
+
     it_should_behave_like 'a module configured attribute', :allow_password_credentials, 'true'
   end
 
@@ -178,7 +231,7 @@ describe G5AuthenticationClient::Client do
       context 'with non-nil username and password' do
 
         it 'should be true' do
-          expect(subject).to be_true
+          expect(subject).to be true
         end
       end
 
@@ -186,7 +239,7 @@ describe G5AuthenticationClient::Client do
         let(:username) {}
 
         it 'should be false' do
-          expect(subject).to be_false
+          expect(subject).to be false
         end
       end
 
@@ -194,7 +247,7 @@ describe G5AuthenticationClient::Client do
         let(:password) {}
 
         it 'should be false' do
-          expect(subject).to be_false
+          expect(subject).to be false
         end
       end
     end
@@ -203,7 +256,7 @@ describe G5AuthenticationClient::Client do
       let(:allow_password_credentials) {'false'}
 
       it 'should be false' do
-        expect(subject).to be_false
+        expect(subject).to be false
       end
     end
   end

data/spec/g5_authentication_client/configuration_spec.rb

@@ -1,14 +1,12 @@
 require 'spec_helper'
 
 describe G5AuthenticationClient::Configuration do
-  let(:test_module) do
+  subject(:test_module) do
     module TestModule
       extend G5AuthenticationClient::Configuration
     end
   end
 
-  subject { test_module }
-
   let(:logger) { double() }
   let(:username) {'username'}
   let(:password) {'password'}
@@ -19,23 +17,63 @@ describe G5AuthenticationClient::Configuration do
   let(:authorization_code){ 'code' }
   let(:access_token) { 'access_token_test' }
   let(:allow_password_credentials) { 'false' }
+  let(:first_name) { 'Joe' }
+  let(:last_name) { 'Person' }
+  let(:organization_name) { 'Things, Inc.' }
+  let(:phone_number) { '8675309123' }
+  let(:title) { 'Developer' }
 
   after { test_module.reset }
 
-  it { should respond_to(:configure) }
+  it 'should respond to configure' do
+    expect(test_module).to respond_to(:configure)
+  end
 
   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') }
+
+    it 'should not be debug' do
+      expect(test_module.debug?).to be false
+    end
+
+    it 'should have a logger' do
+      expect(test_module.logger).to be_instance_of(Logger)
+    end
+
+    it 'should have nil username' do
+      expect(test_module.username).to be_nil
+    end
+
+    it 'should have nil password' do
+      expect(test_module.password).to be_nil
+    end
+
+    it 'should have default client id' do
+      expect(test_module.client_id).to eq(G5AuthenticationClient::DEFAULT_CLIENT_ID)
+    end
+
+    it 'should have default client_secret' do
+      expect(test_module.client_secret).to eq(G5AuthenticationClient::DEFAULT_CLIENT_SECRET)
+    end
+
+    it 'should have default redirect_uri' do
+      expect(test_module.redirect_uri).to eq(G5AuthenticationClient::DEFAULT_REDIRECT_URI)
+    end
+
+    it 'should have default endpoint' do
+      expect(test_module.endpoint).to eq(G5AuthenticationClient::DEFAULT_ENDPOINT)
+    end
+
+    it 'should have nil authorization_code' do
+      expect(test_module.authorization_code).to be_nil
+    end
+
+    it 'should have nil access_token' do
+      expect(test_module.access_token).to be_nil
+    end
+
+    it 'should allow password credentials' do
+      expect(test_module.allow_password_credentials).to eq(G5AuthenticationClient::DEFAULT_ALLOW_PASSWORD_CREDENTIALS)
+    end
   end
 
   context 'with environment variable configuration' do
@@ -44,8 +82,8 @@ describe G5AuthenticationClient::Configuration do
       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'
+      ENV['G5_AUTH_USERNAME'] = new_username
+      ENV['G5_AUTH_ALLOW_PASSWORD_CREDENTIALS'] = new_allow_password_credentials
     end
 
     after do
@@ -55,22 +93,58 @@ describe G5AuthenticationClient::Configuration do
       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 }
+    let(:new_username) { 'foo' }
+
+    let(:new_allow_password_credentials) { 'false' }
+
+    it 'should not be debug' do
+      expect(test_module.debug?).to be false
+    end
+
+    it 'should have a logger' do
+      expect(test_module.logger).to be_instance_of(Logger)
+    end
+
+    it 'should have username' do
+      expect(test_module.username).to eq(new_username)
+    end
+
+    it 'should have nil password' do
+      expect(test_module.password).to be_nil
+    end
+
+    it 'should have default client id' do
+      expect(test_module.client_id).to eq(client_id)
+    end
+
+    it 'should have default client_secret' do
+      expect(test_module.client_secret).to eq(client_secret)
+    end
+
+    it 'should have default redirect_uri' do
+      expect(test_module.redirect_uri).to eq(redirect_uri)
+    end
+
+    it 'should have default endpoint' do
+      expect(test_module.endpoint).to eq(endpoint)
+    end
+
+    it 'should have nil authorization_code' do
+      expect(test_module.authorization_code).to be_nil
+    end
+
+    it 'should have nil access_token' do
+      expect(test_module.access_token).to be_nil
+    end
+
+    it 'should not allow password credentials' do
+      expect(test_module.allow_password_credentials).to eq(new_allow_password_credentials)
+    end
 
   end
 
   describe '.configure' do
-    subject { test_module.configure(&config_block) }
+    subject(:configure) { test_module.configure(&config_block) }
 
     context 'with full configuration' do
       let(:config_block) do
@@ -89,41 +163,107 @@ describe G5AuthenticationClient::Configuration do
         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 }
+      it 'should be debug' do
+        expect(configure.debug?).to be true
+      end
+
+      it 'should have a logger' do
+        expect(configure.logger).to eq(logger)
+      end
+
+      it 'should have username' do
+        expect(configure.username).to eq(username)
+      end
+
+      it 'should have the correct password' do
+        expect(configure.password).to eq(password)
+      end
+
+      it 'should have the correct client id' do
+        expect(configure.client_id).to eq(client_id)
+      end
+
+      it 'should have the correct client_secret' do
+        expect(configure.client_secret).to eq(client_secret)
+      end
+
+      it 'should have the correct redirect_uri' do
+        expect(configure.redirect_uri).to eq(redirect_uri)
+      end
+
+      it 'should have the correct endpoint' do
+        expect(configure.endpoint).to eq(endpoint)
+      end
+
+      it 'should have the correct authorization_code' do
+        expect(configure.authorization_code).to eq(authorization_code)
+      end
+
+      it 'should have the correct access_token' do
+        expect(configure.access_token).to eq(access_token)
+      end
+
+      it 'should have the correct value for allowing password credentials' do
+        expect(configure.allow_password_credentials).to eq(allow_password_credentials)
+      end
     end
 
     context 'with partial configuration' do
       let(:config_block) do
         lambda do |config|
-          config.debug = true
-          config.username = 'foo'
-          config.password = 'bar'
+          config.debug = new_debug
+          config.username = new_username
+          config.password = new_password
         end
       end
 
-      it { should == test_module }
+      let(:new_username) { 'foo' }
+      let(:new_password) { 'bar' }
+      let(:new_debug) { true }
 
-      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 }
+      it 'should be debug' do
+        expect(configure.debug?).to be new_debug
+      end
+
+      it 'should have a logger' do
+        expect(configure.logger).to be_instance_of(Logger)
+      end
+
+      it 'should have username' do
+        expect(configure.username).to eq(new_username)
+      end
+
+      it 'should have the correct password' do
+        expect(configure.password).to eq(new_password)
+      end
+
+      it 'should have default client id' do
+        expect(test_module.client_id).to eq(G5AuthenticationClient::DEFAULT_CLIENT_ID)
+      end
+
+      it 'should have default client_secret' do
+        expect(test_module.client_secret).to eq(G5AuthenticationClient::DEFAULT_CLIENT_SECRET)
+      end
+
+      it 'should have default redirect_uri' do
+        expect(test_module.redirect_uri).to eq(G5AuthenticationClient::DEFAULT_REDIRECT_URI)
+      end
+
+      it 'should have default endpoint' do
+        expect(test_module.endpoint).to eq(G5AuthenticationClient::DEFAULT_ENDPOINT)
+      end
+
+      it 'should have nil authorization_code' do
+        expect(configure.authorization_code).to be_nil
+      end
+
+      it 'should have nil access_token' do
+        expect(configure.access_token).to be_nil
+      end
+
+      it 'should not allow password credentials' do
+        expect(configure.allow_password_credentials).to eq(G5AuthenticationClient::DEFAULT_ALLOW_PASSWORD_CREDENTIALS)
+      end
 
       context 'when there is an env variable default' do
 
@@ -137,13 +277,16 @@ describe G5AuthenticationClient::Configuration do
           ENV['G5_AUTH_ACCESS_TOKEN']=nil
         end
 
-        its(:access_token) { should eq(access_token_value) }
-
+        it 'should have correct access_token' do
+          expect(configure.access_token).to eq(access_token_value)
+        end
       end
     end
   end
 
-  it { should respond_to(:reset) }
+  it 'should reset' do
+    expect(test_module).to respond_to(:reset)
+  end
 
   describe '.reset' do
     before do
@@ -162,18 +305,51 @@ describe G5AuthenticationClient::Configuration do
       end
     end
 
-    subject { test_module.reset;test_module }
+    subject(:reset) { test_module.reset;test_module }
+
+    it 'should not be debug' do
+      expect(reset.debug?).to be false
+    end
+
+    it 'should have a logger' do
+      expect(reset.logger).to be_instance_of(Logger)
+    end
+
+    it 'should have nil username' do
+      expect(reset.username).to be_nil
+    end
+
+    it 'should have nil password' do
+      expect(reset.password).to be_nil
+    end
+
+    it 'should have default client id' do
+      expect(reset.client_id).to eq(G5AuthenticationClient::DEFAULT_CLIENT_ID)
+    end
+
+    it 'should have default client_secret' do
+      expect(reset.client_secret).to eq(G5AuthenticationClient::DEFAULT_CLIENT_SECRET)
+    end
+
+    it 'should have default redirect_uri' do
+      expect(reset.redirect_uri).to eq(G5AuthenticationClient::DEFAULT_REDIRECT_URI)
+    end
+
+    it 'should have default endpoint' do
+      expect(reset.endpoint).to eq(G5AuthenticationClient::DEFAULT_ENDPOINT)
+    end
+
+    it 'should have nil authorization_code' do
+      expect(reset.authorization_code).to be_nil
+    end
 
-    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' }
+    it 'should have nil access_token' do
+      expect(reset.access_token).to be_nil
+    end
+
+    it 'should allow password credentials' do
+      expect(reset.allow_password_credentials).to eq(G5AuthenticationClient::DEFAULT_ALLOW_PASSWORD_CREDENTIALS)
+    end
   end
 
   describe '.options' do
@@ -193,18 +369,21 @@ describe G5AuthenticationClient::Configuration do
       end
     end
 
-    subject { test_module.options }
+    subject(:options) { 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 }
+    it "should have correct options" do
+      options.should include(
+        debug: 'true',
+        username: username,
+        password: password,
+        endpoint: endpoint,
+        client_id: client_id,
+        client_secret: client_secret,
+        redirect_uri: redirect_uri,
+        authorization_code: authorization_code,
+        access_token: access_token,
+        allow_password_credentials: allow_password_credentials
+      )
+    end
   end
 end

data/spec/g5_authentication_client/token_info_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe G5AuthenticationClient::TokenInfo do
-  subject { token_info }
+  subject(:token) { token_info }
   let(:token_info) { described_class.new(attributes) }
 
   let(:attributes) do
@@ -21,16 +21,38 @@ describe G5AuthenticationClient::TokenInfo do
   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 }
+    it 'should have nil resource_owner_id' do
+      expect(token.resource_owner_id).to be_nil
+    end
+
+    it 'should have nil scopes' do
+      expect(token.scopes).to be_empty
+    end
+
+    it 'should have nil expires_in_seconds' do
+      expect(token.expires_in_seconds).to be_nil
+    end
+
+    it 'should have nil application_uid' do
+      expect(token.application_uid).to be_nil
+    end
   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 }
+    it 'should have resource_owner_id' do
+      expect(token.resource_owner_id).to eq(resource_owner_id.to_s)
+    end
+
+    it 'should have scopes' do
+      expect(token.scopes).to eq(scopes)
+    end
+
+    it 'should have expires_in_seconds' do
+      expect(token.expires_in_seconds).to eq(expires_in_seconds.to_i)
+    end
+
+    it 'should have application_uid' do
+      expect(token.application_uid).to eq(application_uid)
+    end
   end
 end

data/spec/g5_authentication_client/user_spec.rb

@@ -1,14 +1,18 @@
 require 'spec_helper'
 
 describe G5AuthenticationClient::User do
-  subject { user }
-  let(:user){G5AuthenticationClient::User.new(attributes)}
+  subject(:user) { G5AuthenticationClient::User.new(attributes) }
 
   let(:attributes) do
-    {email: email,
-    password: password,
-    password_confirmation: password_confirmation,
-    id: id
+    { email: email,
+      password: password,
+      password_confirmation: password_confirmation,
+      id: id,
+      first_name: first_name,
+      last_name: last_name,
+      title: title,
+      organization_name: organization_name,
+      phone_number: phone_number
     }
   end
 
@@ -16,21 +20,69 @@ describe G5AuthenticationClient::User do
   let(:password) { 'foobarbaz' }
   let(:password_confirmation) { 'notamatch' }
   let(:id) {1}
+  let(:first_name) { 'Joe' }
+  let(:last_name) { 'Person' }
+  let(:organization_name) { 'Things, Inc.' }
+  let(:phone_number) { '8675309123' }
+  let(:title) { 'Developer' }
 
   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 }
+    it 'should have nil email' do
+      expect(user.email).to be_nil
+    end
+
+    it 'should have nil password' do
+      expect(user.password).to be_nil
+    end
+
+    it 'should have nil id ' do
+      expect(user.id).to be_nil
+    end
+
+    it 'should have nil password_confirmation' do
+      expect(user.password_confirmation).to be_nil
+    end
   end
 
   context 'with full initialization' do
-    its(:email) { should == email }
-    its(:password){ should == password }
-    its(:password_confirmation) { should == password_confirmation }
-    its(:id) { should == id}
+
+    it 'should have correct email' do
+      expect(user.email).to eq(email)
+    end
+
+    it 'should have correct password' do
+      expect(user.password).to eq(password)
+    end
+
+    it 'should have correct password_confirmation' do
+      expect(user.password_confirmation).to eq(password_confirmation)
+    end
+
+    it 'should have correct id' do
+      expect(user.id).to eq(id)
+    end
+
+    it 'should have correct first_name' do
+      expect(user.first_name).to eq(first_name)
+    end
+
+    it 'should have correct last_name' do
+      expect(user.last_name).to eq(last_name)
+    end
+
+    it 'should have correct title' do
+      expect(user.title).to eq(title)
+    end
+
+    it 'should have correct phone_number' do
+      expect(user.phone_number).to eq(phone_number)
+    end
+
+    it 'should have correct organization_name' do
+      expect(user.organization_name).to eq(organization_name)
+    end
   end
 
   describe '#validate!' do
@@ -67,6 +119,46 @@ describe G5AuthenticationClient::User do
         expect { validate! }.to_not raise_error
       end
     end
+
+    context 'without first_name' do
+      let(:first_name) {}
+
+      it 'should not raise an error' do
+        expect { validate! }.to_not raise_error
+      end
+    end
+
+    context 'without last_name' do
+      let(:last_name) {}
+
+      it 'should not raise an error' do
+        expect { validate! }.to_not raise_error
+      end
+    end
+
+    context 'without title' do
+      let(:title) {}
+
+      it 'should not raise an error' do
+        expect { validate! }.to_not raise_error
+      end
+    end
+
+    context 'without phone_number' do
+      let(:phone_number) {}
+
+      it 'should not raise an error' do
+        expect { validate! }.to_not raise_error
+      end
+    end
+
+    context 'without organization_name' do
+      let(:organization_name) {}
+
+      it 'should not raise an error' do
+        expect { validate! }.to_not raise_error
+      end
+    end
   end
 
   describe '#validate_for_create!' do

data/spec/support/module_configured_attribute.rb

@@ -20,18 +20,26 @@ shared_examples_for 'a module configured attribute' do |attribute_name,default_v
             end
           end
 
-          its(attribute_name){ should == configured_value }
+          it "should have correct #{attribute_name}" do
+            expect(subject.send(attribute_name)).to eq(configured_value)
+          end
+
         end
 
         context 'without module configured #{attribute_name}' do
-          its(attribute_name){ should == default_value }
+
+          it "should have correct #{attribute_name}" do
+            expect(subject.send(attribute_name)).to eq(default_value)
+          end
         end
       end
 
       context 'with new #{attribute_name.to_s}' do
         let(:new_value){ 'userdude' }
 
-        its(attribute_name){ should == new_value }
+        it "should have correct #{attribute_name}" do
+          expect(subject.send(attribute_name)).to eq(new_value)
+        end
       end
     end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: g5_authentication_client
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Rob Revels
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-10 00:00:00.000000000 Z
+date: 2014-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: modelish
@@ -244,9 +244,17 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: g5_authentication_client
-rubygems_version: 2.2.0
+rubygems_version: 2.1.11
 signing_key: 
 specification_version: 4
 summary: Client for the G5 Auth service
-test_files: []
+test_files:
+- spec/g5_authentication_client/client_spec.rb
+- spec/g5_authentication_client/configuration_spec.rb
+- spec/g5_authentication_client/token_info_spec.rb
+- spec/g5_authentication_client/user_spec.rb
+- spec/g5_authentication_client_spec.rb
+- spec/spec_helper.rb
+- spec/support/module_configured_attribute.rb
+- spec/support/oauth_protected_resource.rb
 has_rdoc: