auth0 5.10.0 → 5.13.0

data/spec/lib/auth0/api/v2/clients_spec.rb

@@ -101,4 +101,55 @@ describe Auth0::Api::V2::Clients do
     it { expect { @instance.patch_client('', nil) }.to raise_error 'Must specify a client id' }
     it { expect { @instance.patch_client('some', nil) }.to raise_error 'Must specify a valid body' }
   end
+
+  context '.create_client_credentials' do
+    it { expect(@instance).to respond_to(:create_client_credentials) }
+
+    it 'is expected to send post to /api/v2/clients/1/credentials' do
+      payload = { credential_type: 'public_key', name: 'my credentials', pem: '' }
+
+      expect(@instance).to receive(:post).with('/api/v2/clients/1/credentials', payload)
+      expect { @instance.create_client_credentials('1', payload) }.not_to raise_error
+    end
+
+    it { expect { @instance.create_client_credentials('', nil) }.to raise_error 'Must specify a client id' }
+    it { expect { @instance.create_client_credentials('1', nil) }.to raise_error 'Must specify a valid body' }
+  end
+
+  context '.client_credentials' do
+    it { expect(@instance).to respond_to(:client_credentials) }
+    it { expect(@instance).to respond_to(:get_client_credentials) }
+
+    it 'is expected to send get to /api/v2/clients/1/credentials' do
+      expect(@instance).to receive(:get).with('/api/v2/clients/1/credentials')
+      expect { @instance.client_credentials('1') }.not_to raise_error 
+    end
+
+    it { expect { @instance.client_credentials('') }.to raise_error 'Must specify a client id' }
+  end
+
+  context '.client_credential' do
+    it { expect(@instance).to respond_to(:client_credential) }
+    it { expect(@instance).to respond_to(:get_client_credential) }
+
+    it 'is expected to send get to /api/v2/clients/1/credentials/2' do
+      expect(@instance).to receive(:get).with('/api/v2/clients/1/credentials/2')
+      expect { @instance.client_credential('1', '2') }.not_to raise_error
+    end
+
+    it { expect { @instance.client_credential('', '') }.to raise_error 'Must specify a client id' }
+    it { expect { @instance.client_credential('1', '') }.to raise_error 'Must specify a credential id' }
+  end
+
+  context '.delete_client_credential' do
+    it { expect(@instance).to respond_to(:delete_client_credential) }
+    
+    it 'is expected to delete /api/v2/clients/1/credentials/2' do
+      expect(@instance).to receive(:delete).with('/api/v2/clients/1/credentials/2')
+      expect { @instance.delete_client_credential('1', '2') }.not_to raise_error
+    end
+
+    it { expect { @instance.delete_client_credential('', '') }.to raise_error 'Must specify a client id' }
+    it { expect { @instance.delete_client_credential('1', '') }.to raise_error 'Must specify a credential id' }
+  end
 end

data/spec/lib/auth0/api/v2/users_spec.rb

@@ -583,4 +583,222 @@ describe Auth0::Api::V2::Users do
       end.not_to raise_error
     end
   end
+
+  context '.get_user_authentication_methods' do
+    it 'is expected to respond to user_authentication_methods method' do
+      expect(@instance).to respond_to(:user_authentication_methods)
+    end
+    
+    it 'is expected to respond to get_user_authentication_methods method' do
+      expect(@instance).to respond_to(:get_user_authentication_methods)
+    end
+
+    it 'is expected to raise an exception when the user ID is empty' do
+      expect { @instance.user_authentication_methods(nil) }.to raise_exception(Auth0::MissingUserId)
+    end
+
+    it 'is expected to get user authentication methods' do
+      expect(@instance).to receive(:get).with(
+        '/api/v2/users/USER_ID/authentication-methods', {
+        per_page: nil,
+        page: nil,
+        include_totals: nil
+        }
+      )
+
+      expect do
+        @instance.user_authentication_methods('USER_ID')
+      end.not_to raise_error
+    end
+
+    it 'is expected to get user authentication methods with paging' do
+      expect(@instance).to receive(:get).with(
+        '/api/v2/users/USER_ID/authentication-methods', {
+        per_page: 1,
+        page: 2,
+        include_totals: true
+        }
+      )
+
+      expect do
+        @instance.user_authentication_methods('USER_ID', per_page: 1, page: 2, include_totals: true)
+      end.not_to raise_error
+    end
+  end
+
+  context '.get_user_authentication_method' do
+    it 'is expected to respond to get_user_authentication_method' do
+      expect(@instance).to respond_to :user_authentication_method
+    end
+    
+    it 'is expected to respond to get_user_authentication_method' do
+      expect(@instance).to respond_to :get_user_authentication_method
+    end
+
+    it 'is expected to raise an exception for a missing user ID' do
+      expect { @instance.user_authentication_method(nil, nil) }.to raise_exception(Auth0::MissingUserId)
+    end
+
+    it 'is expected to raise an exception for a missing authentication method ID' do
+      expect { @instance.user_authentication_method('USER_ID', nil) }.to raise_exception(Auth0::MissingParameter)
+    end
+
+    it 'is expected to GET a user authentication method' do
+      expect(@instance).to receive(:get).with(
+        '/api/v2/users/USER_ID/authentication-methods/AUTH_METHOD_ID'
+      )
+
+      expect do
+        @instance.user_authentication_method('USER_ID', 'AUTH_METHOD_ID')
+      end.not_to raise_error
+
+    end
+  end
+
+  context '.create_user_authentication_method' do
+    it 'is expected to respond to create_user_authentication_method' do
+      expect(@instance).to respond_to :create_user_authentication_method
+    end
+
+    it 'is expected to respond to post_user_authentication_method' do
+      expect(@instance).to respond_to :post_user_authentication_method
+    end
+
+    it 'is expected to raise an exception for a missing user ID' do
+      expect { @instance.create_user_authentication_method(nil, nil) }.to raise_exception(Auth0::MissingUserId)
+    end
+
+    it 'is expected to raise an exception for a missing body' do
+      expect { @instance.create_user_authentication_method('USER_ID', nil) }.to raise_exception(Auth0::MissingParameter)
+    end
+
+    it 'is expected to send the body to the endpoint' do
+      body = {
+        type: 'phone'
+      }
+
+      expect(@instance).to receive(:post).with(
+        '/api/v2/users/USER_ID/authentication-methods',
+        body
+      )
+
+      expect do
+        @instance.create_user_authentication_method 'USER_ID', body
+      end.not_to raise_error
+    end
+  end
+
+  context '.put_all_user_authentication_methods' do
+    it 'is expected to respond to put_all_user_authentication_methods' do
+      expect(@instance).to respond_to(:put_all_user_authentication_methods)
+    end
+
+    it 'is expected to respond to update_all_user_authentication_methods' do
+      expect(@instance).to respond_to(:update_all_user_authentication_methods)
+    end
+
+    it 'is expected to raise an exception for a missing user ID' do
+      expect { @instance.put_all_user_authentication_methods(nil, nil) }.to raise_exception(Auth0::MissingUserId)
+    end
+
+    it 'is expected to raise an exception for a missing body' do
+      expect { @instance.put_all_user_authentication_methods('USER_ID', nil) }.to raise_exception(Auth0::MissingParameter)
+    end
+
+    it 'is expected to send the body to the endpoint' do
+      body = {
+        type: 'phone'
+      }
+      
+      expect(@instance).to receive(:put).with(
+        '/api/v2/users/USER_ID/authentication-methods',
+        [body]
+      )
+
+      expect do
+        @instance.put_all_user_authentication_methods 'USER_ID', [body]
+      end.to_not raise_error
+    end
+  end
+
+  context '.patch_user_authentication_method' do
+    it 'is expected to respond to patch_user_authentication_method' do
+      expect(@instance).to respond_to(:patch_user_authentication_method)
+    end
+
+    it 'is expected to respond to update_user_authentication_method' do
+      expect(@instance).to respond_to(:update_user_authentication_method)
+    end
+
+    it 'is expected to raise an exception for a missing user ID' do
+      expect { @instance.patch_user_authentication_method(nil, nil, nil) }.to raise_exception(Auth0::MissingUserId)
+    end
+
+    it 'is expected to raise an exception for a missing authentication_method_id' do
+      expect { @instance.patch_user_authentication_method('USER_ID', nil, nil) }.to raise_exception(Auth0::MissingParameter)
+    end
+
+    it 'is expected to raise an exception for a missing body' do
+      expect { @instance.patch_user_authentication_method('USER_ID', 'AUTH_METHOD_ID', nil) }.to raise_exception(Auth0::MissingParameter)
+    end
+
+    it 'is expected to send the body to the endpoint' do
+      body = {
+        name: 'auth method name'
+      }
+
+      expect(@instance).to receive(:patch).with(
+        '/api/v2/users/USER_ID/authentication-methods/AUTH_METHOD_ID',
+        body
+      )
+
+      expect do
+        @instance.patch_user_authentication_method 'USER_ID', 'AUTH_METHOD_ID', body
+      end.to_not raise_error
+    end
+  end
+  
+  context '.delete_user_authentication_methods' do
+    it 'is expected to respond to delete_user_authentication_methods' do
+      expect(@instance).to respond_to(:delete_user_authentication_methods)
+    end
+
+    it 'is expected to raise an exception for a missing user ID' do
+      expect { @instance.delete_user_authentication_methods(nil) }.to raise_exception(Auth0::MissingUserId)
+    end
+
+    it 'is expected to call the endpoint' do
+      expect(@instance).to receive(:delete).with(
+        '/api/v2/users/USER_ID/authentication-methods'
+      )
+
+      expect do
+        @instance.delete_user_authentication_methods 'USER_ID'
+      end.to_not raise_error
+    end
+  end
+
+  context '.delete_user_authentication_method' do
+    it 'is expected to respond to delete_user_authentication_method' do
+      expect(@instance).to respond_to(:delete_user_authentication_method)
+    end
+
+    it 'is expected to raise an exception for a missing user ID' do
+      expect { @instance.delete_user_authentication_method(nil, nil) }.to raise_exception(Auth0::MissingUserId)
+    end
+
+    it 'is expected to raise an exception for a missing authentication_method_id' do
+      expect { @instance.delete_user_authentication_method('USER_ID', nil) }.to raise_exception(Auth0::MissingParameter)
+    end
+
+    it 'is expected to call the endpoint' do
+      expect(@instance).to receive(:delete).with(
+        '/api/v2/users/USER_ID/authentication-methods/AUTH_METHOD_ID'
+      )
+
+      expect do
+        @instance.delete_user_authentication_method 'USER_ID', 'AUTH_METHOD_ID'
+      end.to_not raise_error
+    end
+  end
 end

data/spec/lib/auth0/mixins/httpproxy_spec.rb

@@ -250,25 +250,37 @@ describe Auth0::Mixins::HTTPProxy do
     end
   end
 
-  %i(post put patch).each do |http_method|
+  def expected_payload(method, overrides = {})
+    if method == :post_form
+      {
+        method: :post,
+        url: 'https://auth0.com/test',
+        timeout: nil,
+        headers: nil,
+        payload: {}
+      }.merge(overrides)
+    else 
+      {
+        method: method,
+        url: 'https://auth0.com/test',
+        timeout: nil,
+        headers: nil,
+        payload: '{}'
+      }.merge(overrides)
+    end
+  end
+
+  %i(post post_form put patch).each do |http_method|
     context ".#{http_method}" do
       it { expect(@instance).to respond_to(http_method.to_sym) }
-      it "should call send http #{http_method} method to path defined through HTTP" do
-        expect(RestClient::Request).to receive(:execute).with(method: http_method,
-                                                              url: 'https://auth0.com/test',
-                                                              timeout: nil,
-                                                              headers: nil,
-                                                              payload: '{}')
+      it "should call send http #{http_method} method to path defined through HTTP"do
+        expect(RestClient::Request).to receive(:execute).with(expected_payload(http_method))
           .and_return(StubResponse.new({}, true, 200))
         expect { @instance.send(http_method, '/test') }.not_to raise_error
       end
 
       it 'should not raise exception if data returned not in json format (should be fixed in v2)' do
-        allow(RestClient::Request).to receive(:execute).with(method: http_method,
-                                                             url: 'https://auth0.com/test',
-                                                             timeout: nil,
-                                                             headers: nil,
-                                                             payload: '{}')
+        allow(RestClient::Request).to receive(:execute).with(expected_payload(http_method))
           .and_return(StubResponse.new('Some random text here', true, 200))
         expect { @instance.send(http_method, '/test') }.not_to raise_error
         expect(@instance.send(http_method, '/test')).to eql('Some random text here')
@@ -277,11 +289,7 @@ describe Auth0::Mixins::HTTPProxy do
       it "should raise Auth0::Unauthorized on send http #{http_method} method
         to path defined through HTTP when 401 status received" do
         @exception.response = StubResponse.new({}, false, 401)
-        allow(RestClient::Request).to receive(:execute).with(method: http_method,
-                                                             url: 'https://auth0.com/test',
-                                                             timeout: nil,
-                                                             headers: nil,
-                                                             payload: '{}')
+        allow(RestClient::Request).to receive(:execute).with(expected_payload(http_method))
           .and_raise(@exception)
         expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::Unauthorized)
       end
@@ -294,11 +302,7 @@ describe Auth0::Mixins::HTTPProxy do
           :x_ratelimit_reset     => 1560564149
         }
         @exception.response = StubResponse.new({}, false, 429,headers)
-        allow(RestClient::Request).to receive(:execute).with(method: http_method,
-                                                             url: 'https://auth0.com/test',
-                                                             timeout: nil,
-                                                             headers: nil,
-                                                             payload: '{}')
+        allow(RestClient::Request).to receive(:execute).with(expected_payload(http_method))
           .and_raise(@exception)
         expect { @instance.send(http_method, '/test') }.to raise_error { |error|
           expect(error).to be_a(Auth0::RateLimitEncountered)
@@ -317,11 +321,7 @@ describe Auth0::Mixins::HTTPProxy do
       it "should raise Auth0::NotFound on send http #{http_method} method
         to path defined through HTTP when 404 status received" do
         @exception.response = StubResponse.new({}, false, 404)
-        allow(RestClient::Request).to receive(:execute).with(method: http_method,
-                                                             url: 'https://auth0.com/test',
-                                                             timeout: nil,
-                                                             headers: nil,
-                                                             payload: '{}')
+        allow(RestClient::Request).to receive(:execute).with(expected_payload(http_method))
           .and_raise(@exception)
         expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::NotFound)
       end
@@ -329,22 +329,14 @@ describe Auth0::Mixins::HTTPProxy do
       it "should raise Auth0::Unsupported on send http #{http_method} method
         to path defined through HTTP when 418 or other unknown status received" do
         @exception.response = StubResponse.new({}, false, 418)
-        allow(RestClient::Request).to receive(:execute).with(method: http_method,
-                                                             url: 'https://auth0.com/test',
-                                                             timeout: nil,
-                                                             headers: nil,
-                                                             payload: '{}')
+        allow(RestClient::Request).to receive(:execute).with(expected_payload(http_method))
           .and_raise(@exception)
         expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::Unsupported)
       end
 
       it "should raise Auth0::RequestTimeout on send http #{http_method} method
         to path defined through HTTP when RestClient::RequestTimeout received" do
-        allow(RestClient::Request).to receive(:execute).with(method: http_method,
-                                                             url: 'https://auth0.com/test',
-                                                             timeout: nil,
-                                                             headers: nil,
-                                                             payload: '{}')
+        allow(RestClient::Request).to receive(:execute).with(expected_payload(http_method))
           .and_raise(RestClient::Exceptions::OpenTimeout.new)
         expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::RequestTimeout)
       end
@@ -352,11 +344,7 @@ describe Auth0::Mixins::HTTPProxy do
       it "should raise Auth0::BadRequest on send http #{http_method} method
         to path defined through HTTP when 400 status received" do
         @exception.response = StubResponse.new({}, false, 400)
-        allow(RestClient::Request).to receive(:execute).with(method: http_method,
-                                                             url: 'https://auth0.com/test',
-                                                             timeout: nil,
-                                                             headers: nil,
-                                                             payload: '{}')
+        allow(RestClient::Request).to receive(:execute).with(expected_payload(http_method))
           .and_raise(@exception)
         expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::BadRequest)
       end
@@ -364,20 +352,13 @@ describe Auth0::Mixins::HTTPProxy do
       it "should raise Auth0::ServerError on send http #{http_method} method
         to path defined through HTTP when 500 received" do
         @exception.response = StubResponse.new({}, false, 500)
-        allow(RestClient::Request).to receive(:execute).with(method: http_method, url: 'https://auth0.com/test',
-                                                             timeout: nil,
-                                                             headers: nil,
-                                                             payload: '{}')
+        allow(RestClient::Request).to receive(:execute).with(expected_payload(http_method))
           .and_raise(@exception)
         expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::ServerError)
       end
 
       it 'should normalize path with Addressable::URI' do
-        expect(RestClient::Request).to receive(:execute).with(method: http_method,
-                                                              url: 'https://auth0.com/te%20st',
-                                                              timeout: nil,
-                                                              headers: nil,
-                                                              payload: '{}')
+        expect(RestClient::Request).to receive(:execute).with(expected_payload(http_method, url: 'https://auth0.com/te%20st'))
           .and_return(StubResponse.new({}, true, 200))
         expect { @instance.send(http_method, '/te st') }.not_to raise_error
       end
@@ -388,11 +369,7 @@ describe Auth0::Mixins::HTTPProxy do
                             'message' => "Path validation error: 'String does not match pattern ^.+\\|.+$:
                                             3241312' on property id (The user_id of the user to retrieve).",
                             'errorCode' => 'invalid_uri')
-        expect(RestClient::Request).to receive(:execute).with(method: http_method,
-                                                              url: 'https://auth0.com/test',
-                                                              timeout: nil,
-                                                              headers: nil,
-                                                              payload: '{}')
+        expect(RestClient::Request).to receive(:execute).with(expected_payload(http_method))
           .and_return(StubResponse.new(res, true, 404))
         expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::NotFound, res)
       end
@@ -404,11 +381,7 @@ describe Auth0::Mixins::HTTPProxy do
           retry_instance.base_uri = "https://auth0.com"
 
           @exception.response = StubResponse.new({}, false, 429)
-          allow(RestClient::Request).to receive(:execute).with(method: http_method,
-                                                              url: 'https://auth0.com/test',
-                                                              timeout: nil,
-                                                              headers: nil,
-                                                              payload: '{}')
+          allow(RestClient::Request).to receive(:execute).with(expected_payload(http_method))
             .and_raise(@exception)
           expect(RestClient::Request).to receive(:execute).exactly(4).times
 
@@ -424,11 +397,7 @@ describe Auth0::Mixins::HTTPProxy do
           retry_instance.retry_count = 2
 
           @exception.response = StubResponse.new({}, false, 429)
-          allow(RestClient::Request).to receive(:execute).with(method: http_method,
-                                                              url: 'https://auth0.com/test',
-                                                              timeout: nil,
-                                                              headers: nil,
-                                                              payload: '{}')
+          allow(RestClient::Request).to receive(:execute).with(expected_payload(http_method))
             .and_raise(@exception)
           expect(RestClient::Request).to receive(:execute).exactly(3).times
 
@@ -445,11 +414,7 @@ describe Auth0::Mixins::HTTPProxy do
 
           @exception.response = StubResponse.new({}, false, 429)
 
-          allow(RestClient::Request).to receive(:execute).with(method: http_method,
-                                                              url: 'https://auth0.com/test',
-                                                              timeout: nil,
-                                                              headers: nil,
-                                                              payload: '{}')
+          allow(RestClient::Request).to receive(:execute).with(expected_payload(http_method))
             .and_raise(@exception)
           
           expect(RestClient::Request).to receive(:execute).exactly(1).times
@@ -467,11 +432,7 @@ describe Auth0::Mixins::HTTPProxy do
           @time_start
 
           @exception.response = StubResponse.new({}, false, 429)
-          allow(RestClient::Request).to receive(:execute).with(method: http_method,
-                                                               url: 'https://auth0.com/test',
-                                                               timeout: nil,
-                                                               headers: nil,
-                                                               payload: '{}') do
+          allow(RestClient::Request).to receive(:execute).with(expected_payload(http_method)) do
 
             time_entries.push(Time.now.to_f - @time_start.to_f)
             @time_start = Time.now.to_f # restart the clock
@@ -492,6 +453,7 @@ describe Auth0::Mixins::HTTPProxy do
       end
     end
   end
+end
 
   context "Renewing tokens" do
     let(:httpproxy_instance) {
@@ -546,7 +508,6 @@ describe Auth0::Mixins::HTTPProxy do
         end
       end
     end
-  end
 
   context "Using cached tokens" do
     let(:httpproxy_instance) {

data/spec/lib/auth0/mixins/initializer_spec.rb

@@ -13,6 +13,15 @@ describe Auth0::Mixins::Initializer do
   let(:params) { { namespace: 'samples.auth0.com' } }
   let(:instance) { DummyClassForProxy.send(:include, described_class).new(params) }
   let(:time_now) { Time.now }
+  
+  let(:client_assertion_signing_key_pair) do
+    rsa_private = OpenSSL::PKey::RSA.generate 2048
+
+    { 
+      public_key: rsa_private.public_key,
+      private_key: rsa_private
+    }
+  end
 
   context 'api v2' do
     it 'sets retry_count when passed' do
@@ -45,31 +54,76 @@ describe Auth0::Mixins::Initializer do
       expect(instance.instance_variable_get('@token')).to eq('123')
     end
 
-    it 'fetches a token if none was given' do
-      params[:client_id] = client_id = 'test_client_id'
-      params[:client_secret] = client_secret = 'test_client_secret'
-      params[:api_identifier] = api_identifier = 'test'
-
-      payload = {
-        grant_type: 'client_credentials',
-        client_id: client_id,
-        client_secret: client_secret,
-        audience: api_identifier
-      }  
-
-      expect(RestClient::Request).to receive(:execute).with(hash_including(
-        method: :post,
-        url: 'https://samples.auth0.com/oauth/token',
-        payload: payload.to_json
-      ))
-      .and_return(StubResponse.new({ 
-        "access_token" => "test", 
-        "expires_in" => 86400}, 
-        true, 
-        200))
-
-      expect(instance.instance_variable_get('@token')).to eq('test')
-      expect(instance.instance_variable_get('@token_expires_at')).to eq(time_now.to_i + 86400)
+    context 'with a client secret' do
+      it 'fetches a token if none was given' do
+        params[:client_id] = client_id = 'test_client_id'
+        params[:client_secret] = client_secret = 'test_client_secret'
+        params[:api_identifier] = api_identifier = 'test'
+
+        payload = {
+          grant_type: 'client_credentials',
+          client_id: client_id,
+          client_secret: client_secret,
+          audience: api_identifier
+        }  
+
+        expect(RestClient::Request).to receive(:execute) do |arg|
+          expect(arg).to(match(
+            include(
+              method: :post,
+              url: 'https://samples.auth0.com/oauth/token'
+            )
+          ))
+
+          expect(JSON.parse(arg[:payload], { symbolize_names: true })).to eq(payload)
+          
+          StubResponse.new({ 
+          "access_token" => "test", 
+          "expires_in" => 86400}, 
+          true, 
+          200)
+        end
+
+        expect(instance.instance_variable_get('@token')).to eq('test')
+        expect(instance.instance_variable_get('@token_expires_at')).to eq(time_now.to_i + 86400)
+      end
+    end
+
+    context 'with a client assertion signing key' do
+      it 'fetches a token if none was given' do
+        private_key = client_assertion_signing_key_pair[:private_key]
+
+        params[:client_id] = client_id = 'test_client_id'
+        params[:api_identifier] = api_identifier = 'test'
+        params[:client_assertion_signing_key] = private_key
+
+        expect(RestClient::Request).to receive(:execute) do |arg|
+          expect(arg).to(match(
+            include(
+              method: :post,
+              url: 'https://samples.auth0.com/oauth/token'
+            )
+          ))
+
+          payload = JSON.parse(arg[:payload], { symbolize_names: true })
+
+          expect(payload[:grant_type]).to eq 'client_credentials'
+          expect(payload[:client_id]).to eq client_id
+          expect(payload[:audience]).to eq api_identifier
+          expect(payload[:client_secret]).to be_nil
+          expect(payload[:client_assertion]).not_to be_nil
+          expect(payload[:client_assertion_type]).to eq Auth0::ClientAssertion::CLIENT_ASSERTION_TYPE
+          
+          StubResponse.new({ 
+          "access_token" => "test", 
+          "expires_in" => 86400}, 
+          true, 
+          200)
+        end
+
+        expect(instance.instance_variable_get('@token')).to eq('test')
+        expect(instance.instance_variable_get('@token_expires_at')).to eq(time_now.to_i + 86400)
+      end
     end
 
     it "doesn't get a new token if one was supplied using 'token'" do