auth0 5.2.0 → 5.6.0

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

@@ -5,6 +5,9 @@ describe Auth0::Mixins::HTTPProxy do
   before :each do
     dummy_instance = DummyClassForProxy.new
     dummy_instance.extend(Auth0::Mixins::HTTPProxy)
+    dummy_instance.base_uri = "https://auth0.com"
+    dummy_instance.retry_count = 0
+
     @instance = dummy_instance
     @exception = DummyClassForRestClient.new
   end
@@ -14,7 +17,7 @@ describe Auth0::Mixins::HTTPProxy 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: '/test',
+                                                              url: 'https://auth0.com/test',
                                                               timeout: nil,
                                                               headers: { params: {} },
                                                               payload: nil)
@@ -24,7 +27,7 @@ describe Auth0::Mixins::HTTPProxy do
 
       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: '/test',
+                                                             url: 'https://auth0.com/test',
                                                              timeout: nil,
                                                              headers: { params: {} },
                                                              payload: nil)
@@ -36,7 +39,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
         expect(RestClient::Request).to receive(:execute).with(method: http_method,
-                                                              url: '/test',
+                                                              url: 'https://auth0.com/test',
                                                               timeout: nil,
                                                               headers: { params: {} },
                                                               payload: nil)
@@ -47,7 +50,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
         expect(RestClient::Request).to receive(:execute).with(method: http_method,
-                                                              url: '/test',
+                                                              url: 'https://auth0.com/test',
                                                               timeout: nil,
                                                               headers: { params: {} },
                                                               payload: nil)
@@ -58,7 +61,7 @@ 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
         expect(RestClient::Request).to receive(:execute).with(method: http_method,
-                                                              url: '/test',
+                                                              url: 'https://auth0.com/test',
                                                               timeout: nil,
                                                               headers: { params: {} },
                                                               payload: nil)
@@ -69,7 +72,7 @@ describe Auth0::Mixins::HTTPProxy do
       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: '/test',
+                                                             url: 'https://auth0.com/test',
                                                              timeout: nil,
                                                              headers: { params: {} },
                                                              payload: nil)
@@ -81,7 +84,7 @@ describe Auth0::Mixins::HTTPProxy do
         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: '/test',
+                                                             url: 'https://auth0.com/test',
                                                              timeout: nil,
                                                              headers: { params: {} },
                                                              payload: nil)
@@ -93,7 +96,7 @@ describe Auth0::Mixins::HTTPProxy do
         to path defined through HTTP when 403" do
         @exception.response = StubResponse.new({}, false, 403)
         allow(RestClient::Request).to receive(:execute).with(method: http_method,
-                                                             url: '/test',
+                                                             url: 'https://auth0.com/test',
                                                              timeout: nil,
                                                              headers: { params: {} },
                                                              payload: nil)
@@ -110,7 +113,7 @@ describe Auth0::Mixins::HTTPProxy do
         }
         @exception.response = StubResponse.new({}, false, 429, headers)
         allow(RestClient::Request).to receive(:execute).with(method: http_method,
-                                                             url: '/test',
+                                                             url: 'https://auth0.com/test',
                                                              timeout: nil,
                                                              headers: { params: {} },
                                                              payload: nil)
@@ -133,7 +136,7 @@ describe Auth0::Mixins::HTTPProxy do
         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: '/test',
+                                                             url: 'https://auth0.com/test',
                                                              timeout: nil,
                                                              headers: { params: {} },
                                                              payload: nil)
@@ -141,14 +144,108 @@ describe Auth0::Mixins::HTTPProxy do
         expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::ServerError)
       end
 
-      it 'should escape path with Addressable::URI.escape' do
+      it 'should normalize path with Addressable::URI' do
         expect(RestClient::Request).to receive(:execute).with(method: http_method,
-                                                              url: '/te%20st',
+                                                              url: 'https://auth0.com/te%20st%23test',
                                                               timeout: nil,
                                                               headers: { params: {} },
                                                               payload: nil)
           .and_return(StubResponse.new({}, true, 200))
-        expect { @instance.send(http_method, '/te st') }.not_to raise_error
+        expect { @instance.send(http_method, '/te st#test') }.not_to raise_error
+      end
+
+      context "when status 429 is recieved on send http #{http_method} method" do
+        it "should retry 3 times when retry_count is not set" do
+          retry_instance = DummyClassForProxy.new
+          retry_instance.extend(Auth0::Mixins::HTTPProxy)
+          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: { params: {} },
+                                                              payload: nil)
+            .and_raise(@exception)
+          expect(RestClient::Request).to receive(:execute).exactly(4).times
+
+          expect { retry_instance.send(http_method, '/test') }.to raise_error { |error|
+            expect(error).to be_a(Auth0::RateLimitEncountered)
+          }
+        end
+
+        it "should retry 2 times when retry_count is set to 2" do
+          retry_instance = DummyClassForProxy.new
+          retry_instance.extend(Auth0::Mixins::HTTPProxy)
+          retry_instance.base_uri = "https://auth0.com"
+          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: { params: {} },
+                                                              payload: nil)
+            .and_raise(@exception)
+          expect(RestClient::Request).to receive(:execute).exactly(3).times
+
+          expect { retry_instance.send(http_method, '/test') }.to raise_error { |error|
+            expect(error).to be_a(Auth0::RateLimitEncountered)
+          }
+        end
+
+        it "should not retry when retry_count is set to 0" do
+          retry_instance = DummyClassForProxy.new
+          retry_instance.extend(Auth0::Mixins::HTTPProxy)
+          retry_instance.base_uri = "https://auth0.com"
+          retry_instance.retry_count = 0
+
+          @exception.response = StubResponse.new({}, false, 429)
+
+          allow(RestClient::Request).to receive(:execute).with(method: http_method,
+                                                              url: 'https://auth0.com/test',
+                                                              timeout: nil,
+                                                              headers: { params: {} },
+                                                              payload: nil)
+            .and_raise(@exception)
+          
+          expect(RestClient::Request).to receive(:execute).exactly(1).times
+          expect { retry_instance.send(http_method, '/test') }.to raise_error { |error|
+            expect(error).to be_a(Auth0::RateLimitEncountered)
+          }
+        end
+
+        it "should have have random retry times grow with jitter backoff" do
+          retry_instance = DummyClassForProxy.new
+          retry_instance.extend(Auth0::Mixins::HTTPProxy)
+          retry_instance.base_uri = "https://auth0.com"
+          retry_instance.retry_count = 2
+          time_entries = []
+          @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: { params: {} },
+                                                               payload: nil) do
+
+            time_entries.push(Time.now.to_f - @time_start.to_f)
+            @time_start = Time.now.to_f # restart the clock
+            raise @exception
+          end
+
+          @time_start = Time.now.to_f #start the clock
+          retry_instance.send(http_method, '/test') rescue nil
+          time_entries_first_set = time_entries.shift(time_entries.length)
+
+          retry_instance.send(http_method, '/test') rescue nil
+          time_entries.each_with_index do |entry, index|
+            if index > 0 #skip the first request
+              expect(entry != time_entries_first_set[index])
+            end
+          end
+        end
       end
     end
   end
@@ -158,7 +255,7 @@ describe Auth0::Mixins::HTTPProxy 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: '/test',
+                                                              url: 'https://auth0.com/test',
                                                               timeout: nil,
                                                               headers: nil,
                                                               payload: '{}')
@@ -168,7 +265,7 @@ describe Auth0::Mixins::HTTPProxy do
 
       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: '/test',
+                                                             url: 'https://auth0.com/test',
                                                              timeout: nil,
                                                              headers: nil,
                                                              payload: '{}')
@@ -181,7 +278,7 @@ describe Auth0::Mixins::HTTPProxy do
         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: '/test',
+                                                             url: 'https://auth0.com/test',
                                                              timeout: nil,
                                                              headers: nil,
                                                              payload: '{}')
@@ -198,7 +295,7 @@ describe Auth0::Mixins::HTTPProxy do
         }
         @exception.response = StubResponse.new({}, false, 429,headers)
         allow(RestClient::Request).to receive(:execute).with(method: http_method,
-                                                             url: '/test',
+                                                             url: 'https://auth0.com/test',
                                                              timeout: nil,
                                                              headers: nil,
                                                              payload: '{}')
@@ -221,7 +318,7 @@ describe Auth0::Mixins::HTTPProxy do
         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: '/test',
+                                                             url: 'https://auth0.com/test',
                                                              timeout: nil,
                                                              headers: nil,
                                                              payload: '{}')
@@ -233,7 +330,7 @@ describe Auth0::Mixins::HTTPProxy do
         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: '/test',
+                                                             url: 'https://auth0.com/test',
                                                              timeout: nil,
                                                              headers: nil,
                                                              payload: '{}')
@@ -244,7 +341,7 @@ describe Auth0::Mixins::HTTPProxy do
       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: '/test',
+                                                             url: 'https://auth0.com/test',
                                                              timeout: nil,
                                                              headers: nil,
                                                              payload: '{}')
@@ -256,7 +353,7 @@ describe Auth0::Mixins::HTTPProxy do
         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: '/test',
+                                                             url: 'https://auth0.com/test',
                                                              timeout: nil,
                                                              headers: nil,
                                                              payload: '{}')
@@ -267,7 +364,7 @@ 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: '/test',
+        allow(RestClient::Request).to receive(:execute).with(method: http_method, url: 'https://auth0.com/test',
                                                              timeout: nil,
                                                              headers: nil,
                                                              payload: '{}')
@@ -275,9 +372,9 @@ describe Auth0::Mixins::HTTPProxy do
         expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::ServerError)
       end
 
-      it 'should escape path with Addressable::URI.escape' do
+      it 'should normalize path with Addressable::URI' do
         expect(RestClient::Request).to receive(:execute).with(method: http_method,
-                                                              url: '/te%20st',
+                                                              url: 'https://auth0.com/te%20st',
                                                               timeout: nil,
                                                               headers: nil,
                                                               payload: '{}')
@@ -292,13 +389,211 @@ describe Auth0::Mixins::HTTPProxy do
                                             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: '/test',
+                                                              url: 'https://auth0.com/test',
                                                               timeout: nil,
                                                               headers: nil,
                                                               payload: '{}')
           .and_return(StubResponse.new(res, true, 404))
         expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::NotFound, res)
       end
+
+      context "when status 429 is recieved on send http #{http_method} method" do
+        it "should retry 3 times when retry_count is not set" do
+          retry_instance = DummyClassForProxy.new
+          retry_instance.extend(Auth0::Mixins::HTTPProxy)
+          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: '{}')
+            .and_raise(@exception)
+          expect(RestClient::Request).to receive(:execute).exactly(4).times
+
+          expect { retry_instance.send(http_method, '/test') }.to raise_error { |error|
+            expect(error).to be_a(Auth0::RateLimitEncountered)
+          }
+        end
+
+        it "should retry 2 times when retry_count is set to 2" do
+          retry_instance = DummyClassForProxy.new
+          retry_instance.extend(Auth0::Mixins::HTTPProxy)
+          retry_instance.base_uri = "https://auth0.com"
+          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: '{}')
+            .and_raise(@exception)
+          expect(RestClient::Request).to receive(:execute).exactly(3).times
+
+          expect { retry_instance.send(http_method, '/test') }.to raise_error { |error|
+            expect(error).to be_a(Auth0::RateLimitEncountered)
+          }
+        end
+
+        it "should not retry when retry_count is set to 0" do
+          retry_instance = DummyClassForProxy.new
+          retry_instance.extend(Auth0::Mixins::HTTPProxy)
+          retry_instance.base_uri = "https://auth0.com"
+          retry_instance.retry_count = 0
+
+          @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: '{}')
+            .and_raise(@exception)
+          
+          expect(RestClient::Request).to receive(:execute).exactly(1).times
+          expect { retry_instance.send(http_method, '/test') }.to raise_error { |error|
+            expect(error).to be_a(Auth0::RateLimitEncountered)
+          }
+        end
+
+        it "should have have random retry times grow with jitter backoff" do
+          retry_instance = DummyClassForProxy.new
+          retry_instance.extend(Auth0::Mixins::HTTPProxy)
+          retry_instance.base_uri = "https://auth0.com"
+          retry_instance.retry_count = 2
+          time_entries = []
+          @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
+
+            time_entries.push(Time.now.to_f - @time_start.to_f)
+            @time_start = Time.now.to_f # restart the clock
+            raise @exception
+          end
+
+          @time_start = Time.now.to_f #start the clock
+          retry_instance.send(http_method, '/test') rescue nil
+          time_entries_first_set = time_entries.shift(time_entries.length)
+
+          retry_instance.send(http_method, '/test') rescue nil
+          time_entries.each_with_index do |entry, index|
+            if index > 0 #skip the first request
+              expect(entry != time_entries_first_set[index])
+            end
+          end
+        end
+      end
+    end
+  end
+
+  context "Renewing tokens" do
+    before :each do
+      @token_instance = DummyClassForTokens.new(
+        client_id: 'test-client-id',
+        client_secret: 'test-client-secret',
+        domain: 'auth0.com')
+    end
+
+    %i(get delete).each do |http_method|
+      context "for #{http_method}" do
+        it 'should renew the token' do
+          expect(RestClient::Request).to receive(:execute).with(hash_including(
+            method: :post,
+            url: 'https://auth0.com/oauth/token',
+          ) ).and_return(StubResponse.new({ 
+            "access_token" => "access_token", 
+            "expires_in" => 86400}, 
+            true, 
+            200))
+
+          expect(RestClient::Request).to receive(:execute).with(hash_including(
+            method: http_method,
+            url: 'https://auth0.com/test',
+            headers: { params: {}, "Authorization" => "Bearer access_token" }
+          )).and_return(StubResponse.new('Some random text here', true, 200))
+
+          expect { @token_instance.send(http_method, '/test') }.not_to raise_error
+        end
+      end
+    end
+
+    %i(post put patch).each do |http_method|
+      context "for #{http_method}" do
+        it 'should renew the token' do
+          expect(RestClient::Request).to receive(:execute).with(hash_including(
+            method: :post,
+            url: 'https://auth0.com/oauth/token',
+          ) ).and_return(StubResponse.new({ 
+            "access_token" => "access_token", 
+            "expires_in" => 86400}, 
+            true, 
+            200))
+
+          expect(RestClient::Request).to receive(:execute).with(hash_including(
+            method: http_method,
+            url: 'https://auth0.com/test',
+            headers: { "Authorization" => "Bearer access_token" }
+          )).and_return(StubResponse.new('Some random text here', true, 200))
+
+          expect { @token_instance.send(http_method, '/test') }.not_to raise_error
+        end
+      end
+    end
+  end
+
+  context "Using cached tokens" do
+    before :each do
+      @token_instance = DummyClassForTokens.new(
+        client_id: 'test-client-id',
+        client_secret: 'test-client-secret',
+        domain: 'auth0.com',
+        token: 'access_token',
+        token_expires_at: Time.now.to_i + 86400)
+    end
+
+    %i(get delete).each do |http_method|
+      context "for #{http_method}" do
+        it 'should use the cached token' do
+          expect(RestClient::Request).not_to receive(:execute).with(hash_including(
+            method: :post,
+            url: 'https://auth0.com/oauth/token',
+          ))
+
+          expect(RestClient::Request).to receive(:execute).with(hash_including(
+            method: http_method,
+            url: 'https://auth0.com/test',
+            headers: { params: {}, "Authorization" => "Bearer access_token" }
+          )).and_return(StubResponse.new('Some random text here', true, 200))
+
+          expect { @token_instance.send(http_method, '/test') }.not_to raise_error
+        end
+      end
+    end
+
+    %i(post put patch).each do |http_method|
+      context "for #{http_method}" do
+        it 'should use the cached token' do
+          expect(RestClient::Request).not_to receive(:execute).with(hash_including(
+            method: :post,
+            url: 'https://auth0.com/oauth/token',
+          ))
+
+          expect(RestClient::Request).to receive(:execute).with(hash_including(
+            method: http_method,
+            url: 'https://auth0.com/test',
+            headers: { "Authorization" => "Bearer access_token" }
+          )).and_return(StubResponse.new('Some random text here', true, 200))
+
+          expect { @token_instance.send(http_method, '/test') }.not_to raise_error
+        end
+      end
     end
   end
 end

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

@@ -1,18 +1,36 @@
 require 'spec_helper'
+require 'timecop'
 
 class MockClass
   attr_reader :token
   include Auth0::Mixins::Initializer
   include Auth0::Mixins::HTTPProxy
   include Auth0::Mixins::Headers
+  include Auth0::Mixins::TokenManagement
 end
 
 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 }
+
   context 'api v2' do
+    it 'sets retry_count when passed' do
+      params[:token] = '123'
+      params[:retry_count] = 10
+
+      expect(instance.instance_variable_get('@retry_count')).to eq(10)
+    end
+  end
+
+  context 'token initialization' do
     before do
       params[:api_version] = 2
+      Timecop.freeze(time_now)
+    end
+
+    after do
+      Timecop.return
     end
 
     it 'sets token when access_token is passed' do
@@ -26,5 +44,74 @@ 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)
+    end
+
+    it "doesn't get a new token if one was supplied using 'token'" do
+      params[:token] = 'access-token'
+
+      expect(RestClient::Request).not_to receive(:execute).with(hash_including(
+          method: :post,
+          url: 'https://samples.auth0.com/oauth/token',
+      ))
+
+      expect(instance.instance_variable_get('@token')).to eq('access-token')
+      expect(instance.instance_variable_get('@token_expires_at')).to eq(Time.now.to_i + 3600)
+    end
+
+    it "doesn't get a new token if one was supplied using 'access_token'" do
+      params[:access_token] = 'access-token'
+
+      expect(RestClient::Request).not_to receive(:execute).with(hash_including(
+          method: :post,
+          url: 'https://samples.auth0.com/oauth/token',
+      ))
+
+      expect(instance.instance_variable_get('@token')).to eq('access-token')
+      expect(instance.instance_variable_get('@token_expires_at')).to eq(Time.now.to_i + 3600)
+    end
+
+    it 'can supply token_expires_at option' do
+      params[:token] = 'access-token'
+      params[:token_expires_at] = time_now.to_i + 300
+
+      expect(RestClient::Request).not_to receive(:execute).with(hash_including(
+          method: :post,
+          url: 'https://samples.auth0.com/oauth/token',
+      ))
+
+      expect(instance.instance_variable_get('@token')).to eq('access-token')
+      expect(instance.instance_variable_get('@token_expires_at')).to eq(time_now.to_i + 300)
+    end
+
+    it 'throws if no token or credentials were given' do
+      params[:client_id] = 'test-client-id'
+      expect { instance }.to raise_error(Auth0::InvalidCredentials)
+    end
   end
 end