auth0 5.1.2 → 5.5.0

data/spec/fixtures/vcr_cassettes/Auth0_Api_V2_Connections/create_test_connection.yml

@@ -12,54 +12,66 @@ http_interactions:
       Accept-Encoding:
       - gzip, deflate
       User-Agent:
-      - Ruby/2.3.1
+      - rest-client/2.0.2 (darwin20.2.0 x86_64) ruby/2.7.2p137
       Content-Type:
       - application/json
       Auth0-Client:
-      - eyJuYW1lIjoicnVieS1hdXRoMCIsInZlcnNpb24iOiI0LjUuMCJ9
+      - eyJuYW1lIjoicnVieS1hdXRoMCIsInZlcnNpb24iOiI1LjEuMiIsImVudiI6eyJydWJ5IjoiMi43LjIifX0=
       Authorization:
       - Bearer API_TOKEN
       Content-Length:
       - '53'
-      Host:
-      - auth0-sdk-tests.auth0.com
   response:
     status:
       code: 201
       message: Created
     headers:
       Date:
-      - Fri, 05 Oct 2018 20:16:25 GMT
+      - Tue, 20 Jul 2021 02:06:03 GMT
       Content-Type:
       - application/json; charset=utf-8
       Transfer-Encoding:
       - chunked
       Connection:
       - keep-alive
-      X-Ratelimit-Limit:
-      - '10'
-      X-Ratelimit-Remaining:
-      - '9'
-      X-Ratelimit-Reset:
-      - '1538770587'
-      Vary:
-      - origin,accept-encoding
+      Cf-Ray:
+      - 6718a0c42c0a323a-LAX
       Cache-Control:
-      - private, no-store, no-cache, must-revalidate, post-check=0, pre-check=0
+      - no-cache
       Content-Encoding:
       - gzip
       Strict-Transport-Security:
-      - max-age=15724800
-      X-Robots-Tag:
-      - noindex, nofollow, nosnippet, noarchive
+      - max-age=31536000
+      Vary:
+      - origin,accept-encoding
+      Cf-Cache-Status:
+      - DYNAMIC
+      Expect-Ct:
+      - max-age=604800, report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct"
+      Ot-Baggage-Auth0-Request-Id:
+      - 6718a0c42c0a323a
+      Ot-Tracer-Sampled:
+      - 'true'
+      Ot-Tracer-Spanid:
+      - 672b1d28532dec55
+      Ot-Tracer-Traceid:
+      - 1552b04c1ec626a6
+      X-Content-Type-Options:
+      - nosniff
+      X-Ratelimit-Limit:
+      - '50'
+      X-Ratelimit-Remaining:
+      - '49'
+      X-Ratelimit-Reset:
+      - '1626746764'
+      Server:
+      - cloudflare
+      Alt-Svc:
+      - h3-27=":443"; ma=86400, h3-28=":443"; ma=86400, h3-29=":443"; ma=86400, h3=":443";
+        ma=86400
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        H4sIAAAAAAAAA3WPQUvEQAyF/0vOFRYRlB4V9iQii+hhWYbpNK0DM0lJMl3K
-        0v/u1EU9eUp4L3zv5QKxhxYCk3v+uJ8fH3Z7fc+H/d3wAg3wZJFJob1AHvw2
-        fLA4I7QmBRsQtCLkkIRTcopmkUa9umsDk1c9s/SvnGJYaszI3FdsJ8XQDSwB
-        3SRsGLaYH6iaeMNxcTOKfuu3659aKb7Y565iyOfaBN5Q7YmJrpQbKd1iVaoH
-        UV3P2Udy4deHdvBJawyS7xL2LqSIZLX08bQ95FPe9n+pp/ULPGRgtDMBAAA=
-    http_version: 
-  recorded_at: Fri, 05 Oct 2018 20:16:25 GMT
-recorded_with: VCR 4.0.0
+        H4sIAAAAAAAAA3WPQUvEQAyF/0vOFUpPMke9LSgelAVlGaYzaR2YJiVJd7cs+9+duurNU0Je8r2XC+QEDiKTp/unXdudu3dtdw9v+2dogGfLTAruAtMQthKi5SOCM1mwAUFbhDyScCle0SzTqDf12sAcVE8s6YVLjmu1GZlTxapJMBxXf0TRagCua6CXxdAPLBH9LGwY7Vv6Yf3eVEpY7LOtGApTTQKvqPbIRLeDO1n61eqoLmT1iaeQycc/HdwQitbsSKEvmHwsGclq6I/D9lAo09b/Sz1cvwBFiD9BMwEAAA==
+  recorded_at: Tue, 20 Jul 2021 02:06:02 GMT
+recorded_with: VCR 6.0.0

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

@@ -113,7 +113,7 @@ describe Auth0::Api::V2::Connections do
   context '.delete_connection_user' do
     it { expect(@instance).to respond_to(:delete_connection_user) }
     it 'is expected to call delete to /api/v2/connections/connectionId/users' do
-      expect(@instance).to receive(:delete).with('/api/v2/connections/connectionId/users?email=email@test.com')
+      expect(@instance).to receive(:delete).with('/api/v2/connections/connectionId/users', email: 'email@test.com')
       @instance.delete_connection_user('connectionId', 'email@test.com')
     end
 

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

@@ -22,9 +22,9 @@ describe Auth0::Api::V2::DeviceCredentials do
       )
       expect { @instance.device_credentials(client_id) }.not_to raise_error
     end
-    it 'is expect to raise an error when type is not one of \'public_key\', \'refresh_token\'' do
+    it 'is expect to raise an error when type is not one of \'public_key\', \'refresh_token\', \'rotating_refresh_token\'' do
       expect { @instance.device_credentials(client_id, type: 'invalid_type') }.to raise_error(
-        'Type must be one of \'public_key\', \'refresh_token\''
+        'Type must be one of \'public_key\', \'refresh_token\', \'rotating_refresh_token\''
       )
     end
   end

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

@@ -20,6 +20,8 @@ describe Auth0::Api::V2::Organizations do
         '/api/v2/organizations',
         per_page: nil,
         page: nil,
+        from: nil,
+        take: nil,
         include_totals: nil
       )
       expect { @instance.organizations }.not_to raise_error
@@ -30,12 +32,16 @@ describe Auth0::Api::V2::Organizations do
         '/api/v2/organizations',
         per_page: 10,
         page: 1,
+        from: 'org_id',
+        take: 50,
         include_totals: true
       )
       expect do
         @instance.organizations(
           per_page: 10,
           page: 1,
+          from: 'org_id',
+          take: 50,
           include_totals: true
         )
       end.not_to raise_error
@@ -438,19 +444,38 @@ describe Auth0::Api::V2::Organizations do
       expect { @instance.get_organizations_members(nil) }.to raise_exception(Auth0::MissingOrganizationId)
     end
 
-    it 'is expected to get invitations for an org' do
+    it 'is expected to get members for an org' do
       expect(@instance).to receive(:get).with(
-        '/api/v2/organizations/org_id/members'
+        '/api/v2/organizations/org_id/members',
+        per_page: nil,
+        page: nil,
+        from: nil,
+        take: nil,
+        include_totals: nil
       )
-      expect { @instance.get_organizations_members('org_id') }.not_to raise_error
+      expect do
+        @instance.get_organizations_members('org_id')
+      end.not_to raise_error
     end
 
-    it 'is expected to get members for an org' do
+    it 'is expected to get /api/v2/organizations with custom parameters' do
       expect(@instance).to receive(:get).with(
-        '/api/v2/organizations/org_id/members'
+        '/api/v2/organizations/org_id/members',
+        per_page: 10,
+        page: 1,
+        from: 'org_id',
+        take: 50,
+        include_totals: true
       )
       expect do
-        @instance.get_organizations_members('org_id')
+        @instance.get_organizations_members(
+          'org_id',
+          per_page: 10,
+          page: 1,
+          from: 'org_id',
+          take: 50,
+          include_totals: true
+        )
       end.not_to raise_error
     end
   end

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

@@ -152,6 +152,8 @@ describe Auth0::Api::V2::Roles do
         '/api/v2/roles/ROLE_ID/users',
         per_page: nil,
         page: nil,
+        from: nil,
+        take: nil,
         include_totals: nil
       )
       expect { @instance.get_role_users('ROLE_ID') }.not_to raise_error
@@ -162,10 +164,12 @@ describe Auth0::Api::V2::Roles do
         '/api/v2/roles/ROLE_ID/users',
         per_page: 30,
         page: 4,
+        from: 'org_id',
+        take: 50,
         include_totals: true
       )
       expect do
-        @instance.get_role_users('ROLE_ID', per_page: 30, page: 4, include_totals: true)
+        @instance.get_role_users('ROLE_ID', per_page: 30, page: 4, from: 'org_id', take: 50, include_totals: true)
       end.not_to raise_error
     end
   end

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,107 @@ 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
 end