bearcat 1.6.5.beta1 → 1.6.5.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd97acc800c267140f131ef12af13e3e2303b1fd440f146a0889ba40fcb47c9b
-  data.tar.gz: 57518d64fcca4a308711f63488ee51ba946eb10eccc2d7b956874282ad65329b
+  metadata.gz: e391dc610d18bc23fbfc10173270a88d3f9dca109b63ea75320bcc8c683c811d
+  data.tar.gz: 602353626c34e485f421e46e81cf7391b4647aa44dd2555c79a6ba5517fc8d0f
 SHA512:
-  metadata.gz: e9c543b8d57865beebf6a86c6f505b620ff85196050ae8883ca3b84c63c94e7442a33c31ca47d4daf61f749e559d8bfa97b1ce0cd901345f18f533abf74cd94f
-  data.tar.gz: 0db04f590f1437e072d0ecc40e003fc664b4b8fb56fccb81ae701e0891ac25db92689cc536b6fd481db38bfbd6914561f62eed8719e5ab484d20370acffc3af3
+  metadata.gz: 1a58bd62214f1b522ef0fbce0185b686009dd057f2e4e94c1e348ced20e8932819760bb4e2103acc2a115ffc31abaf8e6efa1897dcfbe4b688add87d395eb1b4
+  data.tar.gz: c355451022375fc33951674974bfd7ca8986a70a43fa05a07aba5f93352cd8d18f2c0ace525aeb3c88e33262a9f7ce3f248fcb9243a98b70cdab356c1602ae7c

data/lib/bearcat/client.rb

@@ -25,9 +25,43 @@ module Bearcat
       @registered_endpoints
     end
 
+    def retry_request
+      response = nil
+      retries_count = 0
+      begin
+        response = yield
+      rescue => e
+        # Handle 5xx server errors with retry logic
+        if e.respond_to?(:status) && [500, 501, 502, 503, 504].include?(e.status)
+          # Retry if we haven't exhausted max_retries
+          if config[:max_retries].present? && retries_count != -1 && retries_count < config[:max_retries]
+            retries_count += 1
+            sleep(config[:retry_delay] || 0) if (config[:retry_delay] || 0) > 0
+            retry
+          end
+
+          # Retries exhausted or max_retries reached, call callback if present
+          # This is called when: retries are exhausted OR we never retried but max_retries is configured
+          if config[:on_retries_exceeded].present? && retries_count != -1
+            result = config[:on_retries_exceeded].call(e)
+            # If callback returns :retry, allow one final retry after modifying parameters
+            if result == :retry
+              retries_count = -1
+              retry
+            end
+          end
+        end
+
+        raise
+      end
+      response
+    end
+
     def request(method, &block)
-      response = rate_limited_request do
-        connection.send(method, &block)
+      response = retry_request do
+        rate_limited_request do
+          connection.send(method, &block)
+        end
       end
       ApiArray.process_response(response, self)
     end
@@ -59,7 +93,7 @@ module Bearcat
     def rate_limited_request
       return yield unless rate_limiter
 
-      canvas_rate_limits= 0
+      canvas_rate_limits = 0
       response = nil
 
       begin

data/lib/bearcat/version.rb

@@ -1,3 +1,3 @@
 module Bearcat
-  VERSION = '1.6.5.beta1' unless defined?(Bearcat::VERSION)
+  VERSION = '1.6.5.beta2' unless defined?(Bearcat::VERSION)
 end

data/spec/bearcat/client_spec.rb

@@ -10,4 +10,249 @@ describe Bearcat::Client do
     client = Bearcat::Client.new(token: "test_token")
     client.config[:token].should == "test_token"
   end
+
+  describe "#retry_request" do
+    let(:client) { Bearcat::Client.new(prefix: "http://canvas.test", token: "test_token") }
+
+    context "when request succeeds on first attempt" do
+      it "returns the response without retrying" do
+        call_count = 0
+        response = client.retry_request do
+          call_count += 1
+          "success"
+        end
+
+        expect(response).to eq("success")
+        expect(call_count).to eq(1)
+      end
+    end
+
+    context "when request fails with 500 error" do
+      it "raises error immediately when max_retries is not configured" do
+        client = Bearcat::Client.new(prefix: "http://canvas.test", token: "test_token")
+        stub_request(:get, "http://canvas.test/api/v1/accounts")
+          .to_return(status: 500)
+
+        expect {
+          client.list_accounts
+        }.to raise_error(Footrest::HttpError::InternalServerError)
+      end
+
+      it "retries the specified number of times before raising" do
+        client = Bearcat::Client.new(
+          prefix: "http://canvas.test",
+          token: "test_token",
+          max_retries: 3
+        )
+
+        stub_request(:get, "http://canvas.test/api/v1/accounts")
+          .to_return(status: 500)
+
+        expect {
+          client.list_accounts
+        }.to raise_error(Footrest::HttpError::InternalServerError)
+
+        expect(WebMock).to have_requested(:get, "http://canvas.test/api/v1/accounts").times(4) # 1 initial + 3 retries
+      end
+
+      it "succeeds if retry succeeds before max_retries" do
+        client = Bearcat::Client.new(
+          prefix: "http://canvas.test",
+          token: "test_token",
+          max_retries: 3
+        )
+
+        stub_request(:get, "http://canvas.test/api/v1/accounts")
+          .to_return(status: 500)
+          .to_return(status: 500)
+          .to_return(status: 200, body: '[]', headers: { 'Content-Type' => 'application/json' })
+
+        result = client.list_accounts
+        expect(result.members).to eq([])
+        expect(WebMock).to have_requested(:get, "http://canvas.test/api/v1/accounts").times(3) # 1 initial + 2 retries
+      end
+
+      it "calls on_retries_exceeded callback when retries are exhausted" do
+        callback_called = false
+        received_error = nil
+        client = Bearcat::Client.new(
+          prefix: "http://canvas.test",
+          token: "test_token",
+          max_retries: 2,
+          on_retries_exceeded: ->(error) {
+            callback_called = true
+            received_error = error
+          }
+        )
+
+        stub_request(:get, "http://canvas.test/api/v1/accounts")
+          .to_return(status: 500)
+
+        client.list_accounts rescue nil
+        expect(callback_called).to be_truthy
+        expect(received_error).to be_a(Footrest::HttpError::InternalServerError)
+      end
+
+      it "passes error details to on_retries_exceeded callback" do
+        received_error = nil
+        client = Bearcat::Client.new(
+          prefix: "http://canvas.test",
+          token: "test_token",
+          max_retries: 1,
+          on_retries_exceeded: ->(error) { received_error = error }
+        )
+
+        stub_request(:get, "http://canvas.test/api/v1/accounts")
+          .to_return(status: 503, body: "Service Unavailable")
+
+        client.list_accounts rescue nil
+        expect(received_error).to be_a(Footrest::HttpError::ServiceUnavailable)
+        expect(received_error.response[:status]).to eq(503)
+      end
+
+      it "raises error when retries are exhausted and no callback is provided" do
+        client = Bearcat::Client.new(
+          prefix: "http://canvas.test",
+          token: "test_token",
+          max_retries: 2
+        )
+
+        stub_request(:get, "http://canvas.test/api/v1/accounts")
+          .to_return(status: 500)
+
+        expect {
+          client.list_accounts
+        }.to raise_error(Footrest::HttpError::InternalServerError)
+      end
+    end
+
+    context "when request fails with different 5xx errors" do
+      it "retries on 501 error" do
+        client = Bearcat::Client.new(
+          prefix: "http://canvas.test",
+          token: "test_token",
+          max_retries: 2
+        )
+
+        stub_request(:get, "http://canvas.test/api/v1/accounts")
+          .to_return(status: 501)
+
+        expect {
+          client.list_accounts
+        }.to raise_error(Footrest::HttpError::NotImplemented)
+
+        expect(WebMock).to have_requested(:get, "http://canvas.test/api/v1/accounts").times(3)
+      end
+
+      it "retries on 502 error" do
+        client = Bearcat::Client.new(
+          prefix: "http://canvas.test",
+          token: "test_token",
+          max_retries: 2
+        )
+
+        stub_request(:get, "http://canvas.test/api/v1/accounts")
+          .to_return(status: 502)
+
+        expect {
+          client.list_accounts
+        }.to raise_error(Footrest::HttpError::BadGateway)
+
+        expect(WebMock).to have_requested(:get, "http://canvas.test/api/v1/accounts").times(3)
+      end
+
+      it "retries on 503 error" do
+        client = Bearcat::Client.new(
+          prefix: "http://canvas.test",
+          token: "test_token",
+          max_retries: 2
+        )
+
+        stub_request(:get, "http://canvas.test/api/v1/accounts")
+          .to_return(status: 503)
+
+        expect {
+          client.list_accounts
+        }.to raise_error(Footrest::HttpError::ServiceUnavailable)
+
+        expect(WebMock).to have_requested(:get, "http://canvas.test/api/v1/accounts").times(3)
+      end
+    end
+
+    context "when request fails with non-5xx errors" do
+      it "does not retry on 404 error" do
+        client = Bearcat::Client.new(
+          prefix: "http://canvas.test",
+          token: "test_token",
+          max_retries: 3
+        )
+
+        stub_request(:get, "http://canvas.test/api/v1/accounts/999")
+          .to_return(status: 404)
+
+        expect {
+          client.account(999)
+        }.to raise_error(Footrest::HttpError::NotFound)
+
+        expect(WebMock).to have_requested(:get, "http://canvas.test/api/v1/accounts/999").times(1)
+      end
+
+      it "does not retry on 401 error" do
+        client = Bearcat::Client.new(
+          prefix: "http://canvas.test",
+          token: "test_token",
+          max_retries: 3
+        )
+
+        stub_request(:get, "http://canvas.test/api/v1/accounts")
+          .to_return(status: 401)
+
+        expect {
+          client.list_accounts
+        }.to raise_error(Footrest::HttpError::Unauthorized)
+
+        expect(WebMock).to have_requested(:get, "http://canvas.test/api/v1/accounts").times(1)
+      end
+    end
+
+    context "retry delay" do
+      it "uses custom retry_delay between retries" do
+        client = Bearcat::Client.new(
+          prefix: "http://canvas.test",
+          token: "test_token",
+          max_retries: 2,
+          retry_delay: 0.5
+        )
+
+        stub_request(:get, "http://canvas.test/api/v1/accounts")
+          .to_return(status: 500)
+
+        start_time = Time.now
+        client.list_accounts rescue nil
+        elapsed_time = Time.now - start_time
+
+        # Should have slept twice (2 retries) * 0.5 seconds = ~1 second
+        expect(elapsed_time).to be >= 1.0
+        expect(elapsed_time).to be < 1.5
+      end
+
+      it "defaults to no delay when retry_delay is not specified" do
+        client = Bearcat::Client.new(
+          prefix: "http://canvas.test",
+          token: "test_token",
+          max_retries: 2
+        )
+
+        stub_request(:get, "http://canvas.test/api/v1/accounts")
+          .to_return(status: 500)
+
+        start_time = Time.now
+        client.list_accounts rescue nil
+        elapsed_time = Time.now - start_time
+
+        # Should complete quickly with no sleep (default retry_delay: 0)
+        expect(elapsed_time).to be < 0.5
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bearcat
 version: !ruby/object:Gem::Version
-  version: 1.6.5.beta1
+  version: 1.6.5.beta2
 platform: ruby
 authors:
 - Instructure CustomDev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-12-17 00:00:00.000000000 Z
+date: 2026-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake