RUBY-3794 Update unit tests for phase 1 constants and removed API

Author: comandeo-mongo

spec/mongo/retryable/backpressure_spec.rb

@@ -12,16 +12,8 @@
       expect(described_class::MAX_BACKOFF).to eq(10)
     end
 
-    it 'defines MAX_RETRIES as 5' do
-      expect(described_class::MAX_RETRIES).to eq(5)
-    end
-
-    it 'defines RETRY_TOKEN_RETURN_RATE as 0.1' do
-      expect(described_class::RETRY_TOKEN_RETURN_RATE).to eq(0.1)
-    end
-
-    it 'defines DEFAULT_RETRY_TOKEN_CAPACITY as 1000' do
-      expect(described_class::DEFAULT_RETRY_TOKEN_CAPACITY).to eq(1000)
+    it 'defines DEFAULT_MAX_RETRIES as 2' do
+      expect(described_class::DEFAULT_MAX_RETRIES).to eq(2)
     end
   end
 

spec/mongo/retryable/read_worker_overload_spec.rb

@@ -60,23 +60,23 @@ def make_retryable_error(message = 'not master')
   describe '#read_with_retry with overload errors' do
     context 'when an overload error is raised and then succeeds' do
       it 'retries with backoff and returns the result' do
-        expect(worker).to receive(:sleep).at_least(:twice)
+        expect(worker).to receive(:sleep).at_least(:once)
         call_count = 0
         result = worker.read_with_retry(session, server_selector, context) do |_server, _is_retry|
           call_count += 1
-          raise make_overload_error if call_count <= 3
+          raise make_overload_error if call_count <= 2
 
           :success
         end
 
         expect(result).to eq(:success)
-        expect(call_count).to eq(4)
+        expect(call_count).to eq(3)
       end
     end
 
-    context 'when overload errors exceed MAX_RETRIES' do
-      it 'raises after MAX_RETRIES' do
-        max = Mongo::Retryable::Backpressure::MAX_RETRIES
+    context 'when overload errors exceed DEFAULT_MAX_RETRIES' do
+      it 'raises after DEFAULT_MAX_RETRIES' do
+        max = Mongo::Retryable::Backpressure::DEFAULT_MAX_RETRIES
         call_count = 0
 
         expect do
@@ -105,42 +105,5 @@ def make_retryable_error(message = 'not master')
         expect(call_count).to eq(2)
       end
     end
-
-    context 'when adaptive retries are enabled and bucket is drained' do
-      let(:retry_policy) { Mongo::Retryable::RetryPolicy.new(adaptive_retries: true) }
-
-      it 'raises when the token bucket is empty' do
-        bucket = retry_policy.token_bucket
-        bucket.tokens.to_i.times { bucket.consume(1) }
-
-        expect do
-          worker.read_with_retry(session, server_selector, context) do |_server, _is_retry|
-            raise make_overload_error
-          end
-        end.to raise_error(Mongo::Error::OperationFailure, /overloaded/)
-      end
-    end
-
-    context 'when record_success is called on success' do
-      it 'calls record_success(is_retry: false) on first-attempt success' do
-        expect(retry_policy).to receive(:record_success).with(is_retry: false)
-
-        worker.read_with_retry(session, server_selector, context) do |_server|
-          :ok
-        end
-      end
-
-      it 'calls record_success(is_retry: true) after a retry succeeds' do
-        call_count = 0
-        expect(retry_policy).to receive(:record_success).with(is_retry: true)
-
-        worker.read_with_retry(session, server_selector, context) do |_server, _is_retry|
-          call_count += 1
-          raise make_overload_error if call_count == 1
-
-          :ok
-        end
-      end
-    end
   end
 end

spec/mongo/retryable/write_worker_overload_spec.rb

@@ -9,7 +9,7 @@
     end
   end
 
-  let(:retry_policy) { Mongo::Retryable::RetryPolicy.new(adaptive_retries: false) }
+  let(:retry_policy) { Mongo::Retryable::RetryPolicy.new }
 
   let(:client) do
     instance_double(Mongo::Client).tap do |c|
@@ -94,18 +94,6 @@ def call_overload_retry(wkr, error: nil, error_count: 1, &block)
   end
 
   describe '#modern_write_with_retry' do
-    context 'when the operation succeeds on first attempt' do
-      it 'records success and returns the result' do
-        expect(retry_policy).to receive(:record_success).with(is_retry: false)
-
-        result = worker.modern_write_with_retry(session, server, context) do |_conn, _txn, _ctx|
-          :ok
-        end
-
-        expect(result).to eq(:ok)
-      end
-    end
-
     context 'when an overload error occurs' do
       it 'enters the overload retry loop' do
         call_count = 0
@@ -161,21 +149,16 @@ def call_overload_retry(wkr, error: nil, error_count: 1, &block)
 
         expect(result).to eq(:write_ok)
       end
-
-      it 'records success on retry' do
-        expect(retry_policy).to receive(:record_success).with(is_retry: true)
-        call_overload_retry(worker) { |_c, _t, _x| :ok }
-      end
     end
 
     context 'with multiple overload errors' do
       it 'retries multiple times with backoff' do
         call_count = 0
-        expect(worker).to receive(:sleep).exactly(3).times
+        expect(worker).to receive(:sleep).twice
 
         result = call_overload_retry(worker) do |_c, _t, _x|
           call_count += 1
-          raise make_overload_error if call_count < 3
+          raise make_overload_error if call_count < 2
 
           :finally_ok
         end
@@ -184,9 +167,9 @@ def call_overload_retry(wkr, error: nil, error_count: 1, &block)
       end
     end
 
-    context 'when MAX_RETRIES (5) is exceeded' do
+    context 'when DEFAULT_MAX_RETRIES (2) is exceeded' do
       it 'raises the last error' do
-        max = Mongo::Retryable::Backpressure::MAX_RETRIES + 1
+        max = Mongo::Retryable::Backpressure::DEFAULT_MAX_RETRIES + 1
 
         expect do
           call_overload_retry(worker, error_count: max) { |_c, _t, _x| :should_not_reach }
@@ -205,7 +188,7 @@ def call_overload_retry(wkr, error: nil, error_count: 1, &block)
           end
         end.to raise_error(Mongo::Error::OperationFailure, /overloaded/)
 
-        expect(call_count).to eq(Mongo::Retryable::Backpressure::MAX_RETRIES)
+        expect(call_count).to eq(Mongo::Retryable::Backpressure::DEFAULT_MAX_RETRIES)
       end
     end
 
@@ -241,9 +224,8 @@ def call_overload_retry(wkr, error: nil, error_count: 1, &block)
     end
 
     context 'when a non-overload retryable error occurs during overload loop' do
-      it 'records non-overload failure and continues retrying' do
+      it 'continues retrying' do
         call_count = 0
-        expect(retry_policy).to receive(:record_non_overload_retry_failure).once
 
         result = call_overload_retry(worker) do |_c, _t, _x|
           call_count += 1
@@ -256,39 +238,4 @@ def call_overload_retry(wkr, error: nil, error_count: 1, &block)
       end
     end
   end
-
-  describe 'record_success on retry_write path' do
-    it 'records success after standard retry succeeds' do
-      expect(retry_policy).to receive(:record_success).with(is_retry: true)
-      call_count = 0
-
-      worker.modern_write_with_retry(session, server, context) do |_conn, _txn, _ctx|
-        call_count += 1
-        raise make_retryable_write_error if call_count == 1
-
-        :ok
-      end
-    end
-  end
-
-  describe 'adaptive retries (token bucket)' do
-    let(:retry_policy) { Mongo::Retryable::RetryPolicy.new(adaptive_retries: true) }
-
-    context 'when the token bucket is exhausted' do
-      before { retry_policy.token_bucket.consume(retry_policy.token_bucket.capacity) }
-
-      it 'raises the error instead of retrying' do
-        expect do
-          call_overload_retry(worker) { |_c, _t, _x| :no }
-        end.to raise_error(Mongo::Error::OperationFailure, /overloaded/)
-      end
-    end
-
-    context 'when there are tokens available' do
-      it 'retries and records success' do
-        expect(retry_policy).to receive(:record_success).with(is_retry: true)
-        call_overload_retry(worker) { |_c, _t, _x| :ok }
-      end
-    end
-  end
 end