Use webmock

Author: esrakartalOpt

spec/cmab_client_spec.rb

@@ -18,15 +18,17 @@
 require 'spec_helper'
 require 'optimizely/logger'
 require 'optimizely/cmab/cmab_client'
+require 'webmock/rspec'
 
 describe Optimizely::DefaultCmabClient do
   let(:spy_logger) { spy('logger') }
+  let(:retry_config) { Optimizely::CmabRetryConfig.new(max_retries: 3, retry_delay: 0.01, max_backoff: 1, backoff_multiplier: 2) }
   let(:rule_id) { 'test_rule' }
   let(:user_id) { 'user123' }
   let(:attributes) { {'attr1': 'value1', 'attr2': 'value2'} }
   let(:cmab_uuid) { 'uuid-1234' }
   let(:expected_url) { "https://prediction.cmab.optimizely.com/predict/#{rule_id}" }
-  let(:expected_body) do
+  let(:expected_body_for_webmock) do
     {
       instances: [{
         visitorId: user_id,
@@ -37,170 +39,150 @@
         ],
         cmabUUID: cmab_uuid
       }]
-    }
+    }.to_json
   end
   let(:expected_headers) { {'Content-Type' => 'application/json'} }
 
   before do
     allow(Kernel).to receive(:sleep)
+    WebMock.disable_net_connect!
   end
 
   after do
     RSpec::Mocks.space.proxy_for(spy_logger).reset
+    WebMock.reset!
+    WebMock.allow_net_connect!
   end
 
   context 'when client is configured without retries' do
-    let(:mock_http_client) { double('http_client') }
-    let(:client) { described_class.new(mock_http_client, nil, spy_logger) }
+    let(:client) { described_class.new(nil, nil, spy_logger) }
 
     it 'should return the variation id on success' do
-      mock_response = double('response', status_code: 200, json: {'predictions' => [{'variationId' => 'abc123'}]})
-      allow(mock_http_client).to receive(:post).and_return(mock_response)
+      WebMock.stub_request(:post, expected_url)
+             .with(body: expected_body_for_webmock, headers: expected_headers)
+             .to_return(status: 200, body: {'predictions' => [{'variationId' => 'abc123'}]}.to_json, headers: {'Content-Type' => 'application/json'})
 
       result = client.fetch_decision(rule_id, user_id, attributes, cmab_uuid)
 
       expect(result).to eq('abc123')
-      expect(mock_http_client).to have_received(:post).with(
-        expected_url,
-        hash_including(
-          json: expected_body,
-          headers: expected_headers,
-          timeout: 10
-        )
-      ).once
+      expect(WebMock).to have_requested(:post, expected_url)
+                             .with(body: expected_body_for_webmock, headers: expected_headers).once
       expect(Kernel).not_to have_received(:sleep)
     end
 
     it 'should return HTTP exception' do
-      allow(mock_http_client).to receive(:post).and_raise(StandardError.new('Connection error'))
+      WebMock.stub_request(:post, expected_url)
+             .with(body: expected_body_for_webmock, headers: expected_headers)
+             .to_raise(StandardError.new('Connection error'))
 
       expect do
         client.fetch_decision(rule_id, user_id, attributes, cmab_uuid)
       end.to raise_error(Optimizely::CmabFetchError, /Connection error/)
 
-      expect(mock_http_client).to have_received(:post).once
+      expect(WebMock).to have_requested(:post, expected_url)
+                             .with(body: expected_body_for_webmock, headers: expected_headers).once
       expect(spy_logger).to have_received(:log).with(Logger::ERROR, a_string_including('Connection error'))
       expect(Kernel).not_to have_received(:sleep)
     end
 
     it 'should not return 200 status' do
-      mock_response = double('response', status_code: 500, json: nil)
-      allow(mock_http_client).to receive(:post).and_return(mock_response)
+      WebMock.stub_request(:post, expected_url)
+             .with(body: expected_body_for_webmock, headers: expected_headers)
+             .to_return(status: 500)
 
       expect do
         client.fetch_decision(rule_id, user_id, attributes, cmab_uuid)
       end.to raise_error(Optimizely::CmabFetchError, /500/)
 
-      expect(mock_http_client).to have_received(:post).with(
-        expected_url,
-        hash_including(
-          json: expected_body,
-          headers: expected_headers,
-          timeout: 10
-        )
-      ).once
+      expect(WebMock).to have_requested(:post, expected_url)
+                             .with(body: expected_body_for_webmock, headers: expected_headers).once
       expect(spy_logger).to have_received(:log).with(Logger::ERROR, a_string_including('500'))
       expect(Kernel).not_to have_received(:sleep)
     end
 
     it 'should return invalid json' do
-      mock_response = double('response', status_code: 200)
-      allow(mock_response).to receive(:json).and_raise(JSON::ParserError.new('Expecting value'))
-      allow(mock_http_client).to receive(:post).and_return(mock_response)
+      WebMock.stub_request(:post, expected_url)
+             .with(body: expected_body_for_webmock, headers: expected_headers)
+             .to_return(status: 200, body: 'this is not json', headers: {'Content-Type' => 'text/plain'})
 
       expect do
         client.fetch_decision(rule_id, user_id, attributes, cmab_uuid)
       end.to raise_error(Optimizely::CmabInvalidResponseError, /Invalid CMAB fetch response/)
 
-      expect(mock_http_client).to have_received(:post).with(
-        expected_url,
-        hash_including(
-          json: expected_body,
-          headers: expected_headers,
-          timeout: 10
-        )
-      ).once
+      expect(WebMock).to have_requested(:post, expected_url)
+                             .with(body: expected_body_for_webmock, headers: expected_headers).once
       expect(spy_logger).to have_received(:log).with(Logger::ERROR, a_string_including('Invalid CMAB fetch response'))
       expect(Kernel).not_to have_received(:sleep)
     end
 
     it 'should return invalid response structure' do
-      mock_response = double('response', status_code: 200, json: {'no_predictions' => []})
-      allow(mock_http_client).to receive(:post).and_return(mock_response)
+      WebMock.stub_request(:post, expected_url)
+             .with(body: expected_body_for_webmock, headers: expected_headers)
+             .to_return(status: 200, body: {'no_predictions' => []}.to_json, headers: {'Content-Type' => 'application/json'})
 
       expect do
         client.fetch_decision(rule_id, user_id, attributes, cmab_uuid)
       end.to raise_error(Optimizely::CmabInvalidResponseError, /Invalid CMAB fetch response/)
 
-      expect(mock_http_client).to have_received(:post).with(
-        expected_url,
-        hash_including(
-          json: expected_body,
-          headers: expected_headers,
-          timeout: 10
-        )
-      ).once
+      expect(WebMock).to have_requested(:post, expected_url)
+                             .with(body: expected_body_for_webmock, headers: expected_headers).once
       expect(spy_logger).to have_received(:log).with(Logger::ERROR, a_string_including('Invalid CMAB fetch response'))
       expect(Kernel).not_to have_received(:sleep)
     end
   end
 
   context 'when client is configured with retries' do
-    let(:mock_http_client) { double('http_client') } # Fresh double for this context
-    let(:retry_config) { Optimizely::CmabRetryConfig.new(max_retries: 3, retry_delay: 0.01, max_backoff: 1, backoff_multiplier: 2) }
-    let(:client_with_retry) { described_class.new(mock_http_client, retry_config, spy_logger) }
+    let(:client_with_retry) { described_class.new(nil, retry_config, spy_logger) }
 
-    it 'should return the variation id on first try with retry config but no retry needed' do
-      mock_response = double('response', status_code: 200, json: {'predictions' => [{'variationId' => 'abc123'}]})
-      allow(mock_http_client).to receive(:post).and_return(mock_response)
+    it 'should return the variation id on first try' do
+      WebMock.stub_request(:post, expected_url)
+             .with(body: expected_body_for_webmock, headers: expected_headers)
+             .to_return(status: 200, body: {'predictions' => [{'variationId' => 'abc123'}]}.to_json, headers: {'Content-Type' => 'application/json'})
 
       result = client_with_retry.fetch_decision(rule_id, user_id, attributes, cmab_uuid)
 
       expect(result).to eq('abc123')
-      expect(mock_http_client).to have_received(:post).with(
-        expected_url,
-        hash_including(
-          json: expected_body,
-          headers: expected_headers,
-          timeout: 10
-        )
-      ).once
+      expect(WebMock).to have_requested(:post, expected_url)
+                             .with(body: expected_body_for_webmock, headers: expected_headers).once
       expect(Kernel).not_to have_received(:sleep)
     end
 
     it 'should return the variation id on third try' do
-      failure_response = double('response', status_code: 500)
-      success_response = double('response', status_code: 200, json: {'predictions' => [{'variationId' => 'xyz456'}]})
-
-      # Use a sequence to control responses
-      allow(mock_http_client).to receive(:post).and_return(failure_response, failure_response, success_response)
+      WebMock.stub_request(:post, expected_url)
+             .with(body: expected_body_for_webmock, headers: expected_headers)
+             .to_return({status: 500},
+                        {status: 500},
+                        {status: 200, body: {'predictions' => [{'variationId' => 'xyz456'}]}.to_json, headers: {'Content-Type' => 'application/json'}})
 
       result = client_with_retry.fetch_decision(rule_id, user_id, attributes, cmab_uuid)
 
       expect(result).to eq('xyz456')
-      expect(mock_http_client).to have_received(:post).exactly(3).times
+      expect(WebMock).to have_requested(:post, expected_url)
+                             .with(body: expected_body_for_webmock, headers: expected_headers).exactly(3).times
 
       expect(spy_logger).to have_received(:log).with(Logger::INFO, 'Retrying CMAB request (attempt 1) after 0.01 seconds...').once
       expect(spy_logger).to have_received(:log).with(Logger::INFO, 'Retrying CMAB request (attempt 2) after 0.02 seconds...').once
       expect(spy_logger).not_to have_received(:log).with(Logger::INFO, a_string_including('Retrying CMAB request (attempt 3)'))
 
       expect(Kernel).to have_received(:sleep).with(0.01).once
       expect(Kernel).to have_received(:sleep).with(0.02).once
-      expect(Kernel).not_to have_received(:sleep).with(0.04)
       expect(Kernel).not_to have_received(:sleep).with(0.08)
     end
 
     it 'should exhaust all retry attempts' do
-      failure_response = double('response', status_code: 500)
-
-      # All attempts fail
-      allow(mock_http_client).to receive(:post).and_return(failure_response, failure_response, failure_response, failure_response)
+      WebMock.stub_request(:post, expected_url)
+             .with(body: expected_body_for_webmock, headers: expected_headers)
+             .to_return({status: 500},
+                        {status: 500},
+                        {status: 500},
+                        {status: 500})
 
       expect do
         client_with_retry.fetch_decision(rule_id, user_id, attributes, cmab_uuid)
       end.to raise_error(Optimizely::CmabFetchError)
 
-      expect(mock_http_client).to have_received(:post).exactly(4).times
+      expect(WebMock).to have_requested(:post, expected_url)
+                             .with(body: expected_body_for_webmock, headers: expected_headers).exactly(4).times
 
       expect(spy_logger).to have_received(:log).with(Logger::INFO, 'Retrying CMAB request (attempt 1) after 0.01 seconds...').once
       expect(spy_logger).to have_received(:log).with(Logger::INFO, 'Retrying CMAB request (attempt 2) after 0.02 seconds...').once