Fix lint issues

Author: esrakartalOpt

lib/optimizely/cmab/cmab_client.rb

@@ -72,10 +72,11 @@ def fetch_decision(rule_id, user_id, attributes, cmab_uuid, timeout: MAX_WAIT_TI
         }]
       }
 
-      variation_id = @retry_config ?
-        _do_fetch_with_retry(url, request_body, @retry_config, timeout) :
+      if @retry_config
+        _do_fetch_with_retry(url, request_body, @retry_config, timeout)
+      else
         _do_fetch(url, request_body, timeout)
-      variation_id
+      end
     end
 
     def _do_fetch(url, request_body, timeout)

spec/cmab_client_spec.rb

@@ -15,61 +15,61 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 #
-require "spec_helper"
-require "optimizely/cmab/cmab_client"
+require 'spec_helper'
+require 'optimizely/cmab/cmab_client'
 
 describe Optimizely::CmabClient do
-  let(:mock_http_client) { double("http_client") }
-  let(:mock_logger) { double("logger") }
+  let(:mock_http_client) { double('http_client') }
+  let(:mock_logger) { double('logger') }
   let(:retry_config) { Optimizely::CmabRetryConfig.new(max_retries: 3, initial_backoff: 0.01, max_backoff: 1, backoff_multiplier: 2) }
   let(:client) { described_class.new(http_client: mock_http_client, logger: mock_logger, retry_config: nil) }
-  let(:rule_id) { "test_rule" }
-  let(:user_id) { "user123" }
-  let(:attributes) { { 'attr1': "value1", 'attr2': "value2" } }
-  let(:cmab_uuid) { "uuid-1234" }
+  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
     {
       instances: [{
         visitorId: user_id,
         experimentId: rule_id,
         attributes: [
-          { id: "attr1", value: "value1", type: "custom_attribute" },
-          { id: "attr2", value: "value2", type: "custom_attribute" },
+          {id: 'attr1', value: 'value1', type: 'custom_attribute'},
+          {id: 'attr2', value: 'value2', type: 'custom_attribute'},
         ],
-        cmabUUID: cmab_uuid,
-      }],
+        cmabUUID: cmab_uuid
+      }]
     }
   end
-  let(:expected_headers) { { "Content-Type" => "application/json" } }
+  let(:expected_headers) { {'Content-Type' => 'application/json'} }
 
-  it "should return the variation id on success without retrying" do
-    mock_response = double("response", status_code: 200, json: { "predictions" => [{ 'variationId': "abc123" }] })
+  it 'should return the variation id on success without retrying' do
+    mock_response = double('response', status_code: 200, json: {'predictions' => [{'variationId': 'abc123'}]})
     allow(mock_http_client).to receive(:post).and_return(mock_response)
     result = client.fetch_decision(rule_id, user_id, attributes, cmab_uuid)
-    expect(result).to eq("abc123")
+    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,
+        timeout: 10
       )
     )
   end
 
-  it "should return HTTP exception without retrying" do
-    allow(mock_http_client).to receive(:post).and_raise(StandardError.new("Connection error"))
+  it 'should return HTTP exception without retrying' do
+    allow(mock_http_client).to receive(:post).and_raise(StandardError.new('Connection error'))
     allow(mock_logger).to receive(: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(mock_logger).to have_received(:error).with(a_string_including("Connection error"))
+    expect(mock_logger).to have_received(:error).with(a_string_including('Connection error'))
   end
 
-  it "should not return 200 status without retrying" do
-    mock_response = double("response", status_code: 500, json: nil)
+  it 'should not return 200 status without retrying' do
+    mock_response = double('response', status_code: 500, json: nil)
     allow(mock_http_client).to receive(:post).and_return(mock_response)
 
     expect do
@@ -81,15 +81,15 @@
       hash_including(
         json: expected_body,
         headers: expected_headers,
-        timeout: 10,
+        timeout: 10
       )
     )
-    expect(mock_logger).to have_received(:error).with(a_string_including("500"))
+    expect(mock_logger).to have_received(:error).with(a_string_including('500'))
   end
 
-  it "should return invalid json without retrying" do
-    mock_response = double("response", status_code: 200)
-    allow(mock_response).to receive(:json).and_raise(JSON::ParserError.new("Expecting value"))
+  it 'should return invalid json without retrying' 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)
 
     expect do
@@ -101,14 +101,14 @@
       hash_including(
         json: expected_body,
         headers: expected_headers,
-        timeout: 10,
+        timeout: 10
       )
     )
-    expect(mock_logger).to have_received(:error).with(a_string_including("Invalid CMAB fetch response"))
+    expect(mock_logger).to have_received(:error).with(a_string_including('Invalid CMAB fetch response'))
   end
 
-  it "should return invalid response structure without retrying" do
-    mock_response = double("response", status_code: 200, json: { "no_predictions" => [] })
+  it 'should return invalid response structure without retrying' do
+    mock_response = double('response', status_code: 200, json: {'no_predictions' => []})
     allow(mock_http_client).to receive(:post).and_return(mock_response)
 
     expect do
@@ -120,48 +120,48 @@
       hash_including(
         json: expected_body,
         headers: expected_headers,
-        timeout: 10,
+        timeout: 10
       )
     )
-    expect(mock_logger).to have_received(:error).with(a_string_including("Invalid CMAB fetch response"))
+    expect(mock_logger).to have_received(:error).with(a_string_including('Invalid CMAB fetch response'))
   end
 
-  it "should return the variation id on first try with retry config but no retry needed" do
+  it 'should return the variation id on first try with retry config but no retry needed' do
     client_with_retry = described_class.new(
       http_client: mock_http_client,
       logger: mock_logger,
-      retry_config: retry_config,
+      retry_config: retry_config
     )
 
     # Mock successful response
-    mock_response = double("response", status_code: 200, json: { "predictions" => [{ 'variationId': "abc123" }] })
+    mock_response = double('response', status_code: 200, json: {'predictions' => [{'variationId': 'abc123'}]})
     allow(mock_http_client).to receive(:post).and_return(mock_response)
     allow_any_instance_of(Object).to receive(:sleep)
 
     result = client_with_retry.fetch_decision(rule_id, user_id, attributes, cmab_uuid)
 
-    expect(result).to eq("abc123")
+    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,
+        timeout: 10
       )
     ).once
     expect_any_instance_of(Object).not_to have_received(:sleep)
   end
 
-  it "should return the variation id on third try with retry config" do
+  it 'should return the variation id on third try with retry config' do
     client_with_retry = described_class.new(
       http_client: mock_http_client,
       logger: mock_logger,
-      retry_config: retry_config,
+      retry_config: retry_config
     )
 
     # Create failure and success responses
-    failure_response = double("response", status_code: 500)
-    success_response = double("response", status_code: 200, json: { "predictions" => [{ 'variationId': "xyz456" }] })
+    failure_response = double('response', status_code: 500)
+    success_response = double('response', status_code: 200, json: {'predictions' => [{'variationId': 'xyz456'}]})
 
     # First two calls fail, third succeeds
     call_sequence = [failure_response, failure_response, success_response]
@@ -172,7 +172,7 @@
 
     result = client_with_retry.fetch_decision(rule_id, user_id, attributes, cmab_uuid)
 
-    expect(result).to eq("xyz456")
+    expect(result).to eq('xyz456')
     expect(mock_http_client).to have_received(:post).exactly(3).times
 
     # Verify all HTTP calls used correct parameters
@@ -181,28 +181,28 @@
       hash_including(
         json: expected_body,
         headers: expected_headers,
-        timeout: 10,
+        timeout: 10
       )
     )
 
     # Verify retry logging
-    expect(mock_logger).to have_received(:info).with("Retrying CMAB request (attempt 1) after 0.01 seconds...")
-    expect(mock_logger).to have_received(:info).with("Retrying CMAB request (attempt 2) after 0.02 seconds...")
+    expect(mock_logger).to have_received(:info).with('Retrying CMAB request (attempt 1) after 0.01 seconds...')
+    expect(mock_logger).to have_received(:info).with('Retrying CMAB request (attempt 2) after 0.02 seconds...')
 
     # Verify sleep was called with correct backoff times
     expect_any_instance_of(Object).to have_received(:sleep).with(0.01)
     expect_any_instance_of(Object).to have_received(:sleep).with(0.02)
   end
 
-  it "should exhausts all retry attempts" do
+  it 'should exhausts all retry attempts' do
     client_with_retry = described_class.new(
       http_client: mock_http_client,
       logger: mock_logger,
-      retry_config: retry_config,
+      retry_config: retry_config
     )
 
     # Create failure response
-    failure_response = double("response", status_code: 500)
+    failure_response = double('response', status_code: 500)
 
     # All attempts fail
     allow(mock_http_client).to receive(:post).and_return(failure_response)
@@ -218,16 +218,16 @@
     expect(mock_http_client).to have_received(:post).exactly(4).times
 
     # Verify retry logging
-    expect(mock_logger).to have_received(:info).with("Retrying CMAB request (attempt 1) after 0.01 seconds...")
-    expect(mock_logger).to have_received(:info).with("Retrying CMAB request (attempt 2) after 0.02 seconds...")
-    expect(mock_logger).to have_received(:info).with("Retrying CMAB request (attempt 3) after 0.08 seconds...")
+    expect(mock_logger).to have_received(:info).with('Retrying CMAB request (attempt 1) after 0.01 seconds...')
+    expect(mock_logger).to have_received(:info).with('Retrying CMAB request (attempt 2) after 0.02 seconds...')
+    expect(mock_logger).to have_received(:info).with('Retrying CMAB request (attempt 3) after 0.08 seconds...')
 
     # Verify sleep was called for each retry
     expect_any_instance_of(Object).to have_received(:sleep).with(0.01)
     expect_any_instance_of(Object).to have_received(:sleep).with(0.02)
     expect_any_instance_of(Object).to have_received(:sleep).with(0.08)
 
     # Verify final error logging
-    expect(mock_logger).to have_received(:error).with(a_string_including("Max retries exceeded for CMAB request"))
+    expect(mock_logger).to have_received(:error).with(a_string_including('Max retries exceeded for CMAB request'))
   end
 end