better-faraday 3.1.0 → 3.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 505a74e2ae063f298dd6b7885d06f6e8d4851e1b566d4f5560be0b1d1e7890d5
-  data.tar.gz: abe6ef33c08df902f55f8d6235ff587707e84e497ec65a2059b2f4bb06c20097
+  metadata.gz: 6bf92306e4c791a1171310958827a2236faef36480dbed3c111b544035797a68
+  data.tar.gz: 36208257d64565f775bc395beea0b1c72905ad60f9f4c04ea6107375f4ebf2a0
 SHA512:
-  metadata.gz: 692fd039d299eeb2067441d8dd816634924b826314ddcc3caaf0cb3d0231b82b90e47c9077b337fcaaa721231ece2e865432f9b4f1dbb80c97ebb81940f02338
-  data.tar.gz: ca8287fcd46f4e32a2ea5d9ec217b05d0f0fea61167895a90d7c61d0643dc7704b07ced2894a0e89230a08ad29b957f23cf4428840a164e5c3ce36d98e3e5da0
+  metadata.gz: 6c47f524f903183214f43302ab03126b69d09b44660daf4034b5285ef8072d98bfc59fb5a6d614c9863faad704e9e4f9f8afab9e26938ec38295f264df1d974b
+  data.tar.gz: 52e00284afec4daa2797d836f61819b9aee8821cc51daa18f40e19438401001b82e0076e7086c4607a2f9e645a77dbd9f2a9c061709d0f2319a25b787e1025d9

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    better-faraday (3.1.0)
+    better-faraday (3.1.2)
       faraday (>= 1.0, < 3.0)
 
 GEM
@@ -86,7 +86,7 @@ DEPENDENCIES
 
 CHECKSUMS
   addressable (2.9.0) sha256=7fdf6ac3660f7f4e867a0838be3f6cf722ace541dd97767fa42bc6cfa980c7af
-  better-faraday (3.1.0)
+  better-faraday (3.1.2)
   bigdecimal (4.1.3) sha256=61ebe1e5e559bdc3cc6f2c0ee7f427321fc838f59611c294356eb04d6e21cf66
   bundler (4.0.22) sha256=d8d5ec84c8555e0af71db63ed7aee4d1a8fb839ec46d84212d61979242a5d75a
   byebug (13.0.0) sha256=d2263efe751941ca520fa29744b71972d39cbc41839496706f5d9b22e92ae05d

data/better-faraday.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name                  = "better-faraday"
-  s.version               = "3.1.0"
+  s.version               = "3.1.2"
   s.author                = "Yaroslav Konoplov"
   s.email                 = "eahome00@gmail.com"
   s.summary               = "Extends Faraday with useful features"

data/lib/better-faraday.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "better_faraday"

data/lib/better_faraday.rb

@@ -188,6 +188,18 @@ module Faraday
 
     private
 
+    # Fallback for missing reason phrases in the response
+    def bf_reason_phrase
+      phrase = reason_phrase.to_s.strip
+      return phrase.upcase unless phrase.empty? || phrase.casecmp("unknown").zero?
+
+      klass = ::Net::HTTPResponse::CODE_TO_OBJ[status.to_s]
+      return "UNKNOWN" unless klass
+
+      # Converts "Net::HTTPUnprocessableEntity" -> "Unprocessable Entity" -> "UNPROCESSABLE ENTITY"
+      klass.name.split("::").last.sub(/\AHTTP/, "").gsub(/([a-z])([A-Z])/, '\1 \2').upcase
+    end
+
     def bf_truncate(str, limit = 2048, omission = "... (truncated)")
       return str if str.length <= limit
 
@@ -238,14 +250,32 @@ module Faraday
       end
       request_headers_hash = {} if request_headers_hash.nil?
 
-      request_body = env.bf_request_body.then { _1.is_a?(String) ? _1 : _1.to_s }
-      request_byte_count = request_body.bytesize
+      # Safely handle bodies that were already parsed by Faraday middlewares (like f.request :json)
+      request_body = env.bf_request_body
+      request_body_json = nil
 
-      request_is_json = request_headers_hash.any? do |k, v|
-        k.to_s.downcase == "content-type" && v.to_s.match?(%r{\b(?:application|text)/json\b}i)
-      end
+      if request_body.is_a?(Hash) || request_body.is_a?(Array)
+        request_body_json = bf_json_dump(bf_protect_data(request_body))
+        request_body_string = request_body.to_json
+        request_byte_count = request_body_string.bytesize
+      else
+        request_body_is_json = request_headers_hash.any? do |k, v|
+          k.to_s.casecmp("content-type").zero? && v.to_s.match?(%r{\b(?:application|text)/json\b}i)
+        end
+
+        request_body_string = if request_body.is_a?(String)
+          request_body
+        else
+          request_body.respond_to?(:to_json) ? request_body.to_json : request_body.to_s
+        end
 
-      request_json = bf_json_parse(request_body)&.then { bf_json_dump(bf_protect_data(_1)) } if request_is_json
+        request_byte_count = request_body_string.bytesize
+
+        if request_body_is_json
+          parsed = bf_json_parse(request_body_string)
+          request_body_json = bf_json_dump(bf_protect_data(parsed)) unless parsed.nil?
+        end
+      end
 
       request_byte_label = request_byte_count == 1 ? "byte" : "bytes"
 
@@ -255,19 +285,37 @@ module Faraday
       end
       response_headers_hash = {} if response_headers_hash.nil?
 
-      response_body = env.body.then { _1.is_a?(String) ? _1 : _1.to_s }
-      response_byte_count = response_body.bytesize
+      # Safely handle bodies that were already parsed by Faraday middlewares (like f.response :json)
+      response_body = env.body
+      response_body_json = nil
 
-      response_is_json = response_headers_hash.any? do |k, v|
-        k.to_s.downcase == "content-type" && v.to_s.match?(%r{\b(?:application|text)/json\b}i)
-      end
+      if response_body.is_a?(Hash) || response_body.is_a?(Array)
+        response_body_json = bf_json_dump(bf_protect_data(response_body))
+        response_body_string = response_body.to_json
+        response_byte_count = response_body_string.bytesize
+      else
+        response_body_is_json = response_headers_hash.any? do |k, v|
+          k.to_s.casecmp("content-type").zero? && v.to_s.match?(%r{\b(?:application|text)/json\b}i)
+        end
 
-      response_json = bf_json_parse(response_body)&.then { bf_json_dump(bf_protect_data(_1)) } if response_is_json
+        response_body_string = if response_body.is_a?(String)
+          response_body
+        else
+          response_body.respond_to?(:to_json) ? response_body.to_json : response_body.to_s
+        end
+
+        response_byte_count = response_body_string.bytesize
+
+        if response_body_is_json
+          parsed = bf_json_parse(response_body_string)
+          response_body_json = bf_json_dump(bf_protect_data(parsed)) unless parsed.nil?
+        end
+      end
 
       response_byte_label = response_byte_count == 1 ? "byte" : "bytes"
 
       lines = [
-        "-- HTTP #{status} #{reason_phrase} --".gsub(/\s+/, " ").upcase,
+        "-- HTTP #{status} #{bf_reason_phrase} --".gsub(/\s+/, " ").upcase,
         "",
         "-- Request URL --",
         env.url.to_s,
@@ -284,10 +332,10 @@ module Faraday
         "",
 
         %[-- Request Body (#{request_byte_count} #{request_byte_label}) --],
-        if !request_json.nil?
-          request_json
+        if !request_body_json.nil?
+          request_body_json
         else
-          bf_dump(request_body)
+          bf_dump(request_body_string)
         end.then { bf_truncate(_1) },
         "",
 
@@ -304,10 +352,10 @@ module Faraday
         "",
 
         %[-- Response Body (#{response_byte_count} #{response_byte_label}) --],
-        if !response_json.nil?
-          response_json
+        if !response_body_json.nil?
+          response_body_json
         else
-          bf_dump(response_body)
+          bf_dump(response_body_string)
         end.then { bf_truncate(_1) },
         ""
       ]
@@ -328,6 +376,7 @@ module Faraday
   end
 end
 
+
 module BetterFaraday
   class HTTPError < Faraday::Error
     def initialize(response)
@@ -419,7 +468,7 @@ module BetterFaraday
     # Various tokens (access_token, refresh_token, csrf_token, bearer_token, auth_token, or just token)
     /(?:access|refresh|auth|bearer|csrf|authorization)?#{separator}token/i,
     # API keys (api_key, apikey, x_api_key)
-    /api#{separator}key/i,
+    /api#{separator}(?:key|id)/i,
     # Private keys
     /private#{separator}key/i,
     # Crypto mnemonics

data/spec/binary_body_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "securerandom"
+
+RSpec.describe "BetterFaraday Binary Data Handling" do
+  # Generate 3000 bytes of random binary data (invalid UTF-8)
+  let(:binary_payload) { SecureRandom.random_bytes(3000) }
+  let(:expected_omission) { "... (truncated)" }
+
+  let(:env) do
+    Faraday::Env.from(
+      method: :post,
+      url: URI("https://api.example.com/upload"),
+      status: 200,
+      reason_phrase: "OK",
+      request_headers: { "Content-Type" => "application/octet-stream" },
+      request_body: binary_payload,
+      response_headers: { "Content-Type" => "image/png" },
+      body: binary_payload
+    )
+  end
+
+  let(:response) { Faraday::Response.new(env) }
+
+  before do
+    response.env.instance_variable_set(:@bf_request_headers, { "Content-Type" => "application/octet-stream" })
+    response.env.instance_variable_set(:@bf_request_body, binary_payload)
+  end
+
+  it "safely inspects binary data without encoding crashes and truncates it" do
+    inspection = nil
+
+    # Ensure no Encoding::UndefinedConversionError or similar exceptions are raised
+    expect { inspection = response.inspect }.not_to raise_error
+
+    # Verify that the byte count accurately reflects the binary size
+    expect(inspection).to include("-- Request Body (3000 bytes) --")
+    expect(inspection).to include("-- Response Body (3000 bytes) --")
+
+    # Verify that the output is safely truncated to avoid console memory bloat
+    expect(inspection).to include(expected_omission)
+
+    # The raw binary string should not be fully present in the output
+    expect(inspection).not_to include(binary_payload)
+  end
+end

data/spec/json_middleware_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "BetterFaraday with Faraday JSON Middlewares" do
+  let(:conn) do
+    Faraday.new(url: "https://api.example.com") do |f|
+      f.request :json
+      f.response :json
+
+      f.adapter :test do |stub|
+        stub.post("/process") do |env|
+          [
+            200,
+            { "Content-Type" => "application/json" },
+            '{"status": "success", "access_token": "secret_token_123", "user_id": 42}'
+          ]
+        end
+      end
+    end
+  end
+
+  it "safely inspects and masks data when bodies are transformed by JSON middlewares" do
+    request_payload = {
+      action: "login",
+      password: "my_super_secret_password"
+    }
+
+    response = conn.post("/process", request_payload)
+
+    expect(response.body).to be_a(Hash)
+    expect(response.body["status"]).to eq("success")
+
+    inspection = response.inspect
+
+    expect(inspection).to include('"password": "SECRET"')
+    expect(inspection).not_to include("my_super_secret_password")
+    expect(inspection).to include('"action": "login"')
+
+    expect(inspection).to include('"access_token": "SECRET"')
+    expect(inspection).not_to include("secret_token_123")
+    expect(inspection).to include('"user_id": 42')
+
+    expect(inspection).not_to include("=>")
+  end
+end

data/spec/json_parsing_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "BetterFaraday Pre-parsed Bodies & Status Formatting" do
+  let(:env) do
+    Faraday::Env.from(
+      method: :post,
+      url: URI("https://api.example.com/json"),
+      status: 422,
+      reason_phrase: "UNKNOWN", # Faraday sometimes defaults to UNKNOWN
+      request_headers: { "Content-Type" => "application/json" },
+      # Simulate body already parsed by Faraday JSON request middleware
+      request_body: { "account_type" => "trading", "password" => "secret_123" },
+      response_headers: { "Content-Type" => "application/json; charset=UTF-8" },
+      # Simulate body already parsed by Faraday JSON response middleware
+      body: { "code" => 40010001, "message" => "Invalid currency" }
+    )
+  end
+
+  let(:response) { Faraday::Response.new(env) }
+
+  before do
+    response.env.instance_variable_set(:@bf_request_headers, { "Content-Type" => "application/json" })
+    # This is what gets captured by the middleware
+    response.env.instance_variable_set(:@bf_request_body, { "account_type" => "trading", "password" => "secret_123" })
+  end
+
+  it "formats 'UNKNOWN' reason phrase correctly to UNPROCESSABLE ENTITY" do
+    inspection = response.inspect
+    expect(inspection).to include("-- HTTP 422 UNPROCESSABLE ENTITY --")
+  end
+
+  it "formats pre-parsed Hash response bodies to JSON strings and masks data" do
+    inspection = response.inspect
+
+    # Request Hash
+    expect(inspection).to include('"password": "SECRET"')
+    expect(inspection).to include('"account_type": "trading"')
+
+    # Response Hash
+    expect(inspection).to include('"code": 40010001')
+    expect(inspection).to include('"message": "Invalid currency"')
+
+    # Ensure Ruby hash notation is absolutely gone
+    expect(inspection).not_to include("=>")
+  end
+
+  it "resolves empty reason phrases to their Net::HTTP default strings" do
+    response.env.status = 201
+    response.env.reason_phrase = ""
+
+    expect(response.inspect).to include("-- HTTP 201 CREATED --")
+  end
+end

data/spec/reason_phrase_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "BetterFaraday Reason Phrase Formatting" do
+  let(:env) do
+    Faraday::Env.from(
+      method: :get,
+      url: URI("https://api.example.com/status"),
+      status: status,
+      reason_phrase: reason_phrase,
+      request_headers: {},
+      request_body: "",
+      response_headers: {},
+      body: ""
+    )
+  end
+
+  let(:response) { Faraday::Response.new(env) }
+
+  context "when reason_phrase is UNKNOWN" do
+    let(:status) { 422 }
+    let(:reason_phrase) { "UNKNOWN" }
+
+    it "resolves to UNPROCESSABLE ENTITY using Net::HTTP mapping" do
+      expect(response.inspect).to include("-- HTTP 422 UNPROCESSABLE ENTITY --")
+    end
+  end
+
+  context "when reason_phrase is empty" do
+    let(:status) { 201 }
+    let(:reason_phrase) { "   " }
+
+    it "resolves to CREATED using Net::HTTP mapping" do
+      expect(response.inspect).to include("-- HTTP 201 CREATED --")
+    end
+  end
+
+  context "when reason_phrase is valid" do
+    let(:status) { 418 }
+    let(:reason_phrase) { "I Am A Teapot" }
+
+    it "uses the provided reason phrase" do
+      expect(response.inspect).to include("-- HTTP 418 I AM A TEAPOT --")
+    end
+  end
+
+  context "when status code is completely unknown" do
+    let(:status) { 999 }
+    let(:reason_phrase) { "UNKNOWN" }
+
+    it "safely falls back to UNKNOWN if no Net::HTTP mapping exists" do
+      expect(response.inspect).to include("-- HTTP 999 UNKNOWN --")
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: better-faraday
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.1.2
 platform: ruby
 authors:
 - Yaroslav Konoplov
@@ -142,18 +142,23 @@ files:
 - README.md
 - Rakefile
 - better-faraday.gemspec
+- lib/better-faraday.rb
 - lib/better_faraday.rb
 - spec/adapters_spec.rb
 - spec/array_masking_spec.rb
 - spec/assert_status_spec.rb
+- spec/binary_body_spec.rb
 - spec/custom_sensitive_signs_spec.rb
 - spec/http_error_spec.rb
 - spec/inspect_truncation_spec.rb
 - spec/invalid_json_spec.rb
+- spec/json_middleware_spec.rb
+- spec/json_parsing_spec.rb
 - spec/logger_spec.rb
 - spec/middleware_spec.rb
 - spec/multipart_spec.rb
 - spec/nested_sensitive_data_spec.rb
+- spec/reason_phrase_spec.rb
 - spec/sensitive_data_signs_spec.rb
 - spec/spec_helper.rb
 - spec/timing_inspect_spec.rb
@@ -185,14 +190,18 @@ test_files:
 - spec/adapters_spec.rb
 - spec/array_masking_spec.rb
 - spec/assert_status_spec.rb
+- spec/binary_body_spec.rb
 - spec/custom_sensitive_signs_spec.rb
 - spec/http_error_spec.rb
 - spec/inspect_truncation_spec.rb
 - spec/invalid_json_spec.rb
+- spec/json_middleware_spec.rb
+- spec/json_parsing_spec.rb
 - spec/logger_spec.rb
 - spec/middleware_spec.rb
 - spec/multipart_spec.rb
 - spec/nested_sensitive_data_spec.rb
+- spec/reason_phrase_spec.rb
 - spec/sensitive_data_signs_spec.rb
 - spec/spec_helper.rb
 - spec/timing_inspect_spec.rb