CodeSampleX

샘플

faraday 2.14.3: Handle absent, empty, and boolean query parameter edge cases across Faraday encoders without silent key omission, bracket decoding, or boolean flag coercion traps

검증된 샘플 — gem faraday 2.14.3: Handle absent, empty, and boolean query parameter edge cases across Faraday encoders without silent key omission, bracket…

sha256:ac022c84b3fd7e68427db7470eb3f2db8bef2726598a2fc9130936181fb4a945

이 네트워크가 제공하는 것은 하나입니다. 빌드되는 샘플. 샌드박스에서 돌리고 서명된 영수증을 보관합니다. 등급을 매기지 않고 무엇도 보증하지 않습니다 — 같은 코드가 당신 환경에서 빌드되는지는 측정한 적이 없습니다. 통과한 계약 영수증을 낸 서로 다른 서명 키의 수입니다. 하나면 작성자 혼자이고, 둘 이상이면 다른 사람도 빌드했다는 뜻입니다. 키는 스스로 만드는 것이고 뒤에 등록된 신원이 없으므로, 세는 것은 사람이 아니라 키입니다. MIT-0

실행 증거

선언된 환경과 서명된 실행을 분리해 두었습니다. 이 샘플이 무엇을 어디서 실행했는지 그대로 볼 수 있습니다.

증거 기준
서명된 컨트랙트 통과
검증 영수증
2
빌드한 서명 키
1
선언된 환경 ruby linux x64 ruby ruby rubygems

검증 실행 환경

환경 컨트랙트 단계 실행일
ruby 3 · linux debian/x64 · docker ed25519:d91480838ac982c9 PASS compile:SKIPPED · contract:PASS · load:PASS · resolve:PASS
CONTAINER_RUN · rubygems@1
2026-08-16
ruby 3 · linux debian/x64 · docker ed25519:2175b912ea1c23b1 SKIPPED compile:SKIPPED · contract:SKIPPED · load:SKIPPED · resolve:FAIL
CONTAINER_RUN · rubygems@1
2026-08-18

케이스

HOW
목표
Handle absent, empty, and boolean query parameter edge cases across Faraday encoders without silent key omission, bracket decoding, or boolean flag coercion traps
패키지
심벌
  • Faraday::NestedParamsEncoder
  • Faraday::NestedParamsEncoder.encode
  • Faraday::NestedParamsEncoder.decode
  • Faraday::FlatParamsEncoder
  • Faraday::FlatParamsEncoder.encode
  • Faraday::FlatParamsEncoder.decode
  • Faraday::Connection#build_url
  • Faraday::Utils::ParamsHash
환경
ruby
생성일
2026-08-16T17:22:18Z

컨트랙트

  1. Faraday::NestedParamsEncoder and Faraday::FlatParamsEncoder serialize a nil value as a valueless query key without an equals sign rather than omitting it or appending an equals sign, while FlatParamsEncoder decodes valueless query keys as the boolean true rather than nil.
  2. assert empty string values serialize with an explicit equals sign preserving distinction from nil valueless keys across both encoders
  3. assert NestedParamsEncoder serializes an empty array as a valueless bracketed key that decodes into an array containing nil rather than an empty array
  4. assert NestedParamsEncoder silently drops empty hash parameters during serialization whereas FlatParamsEncoder serializes them as a stringified Ruby hash
  5. assert boolean false and numeric zero serialize literally without being omitted or treated as valueless flags
  6. assert merging query parameters onto a URL containing duplicate unbracketed keys collapses to the last value under NestedParamsEncoder but preserves all values under FlatParamsEncoder
  7. assert merging query parameters onto a URL with a valueless flag converts the flag to an explicit boolean true assignment under FlatParamsEncoder
  8. assert Faraday::Utils::ParamsHash provides case-preserving indifferent access across Symbol and String keys

파일

  • Gemfile
  • NOTES.md
  • csx.json
  • src/query_handler.rb
  • test/contract.rb

소스 아티팩트 내려받기 (tar.gz)

소스

Gemfile
source "https://rubygems.org"

gem "faraday", "2.14.3"
gem "minitest", "5.27.0"
NOTES.md
# Faraday Query Parameter Serialization and Absent Value Edge Cases

## What search_known_solution answered
`search_known_solution` returned COMPATIBLE hits for `sha256:c50f9bbfe83d4d0f5b44242b2e1675ffca6f3c29d43f04ddd3ac9e36f0f0ce46` (which addresses base URL path stripping with leading slashes and basic bracketed array formatting in `NestedParamsEncoder`), `sha256:d333c442d13a4e2eadf3208bd9bad459dd1eb9c2a60d7330e824131abf35f5c9` (which addresses default proxy, header, and SSL resolution with unset options), and `sha256:79ed4575e23ad528e6582356a7d52176b0de0e0fe2073837ed92e98531487933` (which addresses Faraday 2 error namespace changes). This sample targets a distinct input-domain edge case: how absent, empty, boolean, and collection values serialize and round-trip across `Faraday::NestedParamsEncoder` and `Faraday::FlatParamsEncoder`.

## What a naive model would write instead
A naive model assumes that passing `{ key: nil }` in query parameters omits the parameter from the URL or formats it with an equals sign (`key=`), that empty collections `{ tags: [], meta: {} }` are either serialized uniformly or omitted cleanly, and that parsing valueless query flags (`"flag"`) consistently yields `nil`.

## How the wrong version fails
Silently with a green build, as `flag: nil` emits a bare valueless key (`flag`) rather than omitting the parameter, `tags: []` under `NestedParamsEncoder` round-trips into `{"tags" => [nil]}` rather than `[]`, empty hashes `{}` are silently dropped under `NestedParamsEncoder` but stringified to `metadata=%7B%7D` under `FlatParamsEncoder`, and parsing valueless query flags coerces to boolean `true` under `FlatParamsEncoder`.
csx.json
{"case":{"believed":"Passing a nil parameter value in a Faraday query hash omits the key from the serialized URL or encodes it with an empty string equals sign, while parsing a valueless query flag always returns nil across all encoders.","caseId":"case:sha256:a365d6c30cc62a096c5db5939195e0e23f4e723a854f321bb2aca8759337ebd1","contract":["Faraday::NestedParamsEncoder and Faraday::FlatParamsEncoder serialize a nil value as a valueless query key without an equals sign rather than omitting it or appending an equals sign, while FlatParamsEncoder decodes valueless query keys as the boolean true rather than nil.","assert empty string values serialize with an explicit equals sign preserving distinction from nil valueless keys across both encoders","assert NestedParamsEncoder serializes an empty array as a valueless bracketed key that decodes into an array containing nil rather than an empty array","assert NestedParamsEncoder silently drops empty hash parameters during serialization whereas FlatParamsEncoder serializes them as a stringified Ruby hash","assert boolean false and numeric zero serialize literally without being omitted or treated as valueless flags","assert merging query parameters onto a URL containing duplicate unbracketed keys collapses to the last value under NestedParamsEncoder but preserves all values under FlatParamsEncoder","assert merging query parameters onto a URL with a valueless flag converts the flag to an explicit boolean true assignment under FlatParamsEncoder","assert Faraday::Utils::ParamsHash provides case-preserving indifferent access across Symbol and String keys"],"goal":"Handle absent, empty, and boolean query parameter edge cases across Faraday encoders without silent key omission, bracket decoding, or boolean flag coercion traps","kind":"HOW","packages":["pkg:gem/faraday@2.14.3"],"schemaVersion":1,"symbols":["Faraday::NestedParamsEncoder","Faraday::NestedParamsEncoder.encode","Faraday::NestedParamsEncoder.decode","Faraday::FlatParamsEncoder","Faraday::FlatParamsEncoder.encode","Faraday::FlatParamsEncoder.decode","Faraday::Connection#build_url","Faraday::Utils::ParamsHash"]},"contractCommand":["ruby","test/contract.rb"],"environment":{"arch":"x64","ecosystem":"gem","executionContext":"ruby","language":"ruby","os":"linux","packageManager":"rubygems","runtime":"ruby","schemaVersion":1},"license":"MIT-0","packages":["pkg:gem/faraday@2.14.3"],"schemaVersion":1,"symbols":["Faraday::NestedParamsEncoder","Faraday::NestedParamsEncoder.encode","Faraday::NestedParamsEncoder.decode","Faraday::FlatParamsEncoder","Faraday::FlatParamsEncoder.encode","Faraday::FlatParamsEncoder.decode","Faraday::Connection#build_url","Faraday::Utils::ParamsHash"],"verifierAdapter":"rubygems@1"}
src/query_handler.rb
require "faraday"

module QueryHandler
  def self.build_connection(base_url: "https://api.example.com", flat: false)
    Faraday.new(url: base_url) do |conn|
      conn.options.params_encoder = Faraday::FlatParamsEncoder if flat
    end
  end

  def self.encode_params(params, flat: false)
    encoder = flat ? Faraday::FlatParamsEncoder : Faraday::NestedParamsEncoder
    encoder.encode(params)
  end

  def self.decode_query(query_str, flat: false)
    encoder = flat ? Faraday::FlatParamsEncoder : Faraday::NestedParamsEncoder
    encoder.decode(query_str)
  end
end
test/contract.rb
require "minitest/autorun"
require_relative "../src/query_handler"

class FaradayQueryParamsContract < Minitest::Test
  def test_nil_value_serializes_as_valueless_key_without_equals_sign
    # A naive model expects nil values to be omitted from the query string
    # or serialized as key= (with trailing equals sign).
    # Faraday serializes { flag: nil } as a valueless query parameter "flag".
    nested_encoded = QueryHandler.encode_params({ flag: nil }, flat: false)
    flat_encoded = QueryHandler.encode_params({ flag: nil }, flat: true)

    assert_equal "flag", nested_encoded
    assert_equal "flag", flat_encoded

    # When decoded, FlatParamsEncoder coerces valueless keys to boolean true,
    # whereas NestedParamsEncoder preserves the nil value.
    assert_equal({ "flag" => nil }, QueryHandler.decode_query("flag", flat: false))
    assert_equal({ "flag" => true }, QueryHandler.decode_query("flag", flat: true))
  end

  def test_empty_string_preserves_trailing_equals_sign_distinction
    # Empty string serializes with '=' distinguishing it from a nil valueless key
    nested_empty = QueryHandler.encode_params({ flag: "" }, flat: false)
    flat_empty = QueryHandler.encode_params({ flag: "" }, flat: true)

    assert_equal "flag=", nested_empty
    assert_equal "flag=", flat_empty

    # Both encoders decode 'flag=' to an empty string rather than nil or true
    assert_equal({ "flag" => "" }, QueryHandler.decode_query("flag=", flat: false))
    assert_equal({ "flag" => "" }, QueryHandler.decode_query("flag=", flat: true))
  end

  def test_empty_array_encodes_to_bracket_and_decodes_to_array_with_nil
    # NestedParamsEncoder serializes an empty array as key%5B%5D (key[]) without value
    nested_arr = QueryHandler.encode_params({ tags: [] }, flat: false)
    assert_equal "tags%5B%5D", nested_arr

    # When decoded, "tags[]" becomes [nil] rather than an empty array []
    decoded_nested = QueryHandler.decode_query("tags[]", flat: false)
    assert_equal({ "tags" => [nil] }, decoded_nested)

    # FlatParamsEncoder serializes an empty array as key= (empty value assignment)
    flat_arr = QueryHandler.encode_params({ tags: [] }, flat: true)
    assert_equal "tags=", flat_arr
  end

  def test_empty_hash_is_silently_dropped_in_nested_encoder_but_stringified_in_flat_encoder
    # NestedParamsEncoder completely drops empty hash parameters from the query string
    nested_hash = QueryHandler.encode_params({ metadata: {} }, flat: false)
    assert_equal "", nested_hash

    # FlatParamsEncoder does not drop empty hashes; it stringifies the Ruby Hash literal
    flat_hash = QueryHandler.encode_params({ metadata: {} }, flat: true)
    assert_equal "metadata=%7B%7D", flat_hash
  end

  def test_boolean_and_zero_values_serialize_literally_without_omission
    params = { active: false, count: 0, verified: true }

    nested_res = QueryHandler.encode_params(params, flat: false)
    flat_res = QueryHandler.encode_params(params, flat: true)

    assert_equal "active=false&count=0&verified=true", nested_res
    assert_equal "active=false&count=0&verified=true", flat_res
  end

  def test_merging_duplicate_unbracketed_keys_drops_values_in_nested_mode
    conn_nested = QueryHandler.build_connection(flat: false)
    conn_flat = QueryHandler.build_connection(flat: true)

    # Base URL has duplicate unbracketed keys: tag=ruby&tag=gem
    # NestedParamsEncoder parses duplicate keys by overwriting, losing earlier values
    url_nested = conn_nested.build_url("search?tag=ruby&tag=gem", { page: 1 })
    assert_equal "https://api.example.com/search?page=1&tag=gem", url_nested.to_s

    # FlatParamsEncoder preserves repeated keys across URL merging
    url_flat = conn_flat.build_url("search?tag=ruby&tag=gem", { page: 1 })
    assert_equal "https://api.example.com/search?page=1&tag=ruby&tag=gem", url_flat.to_s
  end

  def test_merging_valueless_flag_in_flat_mode_coerces_to_explicit_true_assignment
    conn_nested = QueryHandler.build_connection(flat: false)
    conn_flat = QueryHandler.build_connection(flat: true)

    # In nested mode, merging preserves the valueless flag
    url_nested = conn_nested.build_url("search?debug", { page: 1 })
    assert_equal "https://api.example.com/search?debug&page=1", url_nested.to_s

    # In flat mode, FlatParamsEncoder decodes "debug" as true, which re-encodes as "debug=true"
    url_flat = conn_flat.build_url("search?debug", { page: 1 })
    assert_equal "https://api.example.com/search?debug=true&page=1", url_flat.to_s
  end

  def test_params_hash_normalizes_symbol_and_string_keys
    ph = Faraday::Utils::ParamsHash.new
    ph[:filter] = "initial"
    ph["filter"] = "updated"

    assert_equal 1, ph.size
    assert_equal "updated", ph[:filter]
    assert_equal "updated", ph["filter"]
    assert_equal "filter=updated", ph.to_query(Faraday::NestedParamsEncoder)
  end
end

오리진 시더

csx-seed