http 5.3.1 → 6.0.0

data/test/http/form_data/multipart_test.rb

@@ -0,0 +1,303 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class FormDataMultipartTest < Minitest::Test
+  cover "HTTP::FormData::Multipart*"
+
+  BOUNDARY_PATTERN = /-{21}[a-f0-9]{42}/
+  CRLF = "\r\n"
+
+  private
+
+  def fixture_path
+    @fixture_path ||= Pathname.new(__dir__).join("fixtures/the-http-gem.info").realpath
+  end
+
+  def file
+    @file ||= HTTP::FormData::File.new(fixture_path)
+  end
+
+  def params
+    { foo: :bar, baz: file }
+  end
+
+  def form_data
+    @form_data ||= HTTP::FormData::Multipart.new(params)
+  end
+
+  def disposition(params)
+    params = params.map { |k, v| "#{k}=#{v.inspect}" }.join("; ")
+    "Content-Disposition: form-data; #{params}"
+  end
+
+  public
+
+  # --- Multipart body generation ---
+
+  def test_generates_multipart_data
+    b = form_data.boundary
+    expected = [
+      "--#{b}#{CRLF}",
+      "#{disposition 'name' => 'foo'}#{CRLF}",
+      "#{CRLF}bar#{CRLF}",
+      "--#{b}#{CRLF}",
+      "#{disposition 'name' => 'baz', 'filename' => file.filename}#{CRLF}",
+      "Content-Type: #{file.content_type}#{CRLF}",
+      "#{CRLF}#{file}#{CRLF}",
+      "--#{b}--#{CRLF}"
+    ].join
+
+    assert_equal expected, form_data.to_s
+  end
+
+  def test_user_defined_boundary
+    fd = HTTP::FormData::Multipart.new(params, boundary: "my-boundary")
+    expected = [
+      "--my-boundary#{CRLF}",
+      "#{disposition 'name' => 'foo'}#{CRLF}",
+      "#{CRLF}bar#{CRLF}",
+      "--my-boundary#{CRLF}",
+      "#{disposition 'name' => 'baz', 'filename' => file.filename}#{CRLF}",
+      "Content-Type: #{file.content_type}#{CRLF}",
+      "#{CRLF}#{file}#{CRLF}",
+      "--my-boundary--#{CRLF}"
+    ].join
+
+    assert_equal expected, fd.to_s
+  end
+
+  def test_part_without_filename
+    part = HTTP::FormData::Part.new("s", content_type: "mime/type")
+    fd = HTTP::FormData::Multipart.new({ foo: part })
+    b = fd.content_type[/(#{BOUNDARY_PATTERN})$/o, 1]
+
+    expected = [
+      "--#{b}#{CRLF}",
+      "#{disposition 'name' => 'foo'}#{CRLF}",
+      "Content-Type: #{part.content_type}#{CRLF}",
+      "#{CRLF}s#{CRLF}",
+      "--#{b}--#{CRLF}"
+    ].join
+
+    assert_equal expected, fd.to_s
+  end
+
+  def test_part_without_content_type
+    part = HTTP::FormData::Part.new("s")
+    fd = HTTP::FormData::Multipart.new({ foo: part })
+    b = fd.content_type[/(#{BOUNDARY_PATTERN})$/o, 1]
+
+    expected = [
+      "--#{b}#{CRLF}",
+      "#{disposition 'name' => 'foo'}#{CRLF}",
+      "#{CRLF}s#{CRLF}",
+      "--#{b}--#{CRLF}"
+    ].join
+
+    assert_equal expected, fd.to_s
+  end
+
+  def test_supports_enumerable_of_pairs
+    enum = Enumerator.new { |y| y << %i[foo bar] << %i[foo baz] }
+    fd = HTTP::FormData::Multipart.new(enum)
+    b = fd.boundary
+
+    expected = [
+      "--#{b}#{CRLF}",
+      "#{disposition 'name' => 'foo'}#{CRLF}",
+      "#{CRLF}bar#{CRLF}",
+      "--#{b}#{CRLF}",
+      "#{disposition 'name' => 'foo'}#{CRLF}",
+      "#{CRLF}baz#{CRLF}",
+      "--#{b}--#{CRLF}"
+    ].join
+
+    assert_equal expected, fd.to_s
+  end
+
+  def test_array_of_pairs_with_duplicate_names
+    data = [
+      ["metadata", %(filename="first.txt")],
+      ["file", HTTP::FormData::File.new(StringIO.new("uno"), content_type: "plain/text", filename: "abc")],
+      ["metadata", %(filename="second.txt")],
+      ["file", HTTP::FormData::File.new(StringIO.new("dos"), content_type: "plain/text", filename: "xyz")],
+      ["metadata", %w[question=why question=not]]
+    ]
+    fd = HTTP::FormData::Multipart.new(data)
+    b = fd.boundary
+
+    expected = [
+      %(--#{b}\r\n),
+      %(Content-Disposition: form-data; name="metadata"\r\n),
+      %(\r\nfilename="first.txt"\r\n),
+      %(--#{b}\r\n),
+      %(Content-Disposition: form-data; name="file"; filename="abc"\r\n),
+      %(Content-Type: plain/text\r\n),
+      %(\r\nuno\r\n),
+      %(--#{b}\r\n),
+      %(Content-Disposition: form-data; name="metadata"\r\n),
+      %(\r\nfilename="second.txt"\r\n),
+      %(--#{b}\r\n),
+      %(Content-Disposition: form-data; name="file"; filename="xyz"\r\n),
+      %(Content-Type: plain/text\r\n),
+      %(\r\ndos\r\n),
+      %(--#{b}\r\n),
+      %(Content-Disposition: form-data; name="metadata"\r\n),
+      %(\r\nquestion=why\r\n),
+      %(--#{b}\r\n),
+      %(Content-Disposition: form-data; name="metadata"\r\n),
+      %(\r\nquestion=not\r\n),
+      %(--#{b}--\r\n)
+    ].join
+
+    assert_equal expected, fd.to_s
+  end
+
+  # --- size / read / rewind ---
+
+  def test_size_returns_bytesize
+    assert_equal form_data.to_s.bytesize, form_data.size
+  end
+
+  def test_read_returns_multipart_data
+    assert_equal form_data.to_s, form_data.read
+  end
+
+  def test_rewind
+    form_data.read
+    form_data.rewind
+
+    assert_equal form_data.to_s, form_data.read
+  end
+
+  def test_content_length
+    assert_equal form_data.to_s.bytesize, form_data.content_length
+  end
+
+  def test_to_s_rewinds_content
+    content = form_data.read
+
+    assert_equal content, form_data.to_s
+    assert_equal content, form_data.read
+  end
+
+  # --- Content type ---
+
+  def test_content_type_matches_pattern
+    assert_match(%r{^multipart/form-data; boundary=#{BOUNDARY_PATTERN}$}o, form_data.content_type)
+  end
+
+  def test_content_type_with_user_defined_boundary
+    fd = HTTP::FormData::Multipart.new(params, boundary: "my-boundary")
+
+    assert_equal "multipart/form-data; boundary=my-boundary", fd.content_type
+  end
+
+  def test_content_type_with_custom_type
+    fd = HTTP::FormData::Multipart.new(params, boundary: "b", content_type: "multipart/related")
+
+    assert_equal "multipart/related; boundary=b", fd.content_type
+  end
+
+  def test_content_type_with_multipart_mixed
+    fd = HTTP::FormData::Multipart.new(params, boundary: "b", content_type: "multipart/mixed")
+
+    assert_equal "multipart/mixed; boundary=b", fd.content_type
+  end
+
+  def test_content_type_default_is_form_data
+    assert_equal "multipart/form-data", HTTP::FormData::Multipart::DEFAULT_CONTENT_TYPE
+  end
+
+  def test_content_type_converts_to_string
+    fd = HTTP::FormData::Multipart.new(params, boundary: "b", content_type: :"multipart/related")
+
+    assert_equal "multipart/related; boundary=b", fd.content_type
+    assert_instance_of String, fd.content_type
+  end
+
+  # --- Boundary ---
+
+  def test_boundary_matches_pattern
+    assert_match(BOUNDARY_PATTERN, form_data.boundary)
+  end
+
+  def test_boundary_with_user_defined_value
+    fd = HTTP::FormData::Multipart.new(params, boundary: "my-boundary")
+
+    assert_equal "my-boundary", fd.boundary
+  end
+
+  def test_boundary_is_frozen_string
+    assert_predicate form_data.boundary, :frozen?
+    assert_instance_of String, form_data.boundary
+  end
+
+  def test_boundary_with_symbol_value
+    fd = HTTP::FormData::Multipart.new({ foo: "bar" }, boundary: :"my-sym-boundary")
+
+    assert_equal "my-sym-boundary", fd.boundary
+    assert_instance_of String, fd.boundary
+  end
+
+  def test_generate_boundary
+    assert_match(BOUNDARY_PATTERN, HTTP::FormData::Multipart.generate_boundary)
+  end
+
+  # --- Param ---
+
+  def test_parts_with_nil_data
+    form = HTTP::FormData::Multipart.new(nil, boundary: "test-boundary")
+
+    assert_equal "--test-boundary--\r\n", form.to_s
+  end
+
+  def test_param_converts_name_to_string
+    part = HTTP::FormData::Part.new("val")
+    body = HTTP::FormData::Multipart.new({ 123 => part }, boundary: "b").to_s
+
+    assert_includes body, 'name="123"'
+  end
+
+  def test_param_wraps_non_part_value
+    body = HTTP::FormData::Multipart.new({ foo: "raw_string" }, boundary: "b").to_s
+
+    assert_includes body, "raw_string"
+    refute_includes body, "Content-Type:"
+  end
+
+  def test_param_uses_part_directly
+    part = HTTP::FormData::Part.new("part_body", content_type: "text/plain")
+    body = HTTP::FormData::Multipart.new({ foo: part }, boundary: "b").to_s
+
+    assert_includes body, "part_body"
+    assert_includes body, "Content-Type: text/plain"
+  end
+
+  def test_param_header_contains_content_disposition
+    body = HTTP::FormData::Multipart.new({ myfield: "val" }, boundary: "b").to_s
+
+    assert_includes body, "Content-Disposition: form-data; name=\"myfield\""
+  end
+
+  def test_param_includes_content_type_when_present
+    part = HTTP::FormData::Part.new("val", content_type: "application/json")
+    body = HTTP::FormData::Multipart.new({ f: part }, boundary: "b").to_s
+
+    assert_includes body, "Content-Type: application/json\r\n"
+  end
+
+  def test_param_excludes_content_type_when_nil
+    part = HTTP::FormData::Part.new("val")
+    body = HTTP::FormData::Multipart.new({ f: part }, boundary: "b").to_s
+
+    refute_includes body, "Content-Type:"
+  end
+
+  def test_param_footer_is_crlf
+    body = HTTP::FormData::Multipart.new({ f: "v" }, boundary: "b").to_s
+
+    assert_includes body, "v\r\n--b--"
+  end
+end

data/test/http/form_data/part_test.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class FormDataPartTest < Minitest::Test
+  cover "HTTP::FormData::Part*"
+
+  def test_size
+    assert_equal 20, HTTP::FormData::Part.new("привет мир!").size
+  end
+
+  def test_to_s
+    assert_equal "привет мир!", HTTP::FormData::Part.new("привет мир!").to_s
+  end
+
+  def test_to_s_rewinds_content
+    part = HTTP::FormData::Part.new("привет мир!")
+    part.to_s
+    content = part.read
+
+    assert_equal content, part.to_s
+    assert_equal content, part.read
+  end
+
+  def test_read
+    assert_equal "привет мир!", HTTP::FormData::Part.new("привет мир!").read
+  end
+
+  def test_read_with_length
+    part = HTTP::FormData::Part.new("hello world")
+
+    assert_equal "hello", part.read(5)
+    assert_equal " worl", part.read(5)
+    assert_equal "d", part.read(5)
+    assert_nil part.read(5)
+  end
+
+  def test_read_with_nil_length
+    assert_equal "hello", HTTP::FormData::Part.new("hello").read(nil)
+  end
+
+  def test_read_with_outbuf
+    part = HTTP::FormData::Part.new("hello")
+    buf = +""
+    result = part.read(3, buf)
+
+    assert_equal "hel", result
+    assert_equal "hel", buf
+  end
+
+  def test_rewind
+    part = HTTP::FormData::Part.new("привет мир!")
+    part.read
+    part.rewind
+
+    assert_equal "привет мир!", part.read
+  end
+
+  def test_filename_defaults_to_nil
+    assert_nil HTTP::FormData::Part.new("").filename
+  end
+
+  def test_filename_with_option
+    assert_equal "foobar.txt", HTTP::FormData::Part.new("", filename: "foobar.txt").filename
+  end
+
+  def test_filename_stores_exact_value
+    assert_equal "test.txt", HTTP::FormData::Part.new("body", filename: "test.txt").filename
+  end
+
+  def test_content_type_defaults_to_nil
+    assert_nil HTTP::FormData::Part.new("").content_type
+  end
+
+  def test_content_type_with_option
+    assert_equal "application/json", HTTP::FormData::Part.new("", content_type: "application/json").content_type
+  end
+
+  def test_content_type_stores_exact_value
+    assert_equal "text/plain", HTTP::FormData::Part.new("body", content_type: "text/plain").content_type
+  end
+
+  def test_initialize_converts_body_to_string
+    assert_equal "42", HTTP::FormData::Part.new(42).to_s
+  end
+
+  def test_initialize_with_symbol_body
+    assert_equal "hello", HTTP::FormData::Part.new(:hello).to_s
+  end
+end

data/test/http/form_data/urlencoded_test.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class FormDataUrlencodedTest < Minitest::Test
+  cover "HTTP::FormData::Urlencoded*"
+
+  def test_raises_error_for_non_enumerable_input
+    assert_raises(HTTP::FormData::Error) { HTTP::FormData::Urlencoded.new(42) }
+  end
+
+  def test_raises_argument_error_for_non_hash_top_level
+    assert_raises(ArgumentError) { HTTP::FormData::Urlencoded.encoder.call(42) }
+  end
+
+  def test_supports_enumerables_of_pairs
+    form_data = HTTP::FormData::Urlencoded.new([%w[foo bar], ["foo", %w[baz moo]]])
+
+    assert_equal "foo=bar&foo[]=baz&foo[]=moo", form_data.to_s
+  end
+
+  def test_content_type
+    assert_equal "application/x-www-form-urlencoded", HTTP::FormData::Urlencoded.new({ foo: "bar" }).content_type
+  end
+
+  def test_content_length
+    form_data = HTTP::FormData::Urlencoded.new({ "foo[bar]" => "test" })
+
+    assert_equal form_data.to_s.bytesize, form_data.content_length
+  end
+
+  def test_content_length_with_unicode
+    form_data = HTTP::FormData::Urlencoded.new({ "foo[bar]" => "тест" })
+
+    assert_equal form_data.to_s.bytesize, form_data.content_length
+  end
+
+  def test_to_s
+    assert_equal "foo%5Bbar%5D=test", HTTP::FormData::Urlencoded.new({ "foo[bar]" => "test" }).to_s
+  end
+
+  def test_to_s_with_unicode
+    assert_equal "foo%5Bbar%5D=%D1%82%D0%B5%D1%81%D1%82",
+                 HTTP::FormData::Urlencoded.new({ "foo[bar]" => "тест" }).to_s
+  end
+
+  def test_to_s_with_nested_hashes
+    assert_equal "foo[bar]=test", HTTP::FormData::Urlencoded.new({ "foo" => { "bar" => "test" } }).to_s
+  end
+
+  def test_to_s_with_nil_value
+    assert_equal "foo", HTTP::FormData::Urlencoded.new({ "foo" => nil }).to_s
+  end
+
+  def test_to_s_rewinds_content
+    form_data = HTTP::FormData::Urlencoded.new({ "foo[bar]" => "test" })
+    content = form_data.read
+
+    assert_equal content, form_data.to_s
+    assert_equal content, form_data.read
+  end
+
+  def test_size
+    form_data = HTTP::FormData::Urlencoded.new({ "foo[bar]" => "test" })
+
+    assert_equal form_data.to_s.bytesize, form_data.size
+  end
+
+  def test_read
+    form_data = HTTP::FormData::Urlencoded.new({ "foo[bar]" => "test" })
+
+    assert_equal form_data.to_s, form_data.read
+  end
+
+  def test_rewind
+    form_data = HTTP::FormData::Urlencoded.new({ "foo[bar]" => "test" })
+    form_data.read
+    form_data.rewind
+
+    assert_equal form_data.to_s, form_data.read
+  end
+
+  # --- Custom encoders ---
+
+  def test_custom_class_level_encoder
+    original_encoder = HTTP::FormData::Urlencoded.encoder
+    HTTP::FormData::Urlencoded.encoder = JSON.method(:dump)
+    form_data = HTTP::FormData::Urlencoded.new({ "foo[bar]" => "test" })
+
+    assert_equal '{"foo[bar]":"test"}', form_data.to_s
+  ensure
+    HTTP::FormData::Urlencoded.encoder = original_encoder
+  end
+
+  def test_encoder_rejects_non_callable
+    assert_raises(ArgumentError) { HTTP::FormData::Urlencoded.encoder = "not callable" }
+  end
+
+  def test_custom_instance_level_encoder
+    encoder = proc { |data| JSON.dump(data) }
+    form_data = HTTP::FormData::Urlencoded.new({ "foo[bar]" => "test" }, encoder: encoder)
+
+    assert_equal '{"foo[bar]":"test"}', form_data.to_s
+  end
+
+  def test_default_encoder_returns_callable
+    assert_respond_to HTTP::FormData::Urlencoded.encoder, :call
+  end
+
+  def test_default_encoder_encodes_correctly
+    assert_equal "key=value", HTTP::FormData::Urlencoded.encoder.call({ "key" => "value" })
+  end
+
+  def test_nil_encoder_uses_class_default
+    form_data = HTTP::FormData::Urlencoded.new({ foo: "bar" }, encoder: nil)
+
+    assert_equal "foo=bar", form_data.to_s
+  end
+
+  def test_custom_encoder_is_called
+    calls = []
+    custom = proc { |data|
+      calls << data
+      "custom"
+    }
+    form_data = HTTP::FormData::Urlencoded.new({ a: "b" }, encoder: custom)
+
+    assert_equal "custom", form_data.to_s
+    refute_empty calls
+  end
+
+  # --- Initialize edge cases ---
+
+  def test_initialize_with_nil_data
+    assert_equal "", HTTP::FormData::Urlencoded.new(nil).to_s
+  end
+
+  def test_initialize_with_to_h_object
+    obj = Object.new
+    def obj.to_h = { x: "y" }
+
+    assert_equal "x=y", HTTP::FormData::Urlencoded.new(obj).to_s
+  end
+
+  def test_initialize_stores_encoded_content
+    form_data = HTTP::FormData::Urlencoded.new({ a: "1", b: "2" })
+
+    assert_equal "a=1&b=2", form_data.to_s
+    assert_equal 7, form_data.size
+  end
+
+  def test_read_with_length
+    form_data = HTTP::FormData::Urlencoded.new({ foo: "bar" })
+
+    assert_equal "fo", form_data.read(2)
+    assert_equal "o=b", form_data.read(3)
+    assert_equal "ar", form_data.read(5)
+    assert_nil form_data.read(1)
+  end
+
+  def test_read_with_nil_length
+    assert_equal "foo=bar", HTTP::FormData::Urlencoded.new({ foo: "bar" }).read(nil)
+  end
+end