http 5.3.1 → 6.0.0

data/spec/lib/http/headers_spec.rb

@@ -1,527 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::Headers do
-  subject(:headers) { described_class.new }
-
-  it "is Enumerable" do
-    expect(headers).to be_an Enumerable
-  end
-
-  describe "#set" do
-    it "sets header value" do
-      headers.set "Accept", "application/json"
-      expect(headers["Accept"]).to eq "application/json"
-    end
-
-    it "allows retrieval via normalized header name" do
-      headers.set :content_type, "application/json"
-      expect(headers["Content-Type"]).to eq "application/json"
-    end
-
-    it "overwrites previous value" do
-      headers.set :set_cookie, "hoo=ray"
-      headers.set :set_cookie, "woo=hoo"
-      expect(headers["Set-Cookie"]).to eq "woo=hoo"
-    end
-
-    it "allows set multiple values" do
-      headers.set :set_cookie, "hoo=ray"
-      headers.set :set_cookie, %w[hoo=ray woo=hoo]
-      expect(headers["Set-Cookie"]).to eq %w[hoo=ray woo=hoo]
-    end
-
-    it "fails with empty header name" do
-      expect { headers.set "", "foo bar" }.
-        to raise_error HTTP::HeaderError
-    end
-
-    ["foo bar", "foo bar: ok\nfoo", "evil-header: evil-value\nfoo"].each do |name|
-      it "fails with invalid header name (#{name.inspect})" do
-        expect { headers.set name, "baz" }.
-          to raise_error HTTP::HeaderError
-      end
-    end
-
-    it "fails with invalid header value" do
-      expect { headers.set "foo", "bar\nEvil-Header: evil-value" }.
-        to raise_error HTTP::HeaderError
-    end
-  end
-
-  describe "#[]=" do
-    it "sets header value" do
-      headers["Accept"] = "application/json"
-      expect(headers["Accept"]).to eq "application/json"
-    end
-
-    it "allows retrieval via normalized header name" do
-      headers[:content_type] = "application/json"
-      expect(headers["Content-Type"]).to eq "application/json"
-    end
-
-    it "overwrites previous value" do
-      headers[:set_cookie] = "hoo=ray"
-      headers[:set_cookie] = "woo=hoo"
-      expect(headers["Set-Cookie"]).to eq "woo=hoo"
-    end
-
-    it "allows set multiple values" do
-      headers[:set_cookie] = "hoo=ray"
-      headers[:set_cookie] = %w[hoo=ray woo=hoo]
-      expect(headers["Set-Cookie"]).to eq %w[hoo=ray woo=hoo]
-    end
-  end
-
-  describe "#delete" do
-    before { headers.set "Content-Type", "application/json" }
-
-    it "removes given header" do
-      headers.delete "Content-Type"
-      expect(headers["Content-Type"]).to be_nil
-    end
-
-    it "removes header that matches normalized version of specified name" do
-      headers.delete :content_type
-      expect(headers["Content-Type"]).to be_nil
-    end
-
-    it "fails with empty header name" do
-      expect { headers.delete "" }.
-        to raise_error HTTP::HeaderError
-    end
-
-    ["foo bar", "foo bar: ok\nfoo"].each do |name|
-      it "fails with invalid header name (#{name.inspect})" do
-        expect { headers.delete name }.
-          to raise_error HTTP::HeaderError
-      end
-    end
-  end
-
-  describe "#add" do
-    it "sets header value" do
-      headers.add "Accept", "application/json"
-      expect(headers["Accept"]).to eq "application/json"
-    end
-
-    it "allows retrieval via normalized header name" do
-      headers.add :content_type, "application/json"
-      expect(headers["Content-Type"]).to eq "application/json"
-    end
-
-    it "appends new value if header exists" do
-      headers.add "Set-Cookie", "hoo=ray"
-      headers.add :set_cookie, "woo=hoo"
-      expect(headers["Set-Cookie"]).to eq %w[hoo=ray woo=hoo]
-    end
-
-    it "allows append multiple values" do
-      headers.add :set_cookie, "hoo=ray"
-      headers.add :set_cookie, %w[woo=hoo yup=pie]
-      expect(headers["Set-Cookie"]).to eq %w[hoo=ray woo=hoo yup=pie]
-    end
-
-    it "fails with empty header name" do
-      expect { headers.add("", "foobar") }.
-        to raise_error HTTP::HeaderError
-    end
-
-    ["foo bar", "foo bar: ok\nfoo"].each do |name|
-      it "fails with invalid header name (#{name.inspect})" do
-        expect { headers.add name, "baz" }.
-          to raise_error HTTP::HeaderError
-      end
-    end
-
-    it "fails with invalid header value" do
-      expect { headers.add "foo", "bar\nEvil-Header: evil-value" }.
-        to raise_error HTTP::HeaderError
-    end
-
-    it "fails when header name is not a String or Symbol" do
-      expect { headers.add 2, "foo" }.
-        to raise_error HTTP::HeaderError
-    end
-  end
-
-  describe "#get" do
-    before { headers.set("Content-Type", "application/json") }
-
-    it "returns array of associated values" do
-      expect(headers.get("Content-Type")).to eq %w[application/json]
-    end
-
-    it "normalizes header name" do
-      expect(headers.get(:content_type)).to eq %w[application/json]
-    end
-
-    context "when header does not exists" do
-      it "returns empty array" do
-        expect(headers.get(:accept)).to eq []
-      end
-    end
-
-    it "fails with empty header name" do
-      expect { headers.get("") }.
-        to raise_error HTTP::HeaderError
-    end
-
-    ["foo bar", "foo bar: ok\nfoo"].each do |name|
-      it "fails with invalid header name (#{name.inspect})" do
-        expect { headers.get name }.
-          to raise_error HTTP::HeaderError
-      end
-    end
-  end
-
-  describe "#[]" do
-    context "when header does not exists" do
-      it "returns nil" do
-        expect(headers[:accept]).to be_nil
-      end
-    end
-
-    context "when header has a single value" do
-      before { headers.set "Content-Type", "application/json" }
-
-      it "normalizes header name" do
-        expect(headers[:content_type]).to_not be_nil
-      end
-
-      it "returns it returns a single value" do
-        expect(headers[:content_type]).to eq "application/json"
-      end
-    end
-
-    context "when header has a multiple values" do
-      before do
-        headers.add :set_cookie, "hoo=ray"
-        headers.add :set_cookie, "woo=hoo"
-      end
-
-      it "normalizes header name" do
-        expect(headers[:set_cookie]).to_not be_nil
-      end
-
-      it "returns array of associated values" do
-        expect(headers[:set_cookie]).to eq %w[hoo=ray woo=hoo]
-      end
-    end
-  end
-
-  describe "#include?" do
-    before do
-      headers.add :content_type, "application/json"
-      headers.add :set_cookie,   "hoo=ray"
-      headers.add :set_cookie,   "woo=hoo"
-    end
-
-    it "tells whenever given headers is set or not" do
-      expect(headers.include?("Content-Type")).to be true
-      expect(headers.include?("Set-Cookie")).to be true
-      expect(headers.include?("Accept")).to be false
-    end
-
-    it "normalizes given header name" do
-      expect(headers.include?(:content_type)).to be true
-      expect(headers.include?(:set_cookie)).to be true
-      expect(headers.include?(:accept)).to be false
-    end
-  end
-
-  describe "#to_h" do
-    before do
-      headers.add :content_type, "application/json"
-      headers.add :set_cookie,   "hoo=ray"
-      headers.add :set_cookie,   "woo=hoo"
-    end
-
-    it "returns a Hash" do
-      expect(headers.to_h).to be_a ::Hash
-    end
-
-    it "returns Hash with normalized keys" do
-      expect(headers.to_h.keys).to match_array %w[Content-Type Set-Cookie]
-    end
-
-    context "for a header with single value" do
-      it "provides a value as is" do
-        expect(headers.to_h["Content-Type"]).to eq "application/json"
-      end
-    end
-
-    context "for a header with multiple values" do
-      it "provides an array of values" do
-        expect(headers.to_h["Set-Cookie"]).to eq %w[hoo=ray woo=hoo]
-      end
-    end
-  end
-
-  describe "#to_a" do
-    before do
-      headers.add :content_type, "application/json"
-      headers.add :set_cookie,   "hoo=ray"
-      headers.add :set_cookie,   "woo=hoo"
-    end
-
-    it "returns an Array" do
-      expect(headers.to_a).to be_a Array
-    end
-
-    it "returns Array of key/value pairs with normalized keys" do
-      expect(headers.to_a).to eq [
-        %w[Content-Type application/json],
-        %w[Set-Cookie hoo=ray],
-        %w[Set-Cookie woo=hoo]
-      ]
-    end
-  end
-
-  describe "#inspect" do
-    before  { headers.set :set_cookie, %w[hoo=ray woo=hoo] }
-    subject { headers.inspect }
-
-    it { is_expected.to eq '#<HTTP::Headers {"Set-Cookie"=>["hoo=ray", "woo=hoo"]}>' }
-  end
-
-  describe "#keys" do
-    before do
-      headers.add :content_type, "application/json"
-      headers.add :set_cookie,   "hoo=ray"
-      headers.add :set_cookie,   "woo=hoo"
-    end
-
-    it "returns uniq keys only" do
-      expect(headers.keys.size).to eq 2
-    end
-
-    it "normalizes keys" do
-      expect(headers.keys).to include("Content-Type", "Set-Cookie")
-    end
-  end
-
-  describe "#each" do
-    before do
-      headers.add :set_cookie,   "hoo=ray"
-      headers.add :content_type, "application/json"
-      headers.add :set_cookie,   "woo=hoo"
-    end
-
-    it "yields each key/value pair separatedly" do
-      expect { |b| headers.each(&b) }.to yield_control.exactly(3).times
-    end
-
-    it "yields headers in the same order they were added" do
-      expect { |b| headers.each(&b) }.to yield_successive_args(
-        %w[Set-Cookie hoo=ray],
-        %w[Content-Type application/json],
-        %w[Set-Cookie woo=hoo]
-      )
-    end
-
-    it "yields header keys specified as symbols in normalized form" do
-      keys = headers.each.map(&:first)
-      expect(keys).to eq(%w[Set-Cookie Content-Type Set-Cookie])
-    end
-
-    it "yields headers specified as strings without conversion" do
-      headers.add "X_kEy", "value"
-      keys = headers.each.map(&:first)
-      expect(keys).to eq(%w[Set-Cookie Content-Type Set-Cookie X_kEy])
-    end
-
-    it "returns self instance if block given" do
-      expect(headers.each { |*| }).to be headers # rubocop:disable Lint/EmptyBlock
-    end
-
-    it "returns Enumerator if no block given" do
-      expect(headers.each).to be_a Enumerator
-    end
-  end
-
-  describe ".empty?" do
-    subject { headers.empty? }
-
-    context "initially" do
-      it { is_expected.to be true }
-    end
-
-    context "when header exists" do
-      before { headers.add :accept, "text/plain" }
-      it { is_expected.to be false }
-    end
-
-    context "when last header was removed" do
-      before do
-        headers.add :accept, "text/plain"
-        headers.delete :accept
-      end
-
-      it { is_expected.to be true }
-    end
-  end
-
-  describe "#hash" do
-    let(:left)  { described_class.new }
-    let(:right) { described_class.new }
-
-    it "equals if two headers equals" do
-      left.add :accept, "text/plain"
-      right.add :accept, "text/plain"
-
-      expect(left.hash).to eq right.hash
-    end
-  end
-
-  describe "#==" do
-    let(:left)  { described_class.new }
-    let(:right) { described_class.new }
-
-    it "compares header keys and values" do
-      left.add :accept, "text/plain"
-      right.add :accept, "text/plain"
-
-      expect(left).to eq right
-    end
-
-    it "allows comparison with Array of key/value pairs" do
-      left.add :accept, "text/plain"
-      expect(left).to eq [%w[Accept text/plain]]
-    end
-
-    it "sensitive to headers order" do
-      left.add :accept, "text/plain"
-      left.add :cookie, "woo=hoo"
-      right.add :cookie, "woo=hoo"
-      right.add :accept, "text/plain"
-
-      expect(left).to_not eq right
-    end
-
-    it "sensitive to header values order" do
-      left.add :cookie, "hoo=ray"
-      left.add :cookie, "woo=hoo"
-      right.add :cookie, "woo=hoo"
-      right.add :cookie, "hoo=ray"
-
-      expect(left).to_not eq right
-    end
-  end
-
-  describe "#dup" do
-    before { headers.set :content_type, "application/json" }
-
-    subject(:dupped) { headers.dup }
-
-    it { is_expected.to be_a described_class }
-    it { is_expected.not_to be headers }
-
-    it "has headers copied" do
-      expect(dupped[:content_type]).to eq "application/json"
-    end
-
-    context "modifying a copy" do
-      before { dupped.set :content_type, "text/plain" }
-
-      it "modifies dupped copy" do
-        expect(dupped[:content_type]).to eq "text/plain"
-      end
-
-      it "does not affects original headers" do
-        expect(headers[:content_type]).to eq "application/json"
-      end
-    end
-  end
-
-  describe "#merge!" do
-    before do
-      headers.set :host, "example.com"
-      headers.set :accept, "application/json"
-      headers.merge! :accept => "plain/text", :cookie => %w[hoo=ray woo=hoo]
-    end
-
-    it "leaves headers not presented in other as is" do
-      expect(headers[:host]).to eq "example.com"
-    end
-
-    it "overwrites existing values" do
-      expect(headers[:accept]).to eq "plain/text"
-    end
-
-    it "appends other headers, not presented in base" do
-      expect(headers[:cookie]).to eq %w[hoo=ray woo=hoo]
-    end
-  end
-
-  describe "#merge" do
-    before do
-      headers.set :host, "example.com"
-      headers.set :accept, "application/json"
-    end
-
-    subject(:merged) do
-      headers.merge :accept => "plain/text", :cookie => %w[hoo=ray woo=hoo]
-    end
-
-    it { is_expected.to be_a described_class }
-    it { is_expected.not_to be headers }
-
-    it "does not affects original headers" do
-      expect(merged.to_h).to_not eq headers.to_h
-    end
-
-    it "leaves headers not presented in other as is" do
-      expect(merged[:host]).to eq "example.com"
-    end
-
-    it "overwrites existing values" do
-      expect(merged[:accept]).to eq "plain/text"
-    end
-
-    it "appends other headers, not presented in base" do
-      expect(merged[:cookie]).to eq %w[hoo=ray woo=hoo]
-    end
-  end
-
-  describe ".coerce" do
-    let(:dummyClass) { Class.new { def respond_to?(*); end } }
-
-    it "accepts any object that respond to #to_hash" do
-      hashie = double :to_hash => {"accept" => "json"}
-      expect(described_class.coerce(hashie)["accept"]).to eq "json"
-    end
-
-    it "accepts any object that respond to #to_h" do
-      hashie = double :to_h => {"accept" => "json"}
-      expect(described_class.coerce(hashie)["accept"]).to eq "json"
-    end
-
-    it "accepts any object that respond to #to_a" do
-      hashie = double :to_a => [%w[accept json]]
-      expect(described_class.coerce(hashie)["accept"]).to eq "json"
-    end
-
-    it "fails if given object cannot be coerced" do
-      expect { described_class.coerce dummyClass.new }.to raise_error HTTP::Error
-    end
-
-    context "with duplicate header keys (mixed case)" do
-      let(:headers) { {"Set-Cookie" => "hoo=ray", "set_cookie" => "woo=hoo", :set_cookie => "ta=da"} }
-
-      it "adds all headers" do
-        expect(described_class.coerce(headers).to_a).
-          to match_array(
-            [
-              %w[Set-Cookie hoo=ray],
-              %w[set_cookie woo=hoo],
-              %w[Set-Cookie ta=da]
-            ]
-          )
-      end
-    end
-
-    it "is aliased as .[]" do
-      expect(described_class.method(:coerce)).to eq described_class.method(:[])
-    end
-  end
-end

data/spec/lib/http/options/body_spec.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::Options, "body" do
-  let(:opts) { HTTP::Options.new }
-
-  it "defaults to nil" do
-    expect(opts.body).to be nil
-  end
-
-  it "may be specified with with_body" do
-    opts2 = opts.with_body("foo")
-    expect(opts.body).to be nil
-    expect(opts2.body).to eq("foo")
-  end
-end

data/spec/lib/http/options/features_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::Options, "features" do
-  let(:opts) { HTTP::Options.new }
-
-  it "defaults to be empty" do
-    expect(opts.features).to be_empty
-  end
-
-  it "accepts plain symbols in array" do
-    opts2 = opts.with_features([:auto_inflate])
-    expect(opts.features).to be_empty
-    expect(opts2.features.keys).to eq([:auto_inflate])
-    expect(opts2.features[:auto_inflate]).
-      to be_instance_of(HTTP::Features::AutoInflate)
-  end
-
-  it "accepts feature name with its options in array" do
-    opts2 = opts.with_features([{:auto_deflate => {:method => :deflate}}])
-    expect(opts.features).to be_empty
-    expect(opts2.features.keys).to eq([:auto_deflate])
-    expect(opts2.features[:auto_deflate]).
-      to be_instance_of(HTTP::Features::AutoDeflate)
-    expect(opts2.features[:auto_deflate].method).to eq("deflate")
-  end
-
-  it "raises error for not supported features" do
-    expect { opts.with_features([:wrong_feature]) }.
-      to raise_error(HTTP::Error) { |error|
-        expect(error.message).to eq("Unsupported feature: wrong_feature")
-      }
-  end
-end

data/spec/lib/http/options/form_spec.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::Options, "form" do
-  let(:opts) { HTTP::Options.new }
-
-  it "defaults to nil" do
-    expect(opts.form).to be nil
-  end
-
-  it "may be specified with with_form_data" do
-    opts2 = opts.with_form(:foo => 42)
-    expect(opts.form).to be nil
-    expect(opts2.form).to eq(:foo => 42)
-  end
-end

data/spec/lib/http/options/headers_spec.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::Options, "headers" do
-  let(:opts) { HTTP::Options.new }
-
-  it "defaults to be empty" do
-    expect(opts.headers).to be_empty
-  end
-
-  it "may be specified with with_headers" do
-    opts2 = opts.with_headers(:accept => "json")
-    expect(opts.headers).to be_empty
-    expect(opts2.headers).to eq([%w[Accept json]])
-  end
-
-  it "accepts any object that respond to :to_hash" do
-    x = if RUBY_VERSION >= "3.2.0"
-          Data.define(:to_hash).new(:to_hash => { "accept" => "json" })
-        else
-          Struct.new(:to_hash).new({ "accept" => "json" })
-        end
-    expect(opts.with_headers(x).headers["accept"]).to eq("json")
-  end
-end

data/spec/lib/http/options/json_spec.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::Options, "json" do
-  let(:opts) { HTTP::Options.new }
-
-  it "defaults to nil" do
-    expect(opts.json).to be nil
-  end
-
-  it "may be specified with with_json data" do
-    opts2 = opts.with_json(:foo => 42)
-    expect(opts.json).to be nil
-    expect(opts2.json).to eq(:foo => 42)
-  end
-end

data/spec/lib/http/options/merge_spec.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::Options, "merge" do
-  let(:opts) { HTTP::Options.new }
-
-  it "supports a Hash" do
-    old_response = opts.response
-    expect(opts.merge(:response => :body).response).to eq(:body)
-    expect(opts.response).to eq(old_response)
-  end
-
-  it "supports another Options" do
-    merged = opts.merge(HTTP::Options.new(:response => :body))
-    expect(merged.response).to eq(:body)
-  end
-
-  it "merges as excepted in complex cases" do
-    # FIXME: yuck :(
-
-    foo = HTTP::Options.new(
-      :response => :body,
-      :params   => {:baz => "bar"},
-      :form     => {:foo => "foo"},
-      :body     => "body-foo",
-      :json     => {:foo => "foo"},
-      :headers  => {:accept => "json", :foo => "foo"},
-      :proxy    => {},
-      :features => {}
-    )
-
-    bar = HTTP::Options.new(
-      :response           => :parsed_body,
-      :persistent         => "https://www.googe.com",
-      :params             => {:plop => "plip"},
-      :form               => {:bar => "bar"},
-      :body               => "body-bar",
-      :json               => {:bar => "bar"},
-      :keep_alive_timeout => 10,
-      :headers            => {:accept => "xml", :bar => "bar"},
-      :timeout_options    => {:foo => :bar},
-      :ssl                => {:foo => "bar"},
-      :proxy              => {:proxy_address => "127.0.0.1", :proxy_port => 8080}
-    )
-
-    expect(foo.merge(bar).to_hash).to eq(
-      :response           => :parsed_body,
-      :timeout_class      => described_class.default_timeout_class,
-      :timeout_options    => {:foo => :bar},
-      :params             => {:plop => "plip"},
-      :form               => {:bar => "bar"},
-      :body               => "body-bar",
-      :json               => {:bar => "bar"},
-      :persistent         => "https://www.googe.com",
-      :keep_alive_timeout => 10,
-      :ssl                => {:foo => "bar"},
-      :headers            => {"Foo" => "foo", "Accept" => "xml", "Bar" => "bar"},
-      :proxy              => {:proxy_address => "127.0.0.1", :proxy_port => 8080},
-      :follow             => nil,
-      :socket_class       => described_class.default_socket_class,
-      :nodelay            => false,
-      :ssl_socket_class   => described_class.default_ssl_socket_class,
-      :ssl_context        => nil,
-      :cookies            => {},
-      :encoding           => nil,
-      :features           => {}
-    )
-  end
-end