direct7 0.0.10 → 0.0.11

data/vendor/bundle/ruby/2.7.0/gems/http-5.1.1/spec/lib/http/request/body_spec.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+RSpec.describe HTTP::Request::Body do
+  let(:body) { "" }
+  subject    { HTTP::Request::Body.new(body) }
+
+  describe "#initialize" do
+    context "when body is nil" do
+      let(:body) { nil }
+
+      it "does not raise an error" do
+        expect { subject }.not_to raise_error
+      end
+    end
+
+    context "when body is a string" do
+      let(:body) { "string body" }
+
+      it "does not raise an error" do
+        expect { subject }.not_to raise_error
+      end
+    end
+
+    context "when body is an IO" do
+      let(:body) { FakeIO.new("IO body") }
+
+      it "does not raise an error" do
+        expect { subject }.not_to raise_error
+      end
+    end
+
+    context "when body is an Enumerable" do
+      let(:body) { %w[bees cows] }
+
+      it "does not raise an error" do
+        expect { subject }.not_to raise_error
+      end
+    end
+
+    context "when body is of unrecognized type" do
+      let(:body) { 123 }
+
+      it "raises an error" do
+        expect { subject }.to raise_error(HTTP::RequestError)
+      end
+    end
+  end
+
+  describe "#source" do
+    it "returns the original object" do
+      expect(subject.source).to eq ""
+    end
+  end
+
+  describe "#size" do
+    context "when body is nil" do
+      let(:body) { nil }
+
+      it "returns zero" do
+        expect(subject.size).to eq 0
+      end
+    end
+
+    context "when body is a string" do
+      let(:body) { "Привет, мир!" }
+
+      it "returns string bytesize" do
+        expect(subject.size).to eq 21
+      end
+    end
+
+    context "when body is an IO with size" do
+      let(:body) { FakeIO.new("content") }
+
+      it "returns IO size" do
+        expect(subject.size).to eq 7
+      end
+    end
+
+    context "when body is an IO without size" do
+      let(:body) { IO.pipe[0] }
+
+      it "raises a RequestError" do
+        expect { subject.size }.to raise_error(HTTP::RequestError)
+      end
+    end
+
+    context "when body is an Enumerable" do
+      let(:body) { %w[bees cows] }
+
+      it "raises a RequestError" do
+        expect { subject.size }.to raise_error(HTTP::RequestError)
+      end
+    end
+  end
+
+  describe "#each" do
+    let(:chunks) do
+      chunks = []
+      subject.each { |chunk| chunks << chunk.dup }
+      chunks
+    end
+
+    context "when body is nil" do
+      let(:body) { nil }
+
+      it "yields nothing" do
+        expect(chunks).to eq []
+      end
+    end
+
+    context "when body is a string" do
+      let(:body) { "content" }
+
+      it "yields the string" do
+        expect(chunks).to eq %w[content]
+      end
+    end
+
+    context "when body is a non-Enumerable IO" do
+      let(:body) { FakeIO.new(("a" * 16 * 1024) + ("b" * 10 * 1024)) }
+
+      it "yields chunks of content" do
+        expect(chunks.inject("", :+)).to eq ("a" * 16 * 1024) + ("b" * 10 * 1024)
+      end
+    end
+
+    context "when body is a pipe" do
+      let(:ios)  { IO.pipe }
+      let(:body) { ios[0] }
+
+      around do |example|
+        writer = Thread.new(ios[1]) do |io|
+          io << "abcdef"
+          io.close
+        end
+
+        begin
+          example.run
+        ensure
+          writer.join
+        end
+      end
+
+      it "yields chunks of content" do
+        expect(chunks.inject("", :+)).to eq("abcdef")
+      end
+    end
+
+    context "when body is an Enumerable IO" do
+      let(:data) { ("a" * 16 * 1024) + ("b" * 10 * 1024) }
+      let(:body) { StringIO.new data }
+
+      it "yields chunks of content" do
+        expect(chunks.inject("", :+)).to eq data
+      end
+
+      it "allows to enumerate multiple times" do
+        results = []
+
+        2.times do
+          result = ""
+          subject.each { |chunk| result += chunk }
+          results << result
+        end
+
+        aggregate_failures do
+          expect(results.count).to eq 2
+          expect(results).to all eq data
+        end
+      end
+    end
+
+    context "when body is an Enumerable" do
+      let(:body) { %w[bees cows] }
+
+      it "yields elements" do
+        expect(chunks).to eq %w[bees cows]
+      end
+    end
+  end
+
+  describe "#==" do
+    context "when sources are equivalent" do
+      let(:body1) { HTTP::Request::Body.new("content") }
+      let(:body2) { HTTP::Request::Body.new("content") }
+
+      it "returns true" do
+        expect(body1).to eq body2
+      end
+    end
+
+    context "when sources are not equivalent" do
+      let(:body1) { HTTP::Request::Body.new("content") }
+      let(:body2) { HTTP::Request::Body.new(nil) }
+
+      it "returns false" do
+        expect(body1).not_to eq body2
+      end
+    end
+
+    context "when objects are not of the same class" do
+      let(:body1) { HTTP::Request::Body.new("content") }
+      let(:body2) { "content" }
+
+      it "returns false" do
+        expect(body1).not_to eq body2
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/http-5.1.1/spec/lib/http/request/writer_spec.rb

@@ -0,0 +1,121 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+RSpec.describe HTTP::Request::Writer do
+  let(:io)          { StringIO.new }
+  let(:body)        { HTTP::Request::Body.new("") }
+  let(:headers)     { HTTP::Headers.new }
+  let(:headerstart) { "GET /test HTTP/1.1" }
+
+  subject(:writer)  { described_class.new(io, body, headers, headerstart) }
+
+  describe "#stream" do
+    context "when multiple headers are set" do
+      let(:headers) { HTTP::Headers.coerce "Host" => "example.org" }
+
+      it "separates headers with carriage return and line feed" do
+        writer.stream
+        expect(io.string).to eq [
+          "#{headerstart}\r\n",
+          "Host: example.org\r\nContent-Length: 0\r\n\r\n"
+        ].join
+      end
+    end
+
+    context "when headers are specified as strings with mixed case" do
+      let(:headers) { HTTP::Headers.coerce "content-Type" => "text", "X_MAX" => "200" }
+
+      it "writes the headers with the same casing" do
+        writer.stream
+        expect(io.string).to eq [
+          "#{headerstart}\r\n",
+          "content-Type: text\r\nX_MAX: 200\r\nContent-Length: 0\r\n\r\n"
+        ].join
+      end
+    end
+
+    context "when body is nonempty" do
+      let(:body) { HTTP::Request::Body.new("content") }
+
+      it "writes it to the socket and sets Content-Length" do
+        writer.stream
+        expect(io.string).to eq [
+          "#{headerstart}\r\n",
+          "Content-Length: 7\r\n\r\n",
+          "content"
+        ].join
+      end
+    end
+
+    context "when body is not set" do
+      let(:body) { HTTP::Request::Body.new(nil) }
+
+      it "doesn't write anything to the socket and doesn't set Content-Length" do
+        writer.stream
+        expect(io.string).to eq [
+          "#{headerstart}\r\n\r\n"
+        ].join
+      end
+    end
+
+    context "when body is empty" do
+      let(:body) { HTTP::Request::Body.new("") }
+
+      it "doesn't write anything to the socket and sets Content-Length" do
+        writer.stream
+        expect(io.string).to eq [
+          "#{headerstart}\r\n",
+          "Content-Length: 0\r\n\r\n"
+        ].join
+      end
+    end
+
+    context "when Content-Length header is set" do
+      let(:headers) { HTTP::Headers.coerce "Content-Length" => "12" }
+      let(:body)    { HTTP::Request::Body.new("content") }
+
+      it "keeps the given value" do
+        writer.stream
+        expect(io.string).to eq [
+          "#{headerstart}\r\n",
+          "Content-Length: 12\r\n\r\n",
+          "content"
+        ].join
+      end
+    end
+
+    context "when Transfer-Encoding is chunked" do
+      let(:headers) { HTTP::Headers.coerce "Transfer-Encoding" => "chunked" }
+      let(:body)    { HTTP::Request::Body.new(%w[request body]) }
+
+      it "writes encoded content and omits Content-Length" do
+        writer.stream
+        expect(io.string).to eq [
+          "#{headerstart}\r\n",
+          "Transfer-Encoding: chunked\r\n\r\n",
+          "7\r\nrequest\r\n4\r\nbody\r\n0\r\n\r\n"
+        ].join
+      end
+    end
+
+    context "when server won't accept any more data" do
+      before do
+        expect(io).to receive(:write).and_raise(Errno::EPIPE)
+      end
+
+      it "aborts silently" do
+        writer.stream
+      end
+    end
+
+    context "when writing to socket raises an exception" do
+      before do
+        expect(io).to receive(:write).and_raise(Errno::ECONNRESET)
+      end
+
+      it "raises a ConnectionError" do
+        expect { writer.stream }.to raise_error(HTTP::ConnectionError)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/http-5.1.1/spec/lib/http/request_spec.rb

@@ -0,0 +1,234 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+RSpec.describe HTTP::Request do
+  let(:proxy)       { {} }
+  let(:headers)     { {:accept => "text/html"} }
+  let(:request_uri) { "http://example.com/foo?bar=baz" }
+
+  subject :request do
+    HTTP::Request.new(
+      :verb    => :get,
+      :uri     => request_uri,
+      :headers => headers,
+      :proxy   => proxy
+    )
+  end
+
+  it "includes HTTP::Headers::Mixin" do
+    expect(described_class).to include HTTP::Headers::Mixin
+  end
+
+  it "requires URI to have scheme part" do
+    expect { HTTP::Request.new(:verb => :get, :uri => "example.com/") }.to \
+      raise_error(HTTP::Request::UnsupportedSchemeError)
+  end
+
+  it "provides a #scheme accessor" do
+    expect(request.scheme).to eq(:http)
+  end
+
+  it "provides a #verb accessor" do
+    expect(subject.verb).to eq(:get)
+  end
+
+  it "sets given headers" do
+    expect(subject["Accept"]).to eq("text/html")
+  end
+
+  describe "Host header" do
+    subject { request["Host"] }
+
+    context "was not given" do
+      it { is_expected.to eq "example.com" }
+
+      context "and request URI has non-standard port" do
+        let(:request_uri) { "http://example.com:3000/" }
+        it { is_expected.to eq "example.com:3000" }
+      end
+    end
+
+    context "was explicitly given" do
+      before { headers[:host] = "github.com" }
+      it { is_expected.to eq "github.com" }
+    end
+  end
+
+  describe "User-Agent header" do
+    subject { request["User-Agent"] }
+
+    context "was not given" do
+      it { is_expected.to eq HTTP::Request::USER_AGENT }
+    end
+
+    context "was explicitly given" do
+      before { headers[:user_agent] = "MrCrawly/123" }
+      it { is_expected.to eq "MrCrawly/123" }
+    end
+  end
+
+  describe "#redirect" do
+    let(:headers)   { {:accept => "text/html"} }
+    let(:proxy)     { {:proxy_username => "douglas", :proxy_password => "adams"} }
+    let(:body)      { "The Ultimate Question" }
+
+    let :request do
+      HTTP::Request.new(
+        :verb    => :post,
+        :uri     => "http://example.com/",
+        :headers => headers,
+        :proxy   => proxy,
+        :body    => body
+      )
+    end
+
+    subject(:redirected) { request.redirect "http://blog.example.com/" }
+
+    its(:uri)     { is_expected.to eq HTTP::URI.parse "http://blog.example.com/" }
+
+    its(:verb)    { is_expected.to eq request.verb }
+    its(:body)    { is_expected.to eq request.body }
+    its(:proxy)   { is_expected.to eq request.proxy }
+
+    it "presets new Host header" do
+      expect(redirected["Host"]).to eq "blog.example.com"
+    end
+
+    context "with URL with non-standard port given" do
+      subject(:redirected) { request.redirect "http://example.com:8080" }
+
+      its(:uri)     { is_expected.to eq HTTP::URI.parse "http://example.com:8080" }
+
+      its(:verb)    { is_expected.to eq request.verb }
+      its(:body)    { is_expected.to eq request.body }
+      its(:proxy)   { is_expected.to eq request.proxy }
+
+      it "presets new Host header" do
+        expect(redirected["Host"]).to eq "example.com:8080"
+      end
+    end
+
+    context "with schema-less absolute URL given" do
+      subject(:redirected) { request.redirect "//another.example.com/blog" }
+
+      its(:uri)     { is_expected.to eq HTTP::URI.parse "http://another.example.com/blog" }
+
+      its(:verb)    { is_expected.to eq request.verb }
+      its(:body)    { is_expected.to eq request.body }
+      its(:proxy)   { is_expected.to eq request.proxy }
+
+      it "presets new Host header" do
+        expect(redirected["Host"]).to eq "another.example.com"
+      end
+    end
+
+    context "with relative URL given" do
+      subject(:redirected) { request.redirect "/blog" }
+
+      its(:uri)     { is_expected.to eq HTTP::URI.parse "http://example.com/blog" }
+
+      its(:verb)    { is_expected.to eq request.verb }
+      its(:body)    { is_expected.to eq request.body }
+      its(:proxy)   { is_expected.to eq request.proxy }
+
+      it "keeps Host header" do
+        expect(redirected["Host"]).to eq "example.com"
+      end
+
+      context "with original URI having non-standard port" do
+        let :request do
+          HTTP::Request.new(
+            :verb    => :post,
+            :uri     => "http://example.com:8080/",
+            :headers => headers,
+            :proxy   => proxy,
+            :body    => body
+          )
+        end
+
+        its(:uri) { is_expected.to eq HTTP::URI.parse "http://example.com:8080/blog" }
+      end
+    end
+
+    context "with relative URL that misses leading slash given" do
+      subject(:redirected) { request.redirect "blog" }
+
+      its(:uri)     { is_expected.to eq HTTP::URI.parse "http://example.com/blog" }
+
+      its(:verb)    { is_expected.to eq request.verb }
+      its(:body)    { is_expected.to eq request.body }
+      its(:proxy)   { is_expected.to eq request.proxy }
+
+      it "keeps Host header" do
+        expect(redirected["Host"]).to eq "example.com"
+      end
+
+      context "with original URI having non-standard port" do
+        let :request do
+          HTTP::Request.new(
+            :verb    => :post,
+            :uri     => "http://example.com:8080/",
+            :headers => headers,
+            :proxy   => proxy,
+            :body    => body
+          )
+        end
+
+        its(:uri) { is_expected.to eq HTTP::URI.parse "http://example.com:8080/blog" }
+      end
+    end
+
+    context "with new verb given" do
+      subject { request.redirect "http://blog.example.com/", :get }
+      its(:verb) { is_expected.to be :get }
+    end
+  end
+
+  describe "#headline" do
+    subject(:headline) { request.headline }
+
+    it { is_expected.to eq "GET /foo?bar=baz HTTP/1.1" }
+
+    context "when URI contains encoded query" do
+      let(:encoded_query) { "t=1970-01-01T01%3A00%3A00%2B01%3A00" }
+      let(:request_uri) { "http://example.com/foo/?#{encoded_query}" }
+
+      it "does not unencodes query part" do
+        expect(headline).to eq "GET /foo/?#{encoded_query} HTTP/1.1"
+      end
+    end
+
+    context "when URI contains non-ASCII path" do
+      let(:request_uri) { "http://example.com/キョ" }
+
+      it "encodes non-ASCII path part" do
+        expect(headline).to eq "GET /%E3%82%AD%E3%83%A7 HTTP/1.1"
+      end
+    end
+
+    context "when URI contains fragment" do
+      let(:request_uri) { "http://example.com/foo#bar" }
+
+      it "omits fragment part" do
+        expect(headline).to eq "GET /foo HTTP/1.1"
+      end
+    end
+
+    context "with proxy" do
+      let(:proxy) { {:user => "user", :pass => "pass"} }
+      it { is_expected.to eq "GET http://example.com/foo?bar=baz HTTP/1.1" }
+
+      context "and HTTPS uri" do
+        let(:request_uri) { "https://example.com/foo?bar=baz" }
+
+        it { is_expected.to eq "GET /foo?bar=baz HTTP/1.1" }
+      end
+    end
+  end
+
+  describe "#inspect" do
+    subject { request.inspect }
+
+    it { is_expected.to eq "#<HTTP::Request/1.1 GET #{request_uri}>" }
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/http-5.1.1/spec/lib/http/response/body_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+RSpec.describe HTTP::Response::Body do
+  let(:connection) { double(:sequence_id => 0) }
+  let(:chunks)     { ["Hello, ", "World!"] }
+
+  before do
+    allow(connection).to receive(:readpartial) { chunks.shift }
+    allow(connection).to receive(:body_completed?) { chunks.empty? }
+  end
+
+  subject(:body) { described_class.new(connection, :encoding => Encoding::UTF_8) }
+
+  it "streams bodies from responses" do
+    expect(subject.to_s).to eq("Hello, World!")
+  end
+
+  context "when body empty" do
+    let(:chunks) { [""] }
+
+    it "returns responds to empty? with true" do
+      expect(subject).to be_empty
+    end
+  end
+
+  describe "#readpartial" do
+    context "with size given" do
+      it "passes value to underlying connection" do
+        expect(connection).to receive(:readpartial).with(42)
+        body.readpartial 42
+      end
+    end
+
+    context "without size given" do
+      it "does not blows up" do
+        expect { body.readpartial }.to_not raise_error
+      end
+
+      it "calls underlying connection readpartial without specific size" do
+        expect(connection).to receive(:readpartial).with no_args
+        body.readpartial
+      end
+    end
+
+    it "returns content in specified encoding" do
+      body = described_class.new(connection)
+      expect(connection).to receive(:readpartial).
+        and_return(String.new("content", :encoding => Encoding::UTF_8))
+      expect(body.readpartial.encoding).to eq Encoding::BINARY
+
+      body = described_class.new(connection, :encoding => Encoding::UTF_8)
+      expect(connection).to receive(:readpartial).
+        and_return(String.new("content", :encoding => Encoding::BINARY))
+      expect(body.readpartial.encoding).to eq Encoding::UTF_8
+    end
+  end
+
+  context "when body is gzipped" do
+    let(:chunks) do
+      body = Zlib::Deflate.deflate("Hi, HTTP here ☺")
+      len  = body.length
+      [body[0, len / 2], body[(len / 2)..]]
+    end
+    subject(:body) do
+      inflater = HTTP::Response::Inflater.new(connection)
+      described_class.new(inflater, :encoding => Encoding::UTF_8)
+    end
+
+    it "decodes body" do
+      expect(subject.to_s).to eq("Hi, HTTP here ☺")
+    end
+
+    describe "#readpartial" do
+      it "streams decoded body" do
+        [
+          "Hi, HTTP ",
+          "here ☺",
+          nil
+        ].each do |part|
+          expect(subject.readpartial).to eq(part)
+        end
+      end
+    end
+  end
+end