httpi 4.0.3 → 4.0.4

data/spec/httpi/request_spec.rb

@@ -1,290 +0,0 @@
-require "spec_helper"
-require "httpi/request"
-
-describe HTTPI::Request do
-  let(:request) { HTTPI::Request.new }
-
-  describe ".new" do
-    it "accepts a url" do
-      request = HTTPI::Request.new "http://example.com"
-      expect(request.url).to eq(URI("http://example.com"))
-    end
-
-    it "accepts a Hash of accessors to set" do
-      request = HTTPI::Request.new :url => "http://example.com", :open_timeout => 30, :query => { key: "value" }
-      expect(request.url).to eq(URI("http://example.com?key=value"))
-      expect(request.open_timeout).to eq(30)
-      expect(request.query).to eq("key=value")
-    end
-  end
-
-  describe "#url" do
-    it "lets you specify the URL to access as a String" do
-      request.url = "http://example.com"
-      expect(request.url).to eq(URI("http://example.com"))
-    end
-
-    it "also accepts a URI object" do
-      request.url = URI("http://example.com")
-      expect(request.url).to eq(URI("http://example.com"))
-    end
-
-    it "raises an ArgumentError in case of an invalid url" do
-      expect { request.url = "invalid" }.to raise_error(ArgumentError)
-    end
-
-    it "uses username and password as basic authentication if present in the URL" do
-      request.url = "http://username:password@example.com"
-      expect(request.auth.basic).to eq(['username', 'password'])
-    end
-
-    it "uses a blank password if only username is specified in the URL" do
-      request.url = "http://username@example.com"
-      expect(request.auth.basic).to eq(['username', ''])
-    end
-  end
-
-  describe "#query" do
-    it "raises an ArgumentError if url not respond to query" do
-      expect { request.query = "q=query" }.to raise_error(ArgumentError)
-    end
-
-    it "getter return nil for invalid url" do
-      expect(request.query).to be_nil
-    end
-
-    context "with query parameter as String" do
-      it "lets you specify query parameter as String" do
-        request.url = "http://example.com"
-        request.query = "q=query"
-        expect(request.url.to_s).to eq("http://example.com?q=query")
-      end
-
-      it "getter return String for query parameter as String" do
-        request.url = "http://example.com"
-        request.query = "q=query"
-        expect(request.query).to eq("q=query")
-      end
-    end
-
-    context "with query parameter as Hash" do
-      context "with flat query builder" do
-        before do
-          request.url = "http://example.com"
-          request.query = {:q => ["nested", "query"]}
-        end
-
-        it "lets you specify query parameter as Hash" do
-          expect(request.url.to_s).to eq("http://example.com?q=nested&q=query")
-        end
-
-        it "getter return String for query parameter as Hash" do
-          expect(request.query).to eq("q=nested&q=query")
-        end
-      end
-      context "with nested query builder" do
-        before do
-          HTTPI.query_builder = :nested
-
-          request.url = "http://example.com"
-          request.query = {:q => ["nested", "query"]}
-        end
-        after { HTTPI.query_builder = :flat }
-
-        it "lets you specify query parameter as Hash" do
-          expect(request.url.to_s).to eq("http://example.com?q%5B%5D=nested&q%5B%5D=query")
-        end
-
-        it "getter return String for query parameter as Hash" do
-          expect(request.query).to eq("q%5B%5D=nested&q%5B%5D=query")
-        end
-      end
-    end
-  end
-
-  describe "#proxy" do
-    it "lets you specify the proxy URL to use as a String" do
-      request.proxy = "http://proxy.example.com"
-      expect(request.proxy).to eq(URI("http://proxy.example.com"))
-    end
-
-    it 'also accepts the socks URL to use as a String' do
-      request.proxy ="socks://socks.example.com"
-      expect(request.proxy).to eq(URI("socks://socks.example.com"))
-    end
-
-    it "also accepts a URI object" do
-      request.proxy = URI("http://proxy.example.com")
-      expect(request.proxy).to eq(URI("http://proxy.example.com"))
-    end
-
-    it "raises an ArgumentError in case of an invalid url" do
-      expect { request.proxy = "invalid" }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "#ssl" do
-    it "returns false if no request url was specified" do
-      expect(request).not_to be_ssl
-    end
-
-    it "returns false if the request url does not start with https" do
-      request.url = "http://example.com"
-      expect(request).not_to be_ssl
-    end
-
-    it "returns true if the request url starts with https" do
-      request.url = "https://example.com"
-      expect(request).to be_ssl
-    end
-
-    context "with an explicit value" do
-      it "returns the value" do
-        request.ssl = true
-        expect(request).to be_ssl
-      end
-    end
-  end
-
-  describe "#headers" do
-    it "lets you specify a Hash of HTTP request headers" do
-      request.headers = { "Accept-Encoding" => "gzip" }
-      expect(request.headers).to eq HTTPI::Utils::Headers.new.merge({ "Accept-Encoding" => "gzip" })
-    end
-
-    it "defaults to return an empty Hash" do
-      expect(request.headers).to eq({})
-    end
-  end
-
-  describe "#gzip" do
-    it "adds the proper 'Accept-Encoding' header" do
-      request.gzip
-      expect(request.headers["Accept-Encoding"]).to eq("gzip,deflate")
-    end
-  end
-
-  describe "#set_cookies" do
-    it "sets the cookie header for the next request" do
-      request.set_cookies response_with_cookie("some-cookie=choc-chip")
-      expect(request.headers["Cookie"]).to eq("some-cookie=choc-chip")
-    end
-
-    it "sets additional cookies from subsequent requests" do
-      request.set_cookies response_with_cookie("some-cookie=choc-chip")
-      request.set_cookies response_with_cookie("second-cookie=oatmeal")
-
-      expect(request.headers["Cookie"]).to include("some-cookie=choc-chip", "second-cookie=oatmeal")
-    end
-
-    it "accepts an Array of cookies" do
-      cookies = [
-        new_cookie("some-cookie=choc-chip"),
-        new_cookie("second-cookie=oatmeal")
-      ]
-
-      request.set_cookies(cookies)
-
-      expect(request.headers["Cookie"]).to include("some-cookie=choc-chip", "second-cookie=oatmeal")
-    end
-
-    it "doesn't do anything if the response contains no cookies" do
-      request.set_cookies HTTPI::Response.new(200, {}, "")
-      expect(request.headers).not_to include("Cookie")
-    end
-
-    def new_cookie(cookie_string)
-      HTTPI::Cookie.new(cookie_string)
-    end
-
-    def response_with_cookie(cookie)
-      HTTPI::Response.new(200, { "Set-Cookie" => "#{cookie}; Path=/; HttpOnly" }, "")
-    end
-  end
-
-  describe "#body" do
-    context "with query parameter as String" do
-      it "lets you specify the HTTP request body using a String" do
-        request.body = "<some>xml</some>"
-        expect(request.body).to eq("<some>xml</some>")
-      end
-    end
-    context "with flat query builder" do
-      it "lets you specify the HTTP request body using a Hash" do
-        request.body = {:foo => :bar, :baz => :foo}
-        expect(request.body.split("&")).to match_array(["foo=bar", "baz=foo"])
-      end
-    end
-    context "with query parameter as Hash" do
-      context "with flat query builder" do
-        it "request body using a Hash" do
-          request.body = {:foo => :bar, :baz => :foo}
-          expect(request.body.split("&")).to match_array(["foo=bar", "baz=foo"])
-        end
-        it "request body using a Hash with Array" do
-          request.body = {:foo => :bar, :baz => [:foo, :tst]}
-          expect(request.body.split("&")).to match_array(["foo=bar", "baz=foo", "baz=tst"])
-        end
-      end
-      context "with nested query builder" do
-        before { HTTPI.query_builder = :nested }
-        after  { HTTPI.query_builder = :flat }
-        it "request body using a Hash" do
-          request.body = {:foo => :bar, :baz => :foo}
-          expect(request.body.split("&")).to match_array(["foo=bar", "baz=foo"])
-        end
-        it "request body using a Hash with Array" do
-          request.body = {:foo => :bar, :baz => [:foo, :tst]}
-          expect(request.body.split("&")).to match_array(["foo=bar", "baz%5B%5D=foo", "baz%5B%5D=tst"])
-        end
-      end
-    end
-  end
-
-  describe "#open_timeout" do
-    it "lets you specify the open timeout" do
-      request.open_timeout = 30
-      expect(request.open_timeout).to eq(30)
-    end
-  end
-
-  describe "#read_timeout" do
-    it "lets you specify the read timeout" do
-      request.read_timeout = 45
-      expect(request.read_timeout).to eq(45)
-    end
-  end
-
-  describe "#auth" do
-    it "returns the authentication object" do
-      expect(request.auth).to be_an(HTTPI::Auth::Config)
-    end
-
-    it "memoizes the authentication object" do
-      expect(request.auth).to equal(request.auth)
-    end
-  end
-
-  describe "#auth?" do
-    it "returns true when auth credentials are specified" do
-      request.auth.basic "username", "password"
-      expect(request.auth?).to be_truthy
-    end
-
-    it "returns false otherwise" do
-      expect(request.auth?).to be_falsey
-    end
-  end
-
-  describe '#follow_redirect?' do
-    it 'returns true when follow_redirect is set to true' do
-      request.follow_redirect = true
-      expect(request.follow_redirect?).to be_truthy
-    end
-
-    it 'returns false by default' do
-      expect(request.follow_redirect?).to be_falsey
-    end
-  end
-
-end

data/spec/httpi/response_spec.rb

@@ -1,146 +0,0 @@
-require "spec_helper"
-require "httpi/response"
-
-describe HTTPI::Response do
-
-  context "normal" do
-    let(:response) { HTTPI::Response.new 200, {}, Fixture.xml }
-
-    describe "#error?" do
-      it "returns false" do
-        expect(response).not_to be_an_error
-      end
-    end
-
-    describe "#headers" do
-      it "returns the HTTP response headers" do
-        expect(response.headers).to eq({})
-      end
-    end
-
-    describe "#code" do
-      it "returns the HTTP response code" do
-        expect(response.code).to eq(200)
-      end
-
-      it "always returns an Integer" do
-        response = HTTPI::Response.new "200", {}, ""
-        expect(response.code).to eq(200)
-      end
-    end
-
-    describe "#multipart" do
-      it "returns false" do
-        expect(response).not_to be_multipart
-      end
-    end
-
-    describe "#cookies" do
-      it "returns an empty list" do
-        expect(response.cookies).to eq([])
-      end
-    end
-  end
-
-  context "with cookies" do
-    let(:response) { HTTPI::Response.new 200, { "Set-Cookie" => "some-cookie=choc-chip; Path=/; HttpOnly" }, "" }
-
-    describe "#cookies" do
-      it "returns a list of cookies" do
-        cookie = response.cookies.first
-        expect(cookie).to be_a(HTTPI::Cookie)
-      end
-    end
-  end
-
-  context "empty" do
-    let(:response) { HTTPI::Response.new 204, {}, nil }
-
-    describe "#body" do
-      it "returns an empty String" do
-        expect(response.body).to eq("")
-      end
-    end
-  end
-
-  context "multipart" do
-    let(:response) { HTTPI::Response.new 200, { "Content-Type" => "multipart/related" }, "multipart" }
-
-    describe "#multipart" do
-      it "returns true" do
-        expect(response).to be_multipart
-      end
-    end
-  end
-
-  context "error" do
-    let(:response) { HTTPI::Response.new 404, {}, "" }
-
-    describe "#error?" do
-      it "returns true" do
-        expect(response).to be_an_error
-      end
-    end
-  end
-
-  context "gzipped" do
-    let(:response) { HTTPI::Response.new 200, { "Content-Encoding" => "gzip" }, Fixture.gzip }
-
-    describe "#headers" do
-      it "returns the HTTP response headers" do
-        expect(response.headers).to eq HTTPI::Utils::Headers.new.merge({ "Content-Encoding" => "gzip" })
-      end
-    end
-
-    describe "#body" do
-      it "returns the (gzip decoded) HTTP response body" do
-        expect(response.body).to eq(Fixture.xml)
-      end
-
-      it "bubbles Zlib errors" do
-        arbitrary_error = Class.new(ArgumentError)
-        Zlib::GzipReader.expects(:new).raises(arbitrary_error)
-        expect { response.body }.to raise_error(arbitrary_error)
-      end
-    end
-
-    describe "#raw_body" do
-      it "returns the raw HTML response body" do
-        expect(response.raw_body).to eq(Fixture.gzip)
-      end
-    end
-  end
-
-  context "DIME" do
-    let(:response) { HTTPI::Response.new 200, { "Content-Type" => "application/dime" }, Fixture.dime }
-
-    describe "#headers" do
-      it "returns the HTTP response headers" do
-        expect(response.headers).to eq HTTPI::Utils::Headers.new.merge({ "Content-Type" => "application/dime" })
-      end
-
-      it "preserves casing" do
-        expect(response.headers.keys).to eq ["Content-Type"]
-      end
-    end
-
-    describe "#body" do
-      it "returns the (dime decoded) HTTP response body" do
-        expect(response.body).to eq(Fixture.xml_dime)
-      end
-    end
-
-    describe "#raw_body" do
-      it "returns the raw HTML response body" do
-        expect(response.raw_body).to eq(Fixture.dime)
-      end
-    end
-
-    describe "#attachments" do
-      it "returns proper attachment when given a dime response" do
-        response.attachments.first.data == File.read(File.expand_path("../../fixtures/attachment.gif", __FILE__))
-      end
-    end
-  end
-
-end

data/spec/integration/curb_spec.rb

@@ -1,140 +0,0 @@
-require "spec_helper"
-require "integration/support/server"
-
-describe HTTPI::Adapter::Curb do
-
-  # curb is not supported on jruby
-  unless RUBY_PLATFORM =~ /java/
-
-    subject(:adapter) { :curb }
-
-    context "http requests" do
-      before :all do
-        @server = IntegrationServer.run
-      end
-
-      after :all do
-        @server.stop
-      end
-
-      it "sends and receives HTTP headers" do
-        request = HTTPI::Request.new(@server.url + "x-header")
-        request.headers["X-Header"] = "HTTPI"
-
-        response = HTTPI.get(request, adapter)
-        expect(response.body).to include("HTTPI")
-      end
-
-      it "it supports headers with multiple values" do
-        request = HTTPI::Request.new(@server.url + "cookies")
-
-        response = HTTPI.get(request, adapter)
-        cookies = ["cookie1=chip1; path=/", "cookie2=chip2; path=/"]
-        expect(response.headers["Set-Cookie"]).to eq(cookies)
-      end
-
-      it "it supports read timeout" do
-        require "curb"
-
-        request = HTTPI::Request.new(@server.url + "timeout")
-        request.read_timeout = 0.5 # seconds
-
-        expect do
-          HTTPI.get(request, adapter)
-        end.to raise_exception(Curl::Err::TimeoutError)
-      end
-
-      it "executes GET requests" do
-        response = HTTPI.get(@server.url, adapter)
-        expect(response.body).to eq("get")
-        expect(response.headers["Content-Type"]).to eq("text/plain")
-      end
-
-      it "executes POST requests" do
-        response = HTTPI.post(@server.url, "<some>xml</some>", adapter)
-        expect(response.body).to eq("post")
-        expect(response.headers["Content-Type"]).to eq("text/plain")
-      end
-
-      it "executes HEAD requests" do
-        response = HTTPI.head(@server.url, adapter)
-        expect(response.code).to eq(200)
-        expect(response.headers["Content-Type"]).to eq("text/plain")
-      end
-
-      it "executes PUT requests" do
-        response = HTTPI.put(@server.url, "<some>xml</some>", adapter)
-        expect(response.body).to eq("put")
-        expect(response.headers["Content-Type"]).to eq("text/plain")
-      end
-
-      it "executes DELETE requests" do
-        response = HTTPI.delete(@server.url, adapter)
-        expect(response.body).to eq("delete")
-        expect(response.headers["Content-Type"]).to eq("text/plain")
-      end
-
-      it "supports basic authentication" do
-        request = HTTPI::Request.new(@server.url + "basic-auth")
-        request.auth.basic("admin", "secret")
-
-        response = HTTPI.get(request, adapter)
-        expect(response.body).to eq("basic-auth")
-      end
-
-      # Rack::Auth::Digest is removed in Rack 3.1
-      xit "supports digest authentication" do
-        request = HTTPI::Request.new(@server.url + "digest-auth")
-        request.auth.digest("admin", "secret")
-
-        response = HTTPI.get(request, adapter)
-        expect(response.body).to eq("digest-auth")
-      end
-
-      it "supports chunked response" do
-        request = HTTPI::Request.new(@server.url)
-        res = ""
-        request.on_body do |body|
-          res += body
-        end
-        response = HTTPI.post(request, adapter)
-        expect(res).to eq("post")
-        expect(response.body).to eq("")
-      end
-
-    end
-
-    context "https requests" do
-      before :all do
-        @server = IntegrationServer.run(:ssl => true)
-      end
-
-      after :all do
-        @server.stop
-      end
-
-      it "raises when no certificate was set up" do
-        expect { HTTPI.post(@server.url, "", adapter) }.to raise_error(HTTPI::SSLError)
-      end
-
-      it "works when set up properly" do
-        request = HTTPI::Request.new(@server.url)
-        request.auth.ssl.ca_cert_file = IntegrationServer.ssl_ca_file
-
-        response = HTTPI.get(request, adapter)
-        expect(response.body).to eq("get")
-      end
-
-      it "works with ciphers" do
-        request = HTTPI::Request.new(@server.url)
-        request.auth.ssl.ca_cert_file = IntegrationServer.ssl_ca_file
-        request.auth.ssl.ciphers = OpenSSL::SSL::SSLContext.new.ciphers
-
-        response = HTTPI.get(request, adapter)
-        expect(response.body).to eq("get")
-      end
-    end
-
-  end
-end
-

data/spec/integration/em_http_spec.rb

@@ -1,108 +0,0 @@
-require "spec_helper"
-require "integration/support/server"
-
-describe HTTPI::Adapter::EmHttpRequest do
-
-  # em_http is not supported on java
-  unless RUBY_PLATFORM =~ /java/
-    require "em-synchrony"
-
-    subject(:adapter) { :em_http }
-
-    around :each do |example|
-      EM.synchrony do
-        example.run
-        EM.stop
-      end
-    end
-
-    context "http requests" do
-      before :all do
-        # for some reason, these specs don't work with "localhost". [dh, 2012-12-15]
-        @server = IntegrationServer.run(:host => "127.0.0.1")
-      end
-
-      after :all do
-        @server.stop
-      end
-
-      it "sends and receives HTTP headers" do
-        request = HTTPI::Request.new(@server.url + "x-header")
-        request.headers["X-Header"] = "HTTPI"
-
-        response = HTTPI.get(request, adapter)
-        expect(response.body).to include("HTTPI")
-      end
-
-      it "it supports headers with multiple values" do
-        request = HTTPI::Request.new(@server.url + "cookies")
-
-        response = HTTPI.get(request, adapter)
-        cookies = ["cookie1=chip1; path=/", "cookie2=chip2; path=/"]
-        expect(response.headers["Set-Cookie"]).to eq(cookies)
-      end
-
-      if RUBY_PLATFORM =~ /java/
-        pending <<-MSG
-          It seems like JRuby is missing support for inactivity timeout! See related issues on GitHub:
-            - https://github.com/eventmachine/eventmachine/issues/155
-            - https://github.com/eventmachine/eventmachine/pull/312
-        MSG
-      else
-        it "it supports read timeout" do
-          request = HTTPI::Request.new(@server.url + "timeout")
-          request.read_timeout = 0.5 # seconds
-
-          expect do
-            HTTPI.get(request, adapter)
-          end.to raise_exception(HTTPI::TimeoutError)
-        end
-      end
-
-      it "executes GET requests" do
-        response = HTTPI.get(@server.url, adapter)
-        expect(response.body).to eq("get")
-        expect(response.headers["Content-Type"]).to eq("text/plain")
-      end
-
-      it "executes POST requests" do
-        response = HTTPI.post(@server.url, "<some>xml</some>", adapter)
-        expect(response.body).to eq("post")
-        expect(response.headers["Content-Type"]).to eq("text/plain")
-      end
-
-      it "executes HEAD requests" do
-        response = HTTPI.head(@server.url, adapter)
-        expect(response.code).to eq(200)
-        expect(response.headers["Content-Type"]).to eq("text/plain")
-      end
-
-      it "executes PUT requests" do
-        response = HTTPI.put(@server.url, "<some>xml</some>", adapter)
-        expect(response.body).to eq("put")
-        expect(response.headers["Content-Type"]).to eq("text/plain")
-      end
-
-      it "executes DELETE requests" do
-        response = HTTPI.delete(@server.url, adapter)
-        expect(response.body).to eq("delete")
-        expect(response.headers["Content-Type"]).to eq("text/plain")
-      end
-
-      it "supports basic authentication" do
-        request = HTTPI::Request.new(@server.url + "basic-auth")
-        request.auth.basic("admin", "secret")
-
-        response = HTTPI.get(request, adapter)
-        expect(response.body).to eq("basic-auth")
-      end
-
-      # it does not support digest authentication
-
-      # it does not support chunked response
-    end
-
-    # it does not support ssl authentication
-
-  end
-end