httpi 2.1.1 → 2.2.0

data/spec/httpi/auth/ssl_spec.rb

@@ -5,51 +5,51 @@ describe HTTPI::Auth::SSL do
 
   describe "VERIFY_MODES" do
     it "contains the supported SSL verify modes" do
-      HTTPI::Auth::SSL::VERIFY_MODES.should == [:none, :peer, :fail_if_no_peer_cert, :client_once]
+      expect(HTTPI::Auth::SSL::VERIFY_MODES).to eq([:none, :peer, :fail_if_no_peer_cert, :client_once])
     end
   end
 
   describe "#present?" do
     it "defaults to return false" do
       ssl = HTTPI::Auth::SSL.new
-      ssl.should_not be_present
+      expect(ssl).not_to be_present
     end
 
     it "returns false if only a client key was specified" do
       ssl = HTTPI::Auth::SSL.new
       ssl.cert_key_file = "spec/fixtures/client_key.pem"
 
-      ssl.should_not be_present
+      expect(ssl).not_to be_present
     end
 
     it "returns false if only a client key was specified" do
       ssl = HTTPI::Auth::SSL.new
       ssl.cert_file = "spec/fixtures/client_cert.pem"
 
-      ssl.should_not be_present
+      expect(ssl).not_to be_present
     end
 
     it "returns true if both client key and cert are present" do
-      ssl.should be_present
+      expect(ssl).to be_present
     end
 
     it "returns true of the verify_mode is :none" do
       ssl = HTTPI::Auth::SSL.new
       ssl.verify_mode = :none
-      ssl.should be_present
+      expect(ssl).to be_present
     end
   end
 
   describe "#verify_mode" do
     it "defaults to return :peer" do
-      ssl.verify_mode.should == :peer
+      expect(ssl.verify_mode).to eq(:peer)
     end
 
     it "sets the verify mode to use" do
       ssl = HTTPI::Auth::SSL.new
 
       ssl.verify_mode = :none
-      ssl.verify_mode.should == :none
+      expect(ssl.verify_mode).to eq(:none)
     end
 
     it "raises an ArgumentError if the given mode is not supported" do
@@ -61,37 +61,37 @@ describe HTTPI::Auth::SSL do
 
   describe "#cert" do
     it "returns an OpenSSL::X509::Certificate for the given cert_file" do
-      ssl.cert.should be_a(OpenSSL::X509::Certificate)
+      expect(ssl.cert).to be_a(OpenSSL::X509::Certificate)
     end
 
     it "returns nil if no cert_file was given" do
       ssl = HTTPI::Auth::SSL.new
-      ssl.cert.should be_nil
+      expect(ssl.cert).to be_nil
     end
 
     it "returns the explicitly given certificate if set" do
       ssl = HTTPI::Auth::SSL.new
       cert = OpenSSL::X509::Certificate.new
       ssl.cert = cert
-      ssl.cert.should == cert
+      expect(ssl.cert).to eq(cert)
     end
   end
 
   describe "#cert_key" do
     it "returns a OpenSSL::PKey::RSA for the given cert_key" do
-      ssl.cert_key.should be_a(OpenSSL::PKey::RSA)
+      expect(ssl.cert_key).to be_a(OpenSSL::PKey::RSA)
     end
 
     it "returns nil if no cert_key_file was given" do
       ssl = HTTPI::Auth::SSL.new
-      ssl.cert_key.should be_nil
+      expect(ssl.cert_key).to be_nil
     end
 
     it "returns the explicitly given key if set" do
       ssl = HTTPI::Auth::SSL.new
       key = OpenSSL::PKey::RSA.new
       ssl.cert_key = key
-      ssl.cert_key.should == key
+      expect(ssl.cert_key).to eq(key)
     end
   end
 
@@ -100,7 +100,7 @@ describe HTTPI::Auth::SSL do
       ssl = HTTPI::Auth::SSL.new
 
       ssl.ca_cert_file = "spec/fixtures/client_cert.pem"
-      ssl.ca_cert.should be_a(OpenSSL::X509::Certificate)
+      expect(ssl.ca_cert).to be_a(OpenSSL::X509::Certificate)
     end
   end
 
@@ -109,34 +109,34 @@ describe HTTPI::Auth::SSL do
       ssl = HTTPI::Auth::SSL.new
 
       ssl.verify_mode = :none
-      ssl.openssl_verify_mode.should == OpenSSL::SSL::VERIFY_NONE
+      expect(ssl.openssl_verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE)
     end
 
     it "returns the OpenSSL verify mode for :peer" do
       ssl = HTTPI::Auth::SSL.new
 
       ssl.verify_mode = :peer
-      ssl.openssl_verify_mode.should == OpenSSL::SSL::VERIFY_PEER
+      expect(ssl.openssl_verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
     end
 
     it "returns the OpenSSL verify mode for :fail_if_no_peer_cert" do
       ssl = HTTPI::Auth::SSL.new
 
       ssl.verify_mode = :fail_if_no_peer_cert
-      ssl.openssl_verify_mode.should == OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
+      expect(ssl.openssl_verify_mode).to eq(OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT)
     end
 
     it "returns the OpenSSL verify mode for :client_once" do
       ssl = HTTPI::Auth::SSL.new
 
       ssl.verify_mode = :client_once
-      ssl.openssl_verify_mode.should == OpenSSL::SSL::VERIFY_CLIENT_ONCE
+      expect(ssl.openssl_verify_mode).to eq(OpenSSL::SSL::VERIFY_CLIENT_ONCE)
     end
   end
 
   describe "SSL_VERSIONS" do
     it "contains the supported SSL versions" do
-      HTTPI::Auth::SSL::SSL_VERSIONS.should == [:TLSv1, :SSLv2, :SSLv3]
+      expect(HTTPI::Auth::SSL::SSL_VERSIONS).to eq([:TLSv1, :SSLv2, :SSLv3])
     end
   end
 
@@ -145,17 +145,17 @@ describe HTTPI::Auth::SSL do
 
     it 'returns the SSL version for :TLSv1' do
       subject.ssl_version = :TLSv1
-      subject.ssl_version.should eq(:TLSv1)
+      expect(subject.ssl_version).to eq(:TLSv1)
     end
 
     it 'returns the SSL version for :SSLv2' do
       subject.ssl_version = :SSLv2
-      subject.ssl_version.should eq(:SSLv2)
+      expect(subject.ssl_version).to eq(:SSLv2)
     end
 
     it 'returns the SSL version for :SSLv3' do
       subject.ssl_version = :SSLv3
-      subject.ssl_version.should eq(:SSLv3)
+      expect(subject.ssl_version).to eq(:SSLv3)
     end
 
     it 'raises ArgumentError if the version is unsupported' do

data/spec/httpi/cookie_spec.rb

@@ -10,26 +10,26 @@ describe HTTPI::Cookie do
       headers = { "Set-Cookie" => "token=strawberry; Path=/; HttpOnly" }
       cookies = HTTPI::Cookie.list_from_headers(headers)
 
-      cookies.should have(1).item
-      cookies.first.should be_a(HTTPI::Cookie)
+      expect(cookies.size).to eq(1)
+      expect(cookies.first).to be_a(HTTPI::Cookie)
     end
 
     it "handles multiple cookies" do
       headers = { "Set-Cookie" => ["user=chucknorris; Path=/; HttpOnly", "token=strawberry; Path=/; HttpOnly"] }
       cookies = HTTPI::Cookie.list_from_headers(headers)
-      cookies.should have(2).items
+      expect(cookies.size).to eq(2)
     end
   end
 
   describe "#name" do
     it "returns the name of the cookie" do
-      cookie.name.should == "token"
+      expect(cookie.name).to eq("token")
     end
   end
 
   describe "#name_and_value" do
     it "returns the name and value of the cookie" do
-      cookie.name_and_value.should == "token=choc-choc-chip"
+      expect(cookie.name_and_value).to eq("token=choc-choc-chip")
     end
   end
 

data/spec/httpi/cookie_store_spec.rb

@@ -9,14 +9,14 @@ describe HTTPI::CookieStore do
   it "stores a set of cookies" do
     cookie_store = HTTPI::CookieStore.new
     cookie_store.add(user_cookie, token_cookie)
-    cookie_store.fetch.should include("user=chucknorris", "token=strawberry")
+    expect(cookie_store.fetch).to include("user=chucknorris", "token=strawberry")
 
     # add a new token cookie with a different value
     token_cookie = some_cookie(:token, "choc-choc-chip")
     cookie_store.add(token_cookie)
 
-    cookie_store.fetch.should include("token=choc-choc-chip")
-    cookie_store.fetch.should_not include("token=strawberry")
+    expect(cookie_store.fetch).to include("token=choc-choc-chip")
+    expect(cookie_store.fetch).not_to include("token=strawberry")
   end
 
   def some_cookie(name, value)

data/spec/httpi/httpi_spec.rb

@@ -249,19 +249,19 @@ describe HTTPI do
 
     describe ".log" do
       it "defaults to true" do
-        HTTPI.log?.should be_true
+        expect(HTTPI.log?).to be_true
       end
     end
 
     describe ".logger" do
       it "defaults to Logger writing to STDOUT" do
-        HTTPI.logger.should be_a(Logger)
+        expect(HTTPI.logger).to be_a(Logger)
       end
     end
 
     describe ".log_level" do
       it "defaults to :debug" do
-        HTTPI.log_level.should == :debug
+        expect(HTTPI.log_level).to eq(:debug)
       end
     end
 

data/spec/httpi/request_spec.rb

@@ -7,25 +7,25 @@ describe HTTPI::Request do
   describe ".new" do
     it "accepts a url" do
       request = HTTPI::Request.new "http://example.com"
-      request.url.should == URI("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
-      request.url.should == URI("http://example.com")
-      request.open_timeout.should == 30
+      expect(request.url).to eq(URI("http://example.com"))
+      expect(request.open_timeout).to eq(30)
     end
   end
 
   describe "#url" do
     it "lets you specify the URL to access as a String" do
       request.url = "http://example.com"
-      request.url.should == URI("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")
-      request.url.should == 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
@@ -34,12 +34,12 @@ describe HTTPI::Request do
 
     it "uses username and password as basic authentication if present in the URL" do
       request.url = "http://username:password@example.com"
-      request.auth.basic.should == ['username', 'password']
+      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"
-      request.auth.basic.should == ['username', '']
+      expect(request.auth.basic).to eq(['username', ''])
     end
   end
 
@@ -50,37 +50,37 @@ describe HTTPI::Request do
     it "lets you specify query parameter as String" do
       request.url = "http://example.com"
       request.query = "q=query"
-      request.url.to_s.should == "http://example.com?q=query"
+      expect(request.url.to_s).to eq("http://example.com?q=query")
     end
     it "lets you specify query parameter as Hash" do
       request.url = "http://example.com"
       request.query = {:q => "query"}
-      request.url.to_s.should == "http://example.com?q=query"
+      expect(request.url.to_s).to eq("http://example.com?q=query")
     end
     it "getter return nil for invalid url" do
-      request.query.should be_nil
+      expect(request.query).to be_nil
     end
     it "getter return String for query parameter as String" do
       request.url = "http://example.com"
       request.query = "q=query"
-      request.query.should == "q=query"
+      expect(request.query).to eq("q=query")
     end
     it "getter return String for query parameter as Hash" do
       request.url = "http://example.com"
       request.query = {:q => "query"}
-      request.query.should == "q=query"
+      expect(request.query).to eq("q=query")
     end
   end
 
   describe "#proxy" do
     it "lets you specify the proxy URL to use as a String" do
       request.proxy = "http://proxy.example.com"
-      request.proxy.should == URI("http://proxy.example.com")
+      expect(request.proxy).to eq(URI("http://proxy.example.com"))
     end
 
     it "also accepts a URI object" do
       request.proxy = URI("http://proxy.example.com")
-      request.proxy.should == 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
@@ -90,23 +90,23 @@ describe HTTPI::Request do
 
   describe "#ssl" do
     it "returns false if no request url was specified" do
-      request.should_not be_ssl
+      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"
-      request.should_not be_ssl
+      expect(request).not_to be_ssl
     end
 
     it "returns true if the request url starts with https" do
       request.url = "https://example.com"
-      request.should be_ssl
+      expect(request).to be_ssl
     end
 
     context "with an explicit value" do
       it "returns the value" do
         request.ssl = true
-        request.should be_ssl
+        expect(request).to be_ssl
       end
     end
   end
@@ -114,32 +114,32 @@ describe HTTPI::Request do
   describe "#headers" do
     it "lets you specify a Hash of HTTP request headers" do
       request.headers = { "Accept-Encoding" => "gzip" }
-      request.headers.should == { "Accept-Encoding" => "gzip" }
+      expect(request.headers).to eq({ "Accept-Encoding" => "gzip" })
     end
 
     it "defaults to return an empty Hash" do
-      request.headers.should == {}
+      expect(request.headers).to eq({})
     end
   end
 
   describe "#gzip" do
     it "adds the proper 'Accept-Encoding' header" do
       request.gzip
-      request.headers["Accept-Encoding"].should == "gzip,deflate"
+      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")
-      request.headers["Cookie"].should == "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")
 
-      request.headers["Cookie"].should include("some-cookie=choc-chip", "second-cookie=oatmeal")
+      expect(request.headers["Cookie"]).to include("some-cookie=choc-chip", "second-cookie=oatmeal")
     end
 
     it "accepts an Array of cookies" do
@@ -150,12 +150,12 @@ describe HTTPI::Request do
 
       request.set_cookies(cookies)
 
-      request.headers["Cookie"].should include("some-cookie=choc-chip", "second-cookie=oatmeal")
+      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, {}, "")
-      request.headers.should_not include("Cookie")
+      expect(request.headers).not_to include("Cookie")
     end
 
     def new_cookie(cookie_string)
@@ -170,47 +170,47 @@ describe HTTPI::Request do
   describe "#body" do
     it "lets you specify the HTTP request body using a String" do
       request.body = "<some>xml</some>"
-      request.body.should == "<some>xml</some>"
+      expect(request.body).to eq("<some>xml</some>")
     end
 
     it "lets you specify the HTTP request body using a Hash" do
       request.body = {:foo => :bar, :baz => :foo}
-      request.body.split("&").should =~ ["foo=bar", "baz=foo"]
+      expect(request.body.split("&")).to match_array(["foo=bar", "baz=foo"])
     end
   end
 
   describe "#open_timeout" do
     it "lets you specify the open timeout" do
       request.open_timeout = 30
-      request.open_timeout.should == 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
-      request.read_timeout.should == 45
+      expect(request.read_timeout).to eq(45)
     end
   end
 
   describe "#auth" do
     it "returns the authentication object" do
-      request.auth.should be_an(HTTPI::Auth::Config)
+      expect(request.auth).to be_an(HTTPI::Auth::Config)
     end
 
     it "memoizes the authentication object" do
-      request.auth.should equal(request.auth)
+      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"
-      request.auth?.should be_true
+      expect(request.auth?).to be_true
     end
 
     it "returns false otherwise" do
-      request.auth?.should be_false
+      expect(request.auth?).to be_false
     end
   end