httpi 2.1.1 → 2.2.0

data/spec/httpi/adapter/httpclient_spec.rb

@@ -13,7 +13,7 @@ describe HTTPI::Adapter::HTTPClient do
   describe "#request(:get)" do
     it "returns a valid HTTPI::Response" do
       httpclient_expects(:get)
-      adapter.request(:get).should match_response(:body => Fixture.xml)
+      expect(adapter.request(:get)).to match_response(:body => Fixture.xml)
     end
   end
 
@@ -22,14 +22,14 @@ describe HTTPI::Adapter::HTTPClient do
       request.body = Fixture.xml
       httpclient_expects(:post)
 
-      adapter.request(:post).should match_response(:body => Fixture.xml)
+      expect(adapter.request(:post)).to match_response(:body => Fixture.xml)
     end
   end
 
   describe "#request(:head)" do
     it "returns a valid HTTPI::Response" do
       httpclient_expects(:head)
-      adapter.request(:head).should match_response(:body => Fixture.xml)
+      expect(adapter.request(:head)).to match_response(:body => Fixture.xml)
     end
   end
 
@@ -38,21 +38,21 @@ describe HTTPI::Adapter::HTTPClient do
       request.body = Fixture.xml
       httpclient_expects(:put)
 
-      adapter.request(:put).should match_response(:body => Fixture.xml)
+      expect(adapter.request(:put)).to match_response(:body => Fixture.xml)
     end
   end
 
   describe "#request(:delete)" do
     it "returns a valid HTTPI::Response" do
       httpclient_expects(:delete)
-      adapter.request(:delete).should match_response(:body => Fixture.xml)
+      expect(adapter.request(:delete)).to match_response(:body => Fixture.xml)
     end
   end
 
   describe "#request(:custom)" do
     it "returns a valid HTTPI::Response" do
       httpclient_expects(:custom)
-      adapter.request(:custom).should match_response(:body => Fixture.xml)
+      expect(adapter.request(:custom)).to match_response(:body => Fixture.xml)
     end
   end
 
@@ -107,6 +107,19 @@ describe HTTPI::Adapter::HTTPClient do
       end
     end
 
+    context "(for SSL without auth)" do
+      before do
+        request.ssl = true
+      end
+
+      it 'should set the ssl_version if specified' do
+        request.auth.ssl.ssl_version = :SSLv3
+        ssl_config.expects(:ssl_version=).with('SSLv3')
+
+        adapter.request(:get)
+      end
+    end
+
     context "(for SSL client auth)" do
       before do
         request.auth.ssl.cert_key_file = "spec/fixtures/client_key.pem"

data/spec/httpi/adapter/net_http_persistent_spec.rb

@@ -19,37 +19,37 @@ describe HTTPI::Adapter::NetHTTPPersistent do
       request.headers["X-Header"] = "HTTPI"
 
       response = HTTPI.get(request, adapter)
-      response.body.should include("HTTPI")
+      expect(response.body).to include("HTTPI")
     end
 
     it "executes GET requests" do
       response = HTTPI.get(@server.url, adapter)
-      response.body.should eq("get")
-      response.headers["Content-Type"].should eq("text/plain")
+      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)
-      response.body.should eq("post")
-      response.headers["Content-Type"].should eq("text/plain")
+      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)
-      response.code.should == 200
-      response.headers["Content-Type"].should eq("text/plain")
+      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)
-      response.body.should eq("put")
-      response.headers["Content-Type"].should eq("text/plain")
+      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)
-      response.body.should eq("delete")
-      response.headers["Content-Type"].should eq("text/plain")
+      expect(response.body).to eq("delete")
+      expect(response.headers["Content-Type"]).to eq("text/plain")
     end
 
     it "supports basic authentication" do
@@ -57,7 +57,7 @@ describe HTTPI::Adapter::NetHTTPPersistent do
       request.auth.basic("admin", "secret")
 
       response = HTTPI.get(request, adapter)
-      response.body.should eq("basic-auth")
+      expect(response.body).to eq("basic-auth")
     end
 
     it "does not support ntlm authentication" do

data/spec/httpi/adapter/net_http_spec.rb

@@ -19,37 +19,37 @@ describe HTTPI::Adapter::NetHTTP do
       request.headers["X-Header"] = "HTTPI"
 
       response = HTTPI.get(request, adapter)
-      response.body.should include("HTTPI")
+      expect(response.body).to include("HTTPI")
     end
 
     it "executes GET requests" do
       response = HTTPI.get(@server.url, adapter)
-      response.body.should eq("get")
-      response.headers["Content-Type"].should eq("text/plain")
+      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)
-      response.body.should eq("post")
-      response.headers["Content-Type"].should eq("text/plain")
+      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)
-      response.code.should == 200
-      response.headers["Content-Type"].should eq("text/plain")
+      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)
-      response.body.should eq("put")
-      response.headers["Content-Type"].should eq("text/plain")
+      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)
-      response.body.should eq("delete")
-      response.headers["Content-Type"].should eq("text/plain")
+      expect(response.body).to eq("delete")
+      expect(response.headers["Content-Type"]).to eq("text/plain")
     end
 
     it "supports basic authentication" do
@@ -57,7 +57,7 @@ describe HTTPI::Adapter::NetHTTP do
       request.auth.basic("admin", "secret")
 
       response = HTTPI.get(request, adapter)
-      response.body.should eq("basic-auth")
+      expect(response.body).to eq("basic-auth")
     end
 
     it "does not support digest authentication" do
@@ -73,7 +73,18 @@ describe HTTPI::Adapter::NetHTTP do
       request.auth.ntlm("tester", "vReqSoafRe5O")
 
       response = HTTPI.get(request, adapter)
-      response.body.should eq("ntlm-auth")
+      expect(response.body).to eq("ntlm-auth")
+    end
+
+    it 'fatal logs when net/ntlm is not available, but ntlm authentication was requested' do
+      Net.expects(:const_defined?).with(:NTLM).returns false
+
+      request = HTTPI::Request.new(@server.url + 'ntlm-auth')
+      request.auth.ntlm("testing", "failures")
+      HTTPI.logger.expects(:fatal)
+
+      response = HTTPI.get(request, adapter)
+      expect(response.body).to eq("ntlm-auth")
     end
   end
 

data/spec/httpi/adapter/rack_spec.rb

@@ -18,37 +18,37 @@ describe HTTPI::Adapter::NetHTTP do
       request.headers["X-Header"] = "HTTPI"
 
       response = HTTPI.get(request, adapter)
-      response.body.should include("HTTPI")
+      expect(response.body).to include("HTTPI")
     end
 
     it "executes GET requests" do
       response = HTTPI.get(@url, adapter)
-      response.body.should eq("get")
-      response.headers["Content-Type"].should eq("text/plain")
+      expect(response.body).to eq("get")
+      expect(response.headers["Content-Type"]).to eq("text/plain")
     end
 
     it "executes POST requests" do
       response = HTTPI.post(@url, "<some>xml</some>", adapter)
-      response.body.should eq("post")
-      response.headers["Content-Type"].should eq("text/plain")
+      expect(response.body).to eq("post")
+      expect(response.headers["Content-Type"]).to eq("text/plain")
     end
 
     it "executes HEAD requests" do
       response = HTTPI.head(@url, adapter)
-      response.code.should == 200
-      response.headers["Content-Type"].should eq("text/plain")
+      expect(response.code).to eq(200)
+      expect(response.headers["Content-Type"]).to eq("text/plain")
     end
 
     it "executes PUT requests" do
       response = HTTPI.put(@url, "<some>xml</some>", adapter)
-      response.body.should eq("put")
-      response.headers["Content-Type"].should eq("text/plain")
+      expect(response.body).to eq("put")
+      expect(response.headers["Content-Type"]).to eq("text/plain")
     end
 
     it "executes DELETE requests" do
       response = HTTPI.delete(@url, adapter)
-      response.body.should eq("delete")
-      response.headers["Content-Type"].should eq("text/plain")
+      expect(response.body).to eq("delete")
+      expect(response.headers["Content-Type"]).to eq("text/plain")
     end
 
     describe "settings:" do

data/spec/httpi/adapter_spec.rb

@@ -12,8 +12,8 @@ describe HTTPI::Adapter do
 
       adapter.register(name, klass, deps)
 
-      HTTPI::Adapter::ADAPTERS[:custom].should include(:class => klass, :deps => deps)
-      HTTPI::Adapter::ADAPTER_CLASS_MAP[klass].should be(name)
+      expect(HTTPI::Adapter::ADAPTERS[:custom]).to include(:class => klass, :deps => deps)
+      expect(HTTPI::Adapter::ADAPTER_CLASS_MAP[klass]).to be(name)
     end
   end
 
@@ -25,14 +25,14 @@ describe HTTPI::Adapter do
     end
 
     it "sets the adapter to use" do
-      adapter.use.should_not == :net_http
+      expect(adapter.use).not_to eq(:net_http)
 
       adapter.use = :net_http
-      adapter.use.should == :net_http
+      expect(adapter.use).to eq(:net_http)
     end
 
     it "defaults to use the HTTPClient adapter" do
-      adapter.use.should == :httpclient
+      expect(adapter.use).to eq(:httpclient)
     end
 
     it "loads the adapter's client library" do
@@ -48,13 +48,13 @@ describe HTTPI::Adapter do
   describe ".load" do
     context "called with a valid adapter" do
       it "returns the adapter's name and class" do
-        adapter.load(:net_http).should == HTTPI::Adapter::NetHTTP
+        expect(adapter.load(:net_http)).to eq(HTTPI::Adapter::NetHTTP)
       end
     end
 
     context "called with nil" do
       it "returns the default adapter's name and class" do
-        adapter.load(nil).should == HTTPI::Adapter::HTTPClient
+        expect(adapter.load(nil)).to eq(HTTPI::Adapter::HTTPClient)
       end
     end
 

data/spec/httpi/auth/config_spec.rb

@@ -7,156 +7,156 @@ describe HTTPI::Auth::Config do
   describe "#basic" do
     it "lets you specify the basic auth credentials" do
       auth.basic "username", "password"
-      auth.basic.should == ["username", "password"]
+      expect(auth.basic).to eq(["username", "password"])
     end
 
     it "also accepts an Array of credentials" do
       auth.basic ["username", "password"]
-      auth.basic.should == ["username", "password"]
+      expect(auth.basic).to eq(["username", "password"])
     end
 
     it "sets the authentication type to :basic" do
       auth.basic "username", "password"
-      auth.type.should == :basic
+      expect(auth.type).to eq(:basic)
     end
   end
 
   describe "#basic?" do
     it "defaults to return false" do
-      auth.should_not be_basic
+      expect(auth).not_to be_basic
     end
 
     it "returns true for HTTP basic auth" do
       auth.basic "username", "password"
-      auth.should be_basic
+      expect(auth).to be_basic
     end
   end
 
   describe "#digest" do
     it "lets you specify the digest auth credentials" do
       auth.digest "username", "password"
-      auth.digest.should == ["username", "password"]
+      expect(auth.digest).to eq(["username", "password"])
     end
 
     it "also accepts an Array of credentials" do
       auth.digest ["username", "password"]
-      auth.digest.should == ["username", "password"]
+      expect(auth.digest).to eq(["username", "password"])
     end
 
     it "sets the authentication type to :digest" do
       auth.digest "username", "password"
-      auth.type.should == :digest
+      expect(auth.type).to eq(:digest)
     end
   end
 
   describe "#digest?" do
     it "defaults to return false" do
-      auth.should_not be_digest
+      expect(auth).not_to be_digest
     end
 
     it "returns true for HTTP digest auth" do
       auth.digest "username", "password"
-      auth.should be_digest
+      expect(auth).to be_digest
     end
   end
 
   describe "#gssnegotiate" do
     it "sets the authentication type to :gssnegotiate" do
       auth.gssnegotiate
-      auth.type.should == :gssnegotiate
+      expect(auth.type).to eq(:gssnegotiate)
     end
   end
 
   describe "#gssnegotiate?" do
     it "defaults to return false" do
-      auth.should_not be_gssnegotiate
+      expect(auth).not_to be_gssnegotiate
     end
 
     it "returns true for HTTP Negotiate auth" do
       auth.gssnegotiate
-      auth.should be_gssnegotiate
+      expect(auth).to be_gssnegotiate
     end
   end
 
   describe "#http?" do
     it "defaults to return false" do
-      auth.should_not be_http
+      expect(auth).not_to be_http
     end
 
     it "returns true for HTTP basic auth" do
       auth.basic "username", "password"
-      auth.should be_http
+      expect(auth).to be_http
     end
 
     it "returns true for HTTP digest auth" do
       auth.digest "username", "password"
-      auth.should be_http
+      expect(auth).to be_http
     end
   end
 
   describe "#ssl" do
     it "returns the HTTPI::Auth::SSL object" do
-      auth.ssl.should be_a(HTTPI::Auth::SSL)
+      expect(auth.ssl).to be_a(HTTPI::Auth::SSL)
     end
   end
 
   describe "#ssl?" do
     it "defaults to return false" do
-      auth.should_not be_ssl
+      expect(auth).not_to be_ssl
     end
 
     it "returns true for SSL client auth" do
       auth.ssl.cert_key_file = "spec/fixtures/client_key.pem"
       auth.ssl.cert_file = "spec/fixtures/client_cert.pem"
 
-      auth.should be_ssl
+      expect(auth).to be_ssl
     end
   end
 
   describe "#type" do
     it "returns the authentication type" do
       auth.basic "username", "password"
-      auth.type.should == :basic
+      expect(auth.type).to eq(:basic)
     end
   end
 
   describe "#credentials" do
     it "returns the credentials for HTTP basic auth" do
       auth.basic "username", "basic"
-      auth.credentials.should == ["username", "basic"]
+      expect(auth.credentials).to eq(["username", "basic"])
     end
 
     it "returns the credentials for HTTP digest auth" do
       auth.digest "username", "digest"
-      auth.credentials.should == ["username", "digest"]
+      expect(auth.credentials).to eq(["username", "digest"])
     end
   end
 
   describe "#ntlm" do
     it "lets you specify the ntlm auth credentials" do
       auth.ntlm "username", "password"
-      auth.ntlm.should == ["username", "password"]
+      expect(auth.ntlm).to eq(["username", "password"])
     end
 
     it "also accepts an Array of credentials" do
       auth.ntlm ["username", "password"]
-      auth.ntlm.should == ["username", "password"]
+      expect(auth.ntlm).to eq(["username", "password"])
     end
 
     it "sets the authentication type to :ntlm" do
       auth.ntlm "username", "password"
-      auth.type.should == :ntlm
+      expect(auth.type).to eq(:ntlm)
     end
   end
 
   describe "#ntlm?" do
     it "defaults to return false" do
-      auth.should_not be_ntlm
+      expect(auth).not_to be_ntlm
     end
 
     it "returns true for HTTP ntlm auth" do
       auth.ntlm "username", "password"
-      auth.should be_ntlm
+      expect(auth).to be_ntlm
     end
   end