net_http_spec.rb in httpi-2.4.4

- old
+ new
@@ -1,198 +1,54 @@
 require "spec_helper"
-require "integration/support/server"
+require "httpi/adapter/net_http"
+require "httpi/request"
 
-describe HTTPI::Adapter::NetHTTP do
+begin
+  HTTPI::Adapter.load_adapter(:net_http)
 
-  subject(:adapter) { :net_http }
+  describe HTTPI::Adapter::NetHTTP do
+    let(:adapter) { HTTPI::Adapter::NetHTTP.new(request) }
+    let(:request) { HTTPI::Request.new("http://example.com") }
 
-  context "http requests" do
-    before :all do
-      @server = IntegrationServer.run
-    end
-
-    after :all do
-      @server.stop
-    end
-
-    context 'when socks is specified' do
-
-      let(:socks_client) { mock('socks_client') }
-      let(:request){HTTPI::Request.new(@server.url)}
-
-      it 'uses Net::HTTP.SOCKSProxy as client' do
-        socks_client.expects(:new).with(URI(@server.url).host, URI(@server.url).port).returns(:socks_client_instance)
-        Net::HTTP.expects(:SOCKSProxy).with('localhost', 8080).returns socks_client
-
-        request.proxy = 'socks://localhost:8080'
-        adapter = HTTPI::Adapter::NetHTTP.new(request)
-
-        expect(adapter.client).to eq(:socks_client_instance)
+    let(:response) {
+      Object.new.tap do |r|
+        r.stubs(:code).returns(200)
+        r.stubs(:body).returns("abc")
+        r.stubs(:to_hash).returns({"Content-Length" => "3"})
       end
-    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")
+    before do
+      Net::HTTP.any_instance.stubs(:start).returns(response)
     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
+    describe "settings" do
+      describe "open_timeout, read_timeout" do
+        it "are being set on the client" do
+          request.open_timeout = 30
+          request.read_timeout = 40
 
-    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
+          adapter.client.expects(:open_timeout=).with(30)
+          adapter.client.expects(:read_timeout=).with(40)
 
-    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
-
-    context "supports custom methods supported by Net::HTTP" do
-      let(:request) do
-        HTTPI::Request.new(@server.url).tap do|r|
-          r.body = request_body if request_body
+          adapter.request(:get)
         end
       end
 
-      let(:request_body) { nil }
-
-      let(:response) { HTTPI.request(http_method, request, adapter) }
-
-      shared_examples_for 'any supported custom method' do
-        specify { response.body.should eq http_method.to_s }
-        specify { response.headers["Content-Type"].should eq('text/plain') }
+      describe "write_timeout" do
+        if Net::HTTP.method_defined?(:write_timeout=)
+          it "is being set on the client" do
+            request.write_timeout = 50
+            adapter.client.expects(:write_timeout=).with(50)
+            adapter.request(:get)
+          end
+        else
+          it "can not be set on the client" do
+            request.write_timeout = 50
+            expect { adapter.request(:get) }
+              .to raise_error(HTTPI::NotSupportedError, /write_timeout/)
+          end
+        end
       end
-
-      context 'PATCH' do
-        let(:http_method) { :patch }
-        let(:request_body) { "<some>xml</some>" }
-
-        it_behaves_like 'any supported custom method'
-      end
-
-      context 'UNSUPPORTED method' do
-        let(:http_method) { :unsupported }
-
-        specify { expect { response }.to raise_error HTTPI::NotSupportedError }
-      end
     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" do
-      request = HTTPI::Request.new(@server.url + "digest-auth")
-      request.auth.digest("admin", "secret")
-
-      expect { HTTPI.get(request, adapter) }.
-        to raise_error(HTTPI::NotSupportedError, /does not support HTTP digest authentication/)
-    end
-
-    it "supports ntlm authentication" do
-      request = HTTPI::Request.new(@server.url + "ntlm-auth")
-      request.auth.ntlm("tester", "vReqSoafRe5O")
-
-      response = HTTPI.get(request, adapter)
-      expect(response.body).to eq("ntlm-auth")
-    end
-
-    it 'does not support ntlm authentication when Net::NTLM is not available' do
-      Net.expects(:const_defined?).with(:NTLM).returns false
-
-      request = HTTPI::Request.new(@server.url + 'ntlm-auth')
-      request.auth.ntlm("testing", "failures")
-
-      expect { HTTPI.get(request, adapter) }.
-        to raise_error(HTTPI::NotSupportedError, /Net::NTLM is not available/)
-    end
-
-    it 'does not require ntlm when ntlm authenication is not requested' do 
-      HTTPI::Adapter::NetHTTP.any_instance.stubs(:check_net_ntlm_version!).raises(RuntimeError)
-        request = HTTPI::Request.new(@server.url)
-        expect(request.auth.ntlm?).to be false
-
-        # make sure a request doesn't call ntlm check if we don't ask for it.
-        expect { HTTPI.get(request, adapter) }.not_to raise_error
-      HTTPI::Adapter::NetHTTP.any_instance.unstub(:check_net_ntlm_version!)
-    end
-
-    it 'does check ntlm when ntlm authentication is requested' do 
-      request = HTTPI::Request.new(@server.url + "ntlm-auth")
-      request.auth.ntlm("tester", "vReqSoafRe5O")
-        
-      expect { HTTPI.get(request, adapter) }.not_to raise_error
-
-      # the check should also verify that the version of ntlm is supported and still fail if it isn't
-      HTTPI::Adapter::NetHTTP.any_instance.stubs(:ntlm_version).returns("0.1.1")
-
-        request = HTTPI::Request.new(@server.url + "ntlm-auth")
-        request.auth.ntlm("tester", "vReqSoafRe5O")
-        
-        expect { HTTPI.get(request, adapter) }.to raise_error(ArgumentError, /Invalid version/)
-
-      HTTPI::Adapter::NetHTTP.any_instance.unstub(:ntlm_version)
-    end
-
-    it "does not crash when authenticate header is missing (on second request)" do
-      request = HTTPI::Request.new(@server.url + 'ntlm-auth')
-      request.auth.ntlm("tester", "vReqSoafRe5O")
-
-      expect { HTTPI.get(request, adapter) }.
-        to_not raise_error
-
-      expect { HTTPI.get(request, adapter) }.
-        to_not raise_error
-    end
   end
-
-  # it does not support digest auth
-
-  if RUBY_PLATFORM =~ /java/
-    pending "Puma Server complains: SSL not supported on JRuby"
-  else
-    context "https requests" do
-      before :all do
-        @server = IntegrationServer.run(:ssl => true)
-      end
-      after :all do
-        @server.stop
-      end
-
-      # it does not raise when no certificate was set up
-      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
-    end
-  end
-
 end