webmock 1.6.4 → 1.7.0

data/spec/curb_spec_helper.rb

@@ -1,3 +1,5 @@
+require 'ostruct'
+
 module CurbSpecHelper
   def http_request(method, uri, options = {}, &block)
     uri = Addressable::URI.heuristic_parse(uri)
@@ -5,7 +7,8 @@ module CurbSpecHelper
 
     curl = curb_http_request(uri, method, body, options)
 
-    status, response_headers = Curl::Easy::WebmockHelper.parse_header_string(curl.header_str)
+    status, response_headers =
+     WebMock::HttpLibAdapters::CurbAdapter.parse_header_string(curl.header_str)
 
     OpenStruct.new(
       :body => curl.body_str,
@@ -17,7 +20,7 @@ module CurbSpecHelper
 
   def setup_request(uri, curl, options={})
     curl          ||= Curl::Easy.new
-    curl.url      = uri.omit(:userinfo).to_s 
+    curl.url      = uri.omit(:userinfo).to_s
     curl.username = uri.user
     curl.password = uri.password
     curl.timeout  = 10
@@ -38,9 +41,6 @@ module CurbSpecHelper
     Curl::Err::ConnectionFailedError
   end
 
-  def setup_expectations_for_real_request(options = {})
-  end
-
   def http_library
     :curb
   end
@@ -54,7 +54,7 @@ module CurbSpecHelper
         curl.post_body = body
       when :put
         curl.put_data = body
-      end  
+      end
 
       curl.http(method)
       curl

data/spec/em_http_request_spec.rb

@@ -10,6 +10,97 @@ unless RUBY_PLATFORM =~ /java/
 
     it_should_behave_like "WebMock"
 
+    #functionality only supported for em-http-request 1.x
+    if defined?(EventMachine::HttpConnection)
+      describe "with middleware" do
+
+        it "should work with request middleware" do
+          stub_http_request(:get, "www.example.com").with(:body => 'bar')
+
+          middleware = Class.new do
+            def request(client, head, body)
+              [{}, 'bar']
+            end
+          end
+
+          EM.run do
+            conn = EventMachine::HttpRequest.new('http://www.example.com/')
+
+            conn.use middleware
+
+            http = conn.get(:body => 'foo')
+
+            http.callback do
+              WebMock.should have_requested(:get, "www.example.com").with(:body => 'bar')
+              EM.stop
+            end
+          end
+        end
+
+        it "should work with response middleware" do
+          stub_http_request(:get, "www.example.com").to_return(:body => 'foo')
+
+          middleware = Class.new do
+            def response(resp)
+              resp.response = 'bar'
+            end
+          end
+
+          EM.run do
+            conn = EventMachine::HttpRequest.new('http://www.example.com/')
+
+            conn.use middleware
+
+            http = conn.get
+
+            http.callback do
+              http.response.should be == 'bar'
+              EM.stop
+            end
+          end
+        end
+      end
+
+      # not pretty, but it works
+      describe "with synchrony" do
+        let(:webmock_em_http) { File.expand_path(File.join(File.dirname(__FILE__), "../lib/webmock/http_lib_adapters/em_http_request/em_http_request_1_x.rb")) }
+
+        before(:each) do
+          # need to reload the webmock em-http adapter after we require synchrony
+          WebMock::HttpLibAdapters::EmHttpRequestAdapter.disable!
+          $".delete webmock_em_http
+          $".delete File.expand_path(File.join(File.dirname(__FILE__), "../lib/webmock/http_lib_adapters/em_http_request_adapter.rb"))
+          require 'em-synchrony'
+          require 'em-synchrony/em-http'
+          require File.expand_path(File.join(File.dirname(__FILE__), "../lib/webmock/http_lib_adapters/em_http_request_adapter.rb"))
+        end
+
+        it "should work" do
+          stub_request(:post, /.*.testserver.com*/).to_return(:status => 200, :body => 'ok')
+          lambda {
+            EM.run do
+              fiber = Fiber.new do
+                http = EM::HttpRequest.new("http://www.testserver.com").post :body => "foo=bar&baz=bang", :timeout => 60
+                EM.stop
+              end
+              fiber.resume
+            end
+          }.should_not raise_error
+        end
+
+        after(:each) do
+          EM.send(:remove_const, :Synchrony)
+          EM.send(:remove_const, :HTTPMethods)
+          WebMock::HttpLibAdapters::EmHttpRequestAdapter.disable!
+          $".reject! {|path| path.include? "em-http-request"}
+          $".delete webmock_em_http
+          $".delete File.expand_path(File.join(File.dirname(__FILE__), "../lib/webmock/http_lib_adapters/em_http_request_adapter.rb"))
+          require 'em-http-request'
+          require File.expand_path(File.join(File.dirname(__FILE__), "../lib/webmock/http_lib_adapters/em_http_request_adapter.rb"))
+        end
+      end
+    end
+
     it "should work with streaming" do
       stub_http_request(:get, "www.example.com").to_return(:body => "abc")
       response = ""
@@ -36,7 +127,10 @@ unless RUBY_PLATFORM =~ /java/
     end
 
     describe "mocking EM::HttpClient API" do
-      before { stub_http_request(:get, "www.example.com/") }
+      before do
+        stub_http_request(:get, "www.example.com/")
+        WebMock::HttpLibAdapters::EmHttpRequestAdapter.enable!
+      end
       subject do
         client = nil
         EM.run do

data/spec/em_http_request_spec_helper.rb

@@ -6,34 +6,37 @@ module EMHttpRequestSpecHelper
   end
 
   def http_request(method, uri, options = {}, &block)
+    @http = nil
+    head = options[:headers] || {}
     response = nil
     error = nil
     uri = Addressable::URI.heuristic_parse(uri)
     EventMachine.run {
-      request = EventMachine::HttpRequest.new("#{uri.omit(:userinfo).normalize.to_s}")
-      http = request.send(:setup_request, method, {
-        :timeout => 10, 
+      request = EventMachine::HttpRequest.new("#{uri.normalize.to_s}")
+      http = request.send(method, {
+        :timeout => 10,
         :body => options[:body],
         :query => options[:query],
-        'authorization' => [uri.user, uri.password],
-        :head => options[:headers]}, &block)
+        :head => head.merge('authorization' => [uri.user, uri.password])
+      }, &block)
       http.errback {
         error = if http.respond_to?(:errors)
-          http.errors         
+          http.errors
         else
           http.error
-        end  
-        failed 
+        end
+        failed
       }
-      http.callback {    
+      http.callback {
         response = OpenStruct.new({
           :body => http.response,
-          :headers => WebMock::Util::Headers.normalize_headers(extract_response_headers(http)),          
+          :headers => WebMock::Util::Headers.normalize_headers(extract_response_headers(http)),
           :message => http.response_header.http_reason,
           :status => http.response_header.status.to_s
         })
         EventMachine.stop
       }
+      @http = http
     }
     raise error if error
     response
@@ -47,21 +50,18 @@ module EMHttpRequestSpecHelper
     ""
   end
 
-  def setup_expectations_for_real_request(options = {})
-  end
-
   def http_library
     :em_http_request
   end
-  
+
   private
-  
+
   def extract_response_headers(http)
     headers = {}
     if http.response_header
       http.response_header.each do |k,v|
         v = v.join(", ") if v.is_a?(Array)
-        headers[k] = v 
+        headers[k] = v
       end
     end
     headers

data/spec/errors_spec.rb

@@ -5,13 +5,28 @@ describe "errors" do
     describe "message" do
       it "should have message with request signature and snippet" do
         request_signature = mock(:to_s => "aaa")
+        request_stub = mock
+        WebMock::RequestStub.stub!(:from_request_signature).and_return(request_stub)
         WebMock::StubRequestSnippet.stub!(:new).
-          with(request_signature).and_return(mock(:to_s => "bbb"))
+          with(request_stub).and_return(mock(:to_s => "bbb"))
         expected =  "Real HTTP connections are disabled. Unregistered request: aaa" +
                "\n\nYou can stub this request with the following snippet:\n\n" +
-               "bbb\n\n============================================================"  
-        WebMock::NetConnectNotAllowedError.new(request_signature).message.should == expected  
+               "bbb\n\n============================================================"
+        WebMock::NetConnectNotAllowedError.new(request_signature).message.should == expected
+      end
+
+      it "should have message with registered stubs if available" do
+        request_signature = mock(:to_s => "aaa")
+        request_stub = mock
+        WebMock::StubRegistry.instance.stub!(:request_stubs).and_return([request_stub])
+        WebMock::RequestStub.stub!(:from_request_signature).and_return(request_stub)
+        WebMock::StubRequestSnippet.stub!(:new).
+          with(request_stub).and_return(mock(:to_s => "bbb"))
+        expected =  "Real HTTP connections are disabled. Unregistered request: aaa" +
+               "\n\nYou can stub this request with the following snippet:\n\n" +
+               "bbb\n\nregistered request stubs:\n\nbbb\n\n============================================================"
+        WebMock::NetConnectNotAllowedError.new(request_signature).message.should == expected
       end
     end
   end
-end
+end

data/spec/example_curl_output.txt

@@ -1,22 +1,22 @@
-HTTP/1.1 202 OK
-Content-Type: text/html; charset=UTF-8
-Connection: Keep-Alive
-Date: Sat, 23 Jan 2010 01:01:05 GMT
-Content-Length: 438
-Accept: image/jpeg
-Accept: image/png
-
-<HTML>
-<HEAD>
-  <TITLE>Example Web Page</TITLE>
-</HEAD> 
-<body>  
-<p>You have reached this web page by typing &quot;example.com&quot;,
-&quot;example.net&quot;,
-  or &quot;example.org&quot; into your web browser.</p>
-<p>These domain names are reserved for use in documentation and are not available 
-  for registration. See <a href="http://www.rfc-editor.org/rfc/rfc2606.txt">RFC 
-  2606</a>, Section 3.</p>
-</BODY>
-</HTML>
-
+HTTP/1.1 202 OK
+Content-Type: text/html; charset=UTF-8
+Connection: Keep-Alive
+Date: Sat, 23 Jan 2010 01:01:05 GMT
+Content-Length: 419
+Accept: image/jpeg
+Accept: image/png
+
+<HTML>
+<HEAD>
+  <TITLE>Example Web Page</TITLE>
+</HEAD>
+<body>
+<p>You have reached this web page by typing &quot;example.com&quot;,
+&quot;example.net&quot;,
+  or &quot;example.org&quot; into your web browser.</p>
+<p>These domain names are reserved for use in documentation and are not available
+  for registration. See <a href="http://www.rfc-editor.org/rfc/rfc2606.txt">RFC
+  2606</a>, Section 3.</p>
+</BODY>
+</HTML>
+

data/spec/http_lib_adapters/http_lib_adapter_registry_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe WebMock::HttpLibAdapterRegistry do
+  describe "each_adapter" do
+    it "should yield block over each adapter" do
+      class MyAdapter < WebMock::HttpLibAdapter; end
+      WebMock::HttpLibAdapterRegistry.instance.register(:my_lib, MyAdapter)
+      adapters = []
+      WebMock::HttpLibAdapterRegistry.instance.each_adapter {|n,a|
+        adapters << [n, a]
+      }
+      adapters.should include([:my_lib, MyAdapter])
+      WebMock::HttpLibAdapterRegistry.instance.
+        http_lib_adapters.delete(:my_lib)
+    end
+  end
+end

data/spec/http_lib_adapters/http_lib_adapter_spec.rb

@@ -0,0 +1,12 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe WebMock::HttpLibAdapter do
+  describe "adapter_for" do
+    it "should add adapter to adapter registry" do
+      class MyAdapter < WebMock::HttpLibAdapter; end
+      WebMock::HttpLibAdapterRegistry.instance.
+        should_receive(:register).with(:my_lib, MyAdapter)
+      MyAdapter.adapter_for(:my_lib)
+    end
+  end
+end

data/spec/httpclient_spec.rb

@@ -28,7 +28,7 @@ describe "Webmock with HTTPClient" do
        :get, "http://www.example.com/",
        :headers => {"a" => ["c", "b"]}).status.should == "200"
    end
-  
+
 
   describe "async requests" do
 

data/spec/httpclient_spec_helper.rb

@@ -2,7 +2,7 @@ module HTTPClientSpecHelper
   class << self
     attr_accessor :async_mode
   end
-  
+
   def http_request(method, uri, options = {}, &block)
     uri = Addressable::URI.heuristic_parse(uri)
     c = HTTPClient.new
@@ -17,7 +17,7 @@ module HTTPClientSpecHelper
     else
       response = c.request(*params, &block)
     end
-    headers = response.header.all.inject({}) do |headers, header| 
+    headers = response.header.all.inject({}) do |headers, header|
       if !headers.has_key?(header[0])
         headers[header[0]] = header[1]
       else
@@ -41,43 +41,8 @@ module HTTPClientSpecHelper
     Errno::ECONNREFUSED
   end
 
-  def setup_expectations_for_real_request(options = {})
-    socket = mock("TCPSocket")
-    TCPSocket.should_receive(:new).
-      with(options[:host], options[:port]).at_least(:once).and_return(socket)
-
-    socket.stub!(:closed?).and_return(false)
-    socket.stub!(:close).and_return(true)
-
-    request_parts = ["#{options[:method]} #{options[:path]} HTTP/1.1", "Host: #{options[:host]}"]
-
-    if options[:port] == 443
-      OpenSSL::SSL::SSLSocket.should_receive(:new).
-        with(socket, instance_of(OpenSSL::SSL::SSLContext)).
-        at_least(:once).and_return(socket = mock("SSLSocket"))
-      socket.should_receive(:connect).at_least(:once).with()
-      socket.should_receive(:peer_cert).and_return(mock('peer cert', :extensions => []))
-      socket.should_receive(:write).with(/#{request_parts[0]}.*#{request_parts[1]}.*/m).and_return(100)
-    else
-      socket.should_receive(:<<).with(/#{request_parts[0]}.*#{request_parts[1]}.*/m).and_return(100)
-    end
-
-    socket.stub!(:sync=).with(true)
-
-    socket.should_receive(:gets).with("\n").
-      and_return("HTTP/1.1 #{options[:response_code]} #{options[:response_message]}\r\n",
-                 "Content-Length: #{options[:response_body].length}\r\n",
-                 "\r\n")
-    socket.stub(:readpartial) do |size, buf|
-      buf << options[:response_body]
-    end
-
-    socket.stub!(:eof?).and_return(true)
-    socket.stub!(:close).and_return(true)
-  end
-  
   def http_library
-    :http_client
+    :httpclient
   end
 
 end

data/spec/my_rack_app.rb

@@ -0,0 +1,18 @@
+require 'rack'
+
+class MyRackApp
+  def self.call(env)
+    case env.values_at('REQUEST_METHOD', 'PATH_INFO')
+      when ['GET', '/']
+        [200, {}, ["This is my root!"]]
+      when ['GET', '/greet']
+        name = env['QUERY_STRING'][/name=([^&]*)/, 1] || "World"
+        [200, {}, ["Hello, #{name}"]]
+      when ['POST', '/greet']
+        name = env["rack.input"].read[/name=([^&]*)/, 1] || "World"
+        [200, {}, ["Good to meet you, #{name}!"]]
+      else
+        [404, {}, ['']]
+    end
+  end
+end

data/spec/net_http_shared.rb

@@ -0,0 +1,125 @@
+shared_examples_for "Net::HTTP" do
+  describe "when making real requests", :net_connect => true do
+    let(:port){ WebMockServer.instance.port }
+
+    before(:each) do
+      @http = Net::HTTP.new("localhost", port)
+    end
+
+    it "should return a Net::ReadAdapter from response.body when a real request is made with a block and #read_body", :net_connect => true do
+      response = Net::HTTP.new("localhost", port).request_get('/') { |r| r.read_body { } }
+      response.body.should be_a(Net::ReadAdapter)
+    end
+
+    it "should handle requests with block passed to read_body", :net_connect => true do
+      body = ""
+      req = Net::HTTP::Get.new("/")
+      Net::HTTP.start("localhost", port) do |http|
+        http.request(req) do |res|
+          res.read_body do |str|
+            body << str
+          end
+        end
+      end
+      body.should =~ /hello world/
+    end
+
+    it "should connect only once when connected on start", :net_connect => true do
+      @http = Net::HTTP.new('localhost', port)
+      socket_id_before_request = socket_id_after_request = nil
+      @http.start {|conn|
+        socket_id_before_request = conn.instance_variable_get(:@socket).object_id
+        conn.request(Net::HTTP::Get.new("/"))
+        socket_id_after_request = conn.instance_variable_get(:@socket).object_id
+      }
+      socket_id_after_request.should_not be_nil
+      socket_id_after_request.should == socket_id_before_request
+    end
+
+    describe "without start" do
+      it "should close connection after a real request" do
+        @http.get('/') { }
+        @http.should_not be_started
+      end
+
+      it "should execute block exactly once" do
+        times = 0
+        @http.get('/') { times += 1 }
+        times.should == 1
+      end
+
+      it "should have socket open during a real request" do
+        socket_id = nil
+        @http.get('/') {
+          socket_id = @http.instance_variable_get(:@socket).object_id
+        }
+        socket_id.should_not be_nil
+      end
+
+      it "should be started during a real request" do
+        started = nil
+        @http.get('/') {
+          started = @http.started?
+        }
+        started.should == true
+        @http.started?.should == false
+      end
+    end
+
+    describe "with start" do
+      it "should close connection after a real request" do
+        @http.start {|conn| conn.get('/') { } }
+        @http.should_not be_started
+      end
+
+      it "should execute block exactly once" do
+        times = 0
+        @http.start {|conn| conn.get('/') { times += 1 }}
+        times.should == 1
+      end
+
+      it "should have socket open during a real request" do
+        socket_id = nil
+        @http.start {|conn| conn.get('/') {
+            socket_id = conn.instance_variable_get(:@socket).object_id
+          }
+        }
+        socket_id.should_not be_nil
+      end
+
+      it "should be started during a real request" do
+        started = nil
+        @http.start {|conn| conn.get('/') {
+            started = conn.started?
+          }
+        }
+        started.should == true
+        @http.started?.should == false
+      end
+    end
+
+    describe "with start without request block" do
+      it "should close connection after a real request" do
+        @http.start {|conn| conn.get('/') }
+        @http.should_not be_started
+      end
+
+      it "should have socket open during a real request" do
+        socket_id = nil
+        @http.start {|conn|
+          socket_id = conn.instance_variable_get(:@socket).object_id
+        }
+        socket_id.should_not be_nil
+      end
+
+      it "should be started during a real request" do
+        started = nil
+        @http.start {|conn|
+          started = conn.started?
+        }
+        started.should == true
+        @http.started?.should == false
+      end
+    end
+  end
+end