webmock 0.7.3 → 0.8.0

data/lib/webmock/request.rb

@@ -0,0 +1,29 @@
+module WebMock
+
+  class Request
+    attr_accessor :method, :uri, :body, :headers
+
+    def initialize(method, uri, options = {})
+      self.method = method
+      self.uri = uri.is_a?(Addressable::URI) ? uri : WebMock::Util::URI.normalize_uri(uri)
+      assign_options(options)
+    end
+
+    def to_s
+      string = "#{self.method.to_s.upcase} #{WebMock::Util::URI.strip_default_port_from_uri_string(self.uri.to_s)}"
+      string << " with body '#{body.to_s}'" if body && body.to_s != ''
+      if headers && !headers.empty?
+        string << " with headers #{WebMock::Util::Headers.normalize_headers(headers).inspect.gsub("\"","'")}"
+      end
+      string
+    end
+
+    private
+
+    def assign_options(options)
+      self.body = options[:body] if options.has_key?(:body)
+      self.headers = WebMock::Util::Headers.normalize_headers(options[:headers]) if options.has_key?(:headers)
+    end
+
+  end
+end

data/lib/webmock/request_profile.rb

@@ -1,28 +1,41 @@
 module WebMock
 
-  class RequestProfile < Struct.new(:method, :uri, :body, :headers)
-
-    def initialize(method, uri, body = nil, headers = nil)
-      super
-      self.uri = WebMock::Util::URI.normalize_uri(self.uri) unless self.uri.is_a?(Addressable::URI)
-      self.headers = WebMock::Util::Headers.normalize_headers(self.headers)
-    end
+  class RequestProfile < Request
 
     def with(options)
-      self.body = options[:body] if options.has_key?(:body)
-      self.headers = WebMock::Util::Headers.normalize_headers(options[:headers]) if options.has_key?(:headers)
+      assign_options(options)
       self
     end
+    
+    def body=(body)
+      @body = Body.new(body)
+    end
+
+    class Body
+
+      attr_reader :data
+
+      def initialize(data)
+        @data = data
+      end
 
-    def to_s
-      string = "#{self.method.to_s.upcase} #{WebMock::Util::URI.strip_default_port_from_uri_string(self.uri.to_s)}"
-      string << " with body '#{body}'" if body
-      if headers && !headers.empty?
-        string << " with headers #{WebMock::Util::Headers.normalize_headers(headers).inspect.gsub("\"","'")}"
+      def ==(other)
+        other = Body.new(other) unless other.is_a?(Body)
+        other.is_a?(Body) &&
+          (other.is_empty? && self.is_empty? || other.data == self.data)        
       end
-      string
+
+      def is_empty?
+        @data.nil? || @data == ""
+      end
+
+      def to_s
+        @data
+      end
+
     end
 
   end
 
+
 end

data/lib/webmock/request_registry.rb

@@ -25,9 +25,9 @@ module WebMock
 
     def response_for_request(request_signature)
       stub = request_stub_for(request_signature)
-      stub ? stub.response : nil
+      stub ? evaluate_response_for_request(stub.response, request_signature) : nil
     end
-    
+
     def times_executed(request_profile)
       self.requested_signatures.hash.select { |request_signature, times_executed|
         request_signature.match(request_profile)
@@ -42,5 +42,15 @@ module WebMock
       }
     end
 
+    def evaluate_response_for_request(response, request_signature)
+      evaluated_response = response.dup
+      [:body, :headers].each do |attribute|
+        if response.options[attribute].is_a?(Proc)
+          evaluated_response.options[attribute] = response.options[attribute].call(request_signature)
+        end
+      end
+      evaluated_response
+    end
+
   end
 end

data/lib/webmock/request_signature.rb

@@ -1,8 +1,9 @@
 module WebMock
 
-  class RequestSignature < RequestProfile
+  class RequestSignature < Request
 
     def match(request_profile)
+      raise ArgumentError unless request_profile.is_a?(RequestProfile)
       match_method(request_profile) &&
         match_body(request_profile) &&
         match_headers(request_profile) &&

data/lib/webmock/request_stub.rb

@@ -9,8 +9,7 @@ module WebMock
     end
 
     def with(params)
-      @request_profile.body = params[:body]
-      @request_profile.headers = Util::Headers.normalize_headers(params[:headers])
+      @request_profile.with(params)
       self
     end
 

data/lib/webmock/response.rb

@@ -1,24 +1,26 @@
 module WebMock
   class Response
+    attr_accessor :options
 
     def initialize(options = {})
       @options = options
+      @options[:headers] = Util::Headers.normalize_headers(@options[:headers]) unless @options[:headers].is_a?(Proc)
     end
 
     def headers
-      Util::Headers.normalize_headers(@options[:headers])
+      @options[:headers]
     end
 
     def body
       return '' unless @options.has_key?(:body)
-
-      if !@options[:body].include?("\0") && File.exists?(@options[:body]) && !File.directory?(@options[:body])
-        File.read(@options[:body])
-      else
+      case @options[:body]
+      when IO
+        @options[:body].read
+      when String
         @options[:body]
       end
     end
-    
+
     def status
       @options.has_key?(:status) ? @options[:status] : 200
     end
@@ -27,5 +29,15 @@ module WebMock
       raise @options[:exception].new('Exception from WebMock') if @options.has_key?(:exception)
     end
 
+    def dup
+      dup_response = super
+      dup_response.options = options.dup
+      dup_response
+    end
+
+    def ==(other)
+      options == other.options
+    end
+
   end
 end

data/lib/webmock/util/uri.rb

@@ -18,7 +18,7 @@ module WebMock
         normalized_uri = Addressable::URI.heuristic_parse(uri)
         normalized_uri.query_values = normalized_uri.query_values if normalized_uri.query_values
         normalized_uri.normalize!
-        normalized_uri.port = normalized_uri.inferred_port unless normalized_uri.port && normalized_uri.inferred_port
+        normalized_uri.port = normalized_uri.inferred_port unless normalized_uri.port
         normalized_uri
       end
 
@@ -34,7 +34,7 @@ module WebMock
           uris = uris_with_scheme_and_without(uris)
         end
 
-        if normalized_uri.path == '/' && normalized_uri.query == nil
+        if normalized_uri.path == '/'
           uris = uris_with_trailing_slash_and_without(uris)
         end
 

data/lib/webmock/webmock.rb

@@ -13,13 +13,13 @@ module WebMock
 
   def assert_requested(method, uri, options = {})
     expected_times_executed = options.delete(:times) || 1
-    request = RequestProfile.new(method, uri, options[:body], options[:headers])
+    request = RequestProfile.new(method, uri, options)
     verifier = RequestExecutionVerifier.new(request, expected_times_executed)
     assertion_failure(verifier.failure_message) unless verifier.matches?
   end
 
   def assert_not_requested(method, uri, options = {})
-    request = RequestProfile.new(method, uri, options[:body], options[:headers])
+    request = RequestProfile.new(method, uri, options)
     verifier = RequestExecutionVerifier.new(request, options.delete(:times))
     assertion_failure(verifier.negative_failure_message) unless verifier.does_not_match?
   end

data/spec/httpclient_spec.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'webmock_spec'
+require 'ostruct'
+
+require 'httpclient'
+require 'httpclient_spec_helper'
+
+describe "Webmock with HTTPClient" do
+  include HTTPClientSpecHelper
+
+  before(:each) do
+    HTTPClientSpecHelper.async_mode = false
+  end
+
+  it_should_behave_like "WebMock"
+
+  it "should yield block on response if block provided" do
+    stub_http_request(:get, "www.example.com").to_return(:body => "abc")
+    response_body = ""
+    http_request(:get, "http://www.example.com/") do |body|
+      response_body = body
+    end
+    response_body.should == "abc"
+  end
+
+  describe "async requests" do
+
+    before(:each) do
+      HTTPClientSpecHelper.async_mode = true
+    end
+
+    it_should_behave_like "WebMock"
+
+  end
+
+end

data/spec/httpclient_spec_helper.rb

@@ -0,0 +1,57 @@
+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
+    c.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    c.set_basic_auth(nil, uri.user, uri.password) if uri.user
+    params = [method, "#{uri.omit(:userinfo, :query).normalize.to_s}",
+      uri.query_values, options[:body], options[:headers] || {}]
+    if HTTPClientSpecHelper.async_mode
+      connection = c.request_async(*params)
+      connection.join
+      response = connection.pop
+    else
+      response = c.request(*params, &block)
+    end
+    OpenStruct.new({
+      :body => HTTPClientSpecHelper.async_mode ? response.content.read : response.content,
+      :headers => Hash[response.header.all],
+      :status => response.code.to_s })
+  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").once.and_return("HTTP/1.1 #{options[:response_code]} #{options[:response_message]}\nContent-Length: #{options[:response_body].length}\n\n#{options[:response_body]}")
+
+    socket.stub!(:eof?).and_return(true)
+    socket.stub!(:close).and_return(true)
+
+    socket.should_receive(:readpartial).any_number_of_times.and_raise(EOFError)
+  end
+
+end

data/spec/net_http_spec.rb

@@ -1,34 +1,25 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 require 'webmock_spec'
 require 'ostruct'
+require 'net_http_spec_helper'
 
-def http_request(method, uri, options = {})
-  begin
-    uri = URI.parse(uri)
-  rescue
-    uri = Addressable::URI.heuristic_parse(uri)
-  end
-  response = nil
-  clazz = Net::HTTP.const_get("#{method.to_s.capitalize}")
-  req = clazz.new("#{uri.path}#{uri.query ? '?' : ''}#{uri.query}", options[:headers])
-  req.basic_auth uri.user, uri.password if uri.user
-  http = Net::HTTP.new(uri.host, uri.port)
-  http.use_ssl = true if uri.scheme == "https"
-  response = http.start {|http|
-    http.request(req, options[:body])
-  }
-  OpenStruct.new({
-    :body => response.body,
-    :headers => response,
-    :status => response.code })
-end
+include NetHTTPSpecHelper
 
 describe "Webmock with Net:HTTP" do
-  
+
   it_should_behave_like "WebMock"
-  
+
   it "should work with block provided" do
-    stub_http_request(:get, "www.google.com").to_return(:body => "abc"*100000)
-    Net::HTTP.start("www.google.com") { |query| query.get("/") }.body.should == "abc"*100000
+    stub_http_request(:get, "www.example.com").to_return(:body => "abc"*100000)
+    Net::HTTP.start("www.example.com") { |query| query.get("/") }.body.should == "abc"*100000
+  end
+  
+  it "should yield block on response" do
+    stub_http_request(:get, "www.example.com").to_return(:body => "abc")
+    response_body = ""
+    http_request(:get, "http://www.example.com/") do |response|
+      response_body = response.body
+    end
+    response_body.should == "abc"
   end
 end

data/spec/net_http_spec_helper.rb

@@ -0,0 +1,53 @@
+module NetHTTPSpecHelper
+  def http_request(method, uri, options = {}, &block)
+    begin
+      uri = URI.parse(uri)
+    rescue
+      uri = Addressable::URI.heuristic_parse(uri)
+    end
+    response = nil
+    clazz = Net::HTTP.const_get("#{method.to_s.capitalize}")
+    req = clazz.new("#{uri.path}#{uri.query ? '?' : ''}#{uri.query}", options[:headers])
+
+    req.basic_auth uri.user, uri.password if uri.user
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = true if uri.scheme == "https"
+    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    response = http.start {|http|
+      http.request(req, options[:body], &block)
+    }
+    OpenStruct.new({
+      :body => response.body,
+      :headers => response,
+      :status => response.code })
+  end
+
+  # Sets several expectations that a real HTTP request makes it
+  # past WebMock to the socket layer. You can use this when you need to check
+  # that a request isn't handled by WebMock
+  #This solution is copied from FakeWeb project
+  def setup_expectations_for_real_request(options = {})
+    # Socket handling
+    if options[:port] == 443
+      socket = mock("SSLSocket")
+      OpenSSL::SSL::SSLSocket.should_receive(:===).with(socket).at_least(:once).and_return(true)
+      OpenSSL::SSL::SSLSocket.should_receive(:new).with(socket, instance_of(OpenSSL::SSL::SSLContext)).at_least(:once).and_return(socket)
+      socket.stub!(:sync_close=).and_return(true)
+      socket.should_receive(:connect).at_least(:once).with()
+    else
+      socket = mock("TCPSocket")
+      Socket.should_receive(:===).with(socket).at_least(:once).and_return(true)
+    end
+
+    TCPSocket.should_receive(:open).with(options[:host], options[:port]).at_least(:once).and_return(socket)
+    socket.stub!(:closed?).and_return(false)
+    socket.stub!(:close).and_return(true)
+
+    # Request/response handling
+    request_parts = ["#{options[:method]} #{options[:path]} HTTP/1.1", "Host: #{options[:host]}"]
+    socket.should_receive(:write).with(/#{request_parts[0]}.*#{request_parts[1]}.*/m).and_return(100)
+
+    socket.should_receive(:sysread).once.and_return("HTTP/1.1 #{options[:response_code]} #{options[:response_message]}\nContent-Length: #{options[:response_body].length}\n\n#{options[:response_body]}")
+    socket.should_receive(:sysread).any_number_of_times.and_raise(EOFError)
+  end
+end

data/spec/request_execution_verifier_spec.rb

@@ -3,7 +3,7 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 describe RequestExecutionVerifier do
   before(:each) do
     @verifier = RequestExecutionVerifier.new
-    @request_profile = mock(RequestProfile, :to_s => "www.google.com")
+    @request_profile = mock(RequestProfile, :to_s => "www.example.com")
     @verifier.request_profile = @request_profile
   end
 
@@ -13,13 +13,13 @@ describe RequestExecutionVerifier do
     it "should report failure message" do
       @verifier.times_executed = 0
       @verifier.expected_times_executed = 2
-      @verifier.failure_message.should == "The request www.google.com was expected to execute 2 times but it executed 0 times"
+      @verifier.failure_message.should == "The request www.example.com was expected to execute 2 times but it executed 0 times"
     end
 
     it "should report failure message correctly when executed times is one" do
       @verifier.times_executed = 1
       @verifier.expected_times_executed = 1
-      @verifier.failure_message.should == "The request www.google.com was expected to execute 1 time but it executed 1 time"
+      @verifier.failure_message.should == "The request www.example.com was expected to execute 1 time but it executed 1 time"
     end
 
   end
@@ -29,12 +29,12 @@ describe RequestExecutionVerifier do
     it "should report failure message if it executed number of times specified" do
       @verifier.times_executed = 2
       @verifier.expected_times_executed = 2
-      @verifier.negative_failure_message.should == "The request www.google.com was not expected to execute 2 times but it executed 2 times"
+      @verifier.negative_failure_message.should == "The request www.example.com was not expected to execute 2 times but it executed 2 times"
     end
 
     it "should report failure message when not expected request but it executed" do
       @verifier.times_executed = 1
-      @verifier.negative_failure_message.should == "The request www.google.com was expected to execute 0 times but it executed 1 time"
+      @verifier.negative_failure_message.should == "The request www.example.com was expected to execute 0 times but it executed 1 time"
     end
 
   end