webmock 0.7.0

data/lib/webmock/request_registry.rb

@@ -0,0 +1,47 @@
+module WebMock
+
+  class RequestRegistry
+    include Singleton
+
+    attr_accessor :request_stubs, :requested
+
+    def initialize
+      reset_webmock
+    end
+
+    def reset_webmock
+      self.request_stubs = []
+      self.requested = HashCounter.new
+    end
+
+    def register_request_stub(stub)
+      request_stubs.insert(0, stub)
+      stub
+    end
+
+    def registered_request?(request_profile)
+      stub_for(request_profile)
+    end
+
+    def response_for_request(request_profile)
+      stub = stub_for(request_profile)
+      self.requested.put(request_profile)
+      stub ? stub.response : nil
+    end
+    
+    def times_executed(request_profile)
+      self.requested.hash.select { |executed_request_profile, times_executed|
+        executed_request_profile.match(request_profile)
+      }.inject(0) {|sum, (_, times_executed)| sum + times_executed }
+    end
+
+    private
+
+    def stub_for(request_profile)
+      request_stubs.detect { |registered_request_stub|
+        request_profile.match(registered_request_stub.request_profile)
+      }
+    end
+
+  end
+end

data/lib/webmock/request_stub.rb

@@ -0,0 +1,26 @@
+module WebMock
+  class RequestStub
+    attr_accessor :request_profile, :response
+    
+    def initialize(method, url)
+      @request_profile = RequestProfile.new(method, url)
+      @response = WebMock::Response.new
+      self
+    end
+
+    def with(params)
+      @request_profile.body = params[:body]
+      @request_profile.headers = Utility.normalize_headers(params[:headers])
+      self
+    end
+
+    def to_return(response_hash)
+      @response = WebMock::Response.new(response_hash)
+    end
+    
+    def to_raise(exception)
+      @response = WebMock::Response.new({:exception => exception})
+    end
+    
+  end
+end

data/lib/webmock/response.rb

@@ -0,0 +1,31 @@
+module WebMock
+  class Response
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def headers
+      Utility.normalize_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
+        @options[:body]
+      end
+    end
+    
+    def status
+      @options.has_key?(:status) ? @options[:status] : 200
+    end
+
+    def raise_error_if_any
+      raise @options[:exception].new('Exception from WebMock') if @options.has_key?(:exception)
+    end
+
+  end
+end

data/lib/webmock/url.rb

@@ -0,0 +1,46 @@
+module WebMock
+
+  class URL
+
+    def self.normalize_uri(uri)
+      return uri if uri.is_a?(Regexp)
+      normalized_uri =
+      case uri
+      when URI then uri
+      when String
+        uri = 'http://' + uri unless uri.match('^https?://')
+        URI.parse(uri)
+      end
+      normalized_uri.query = sort_query_params(normalized_uri.query)
+      normalized_uri.normalize
+    end
+
+    def self.variations_of_uri_as_strings(uri_object)
+      normalized_uri = normalize_uri(uri_object.dup)
+      normalized_uri_string = normalized_uri.to_s
+
+      variations = [normalized_uri_string]
+
+      # if the port is implied in the original, add a copy with an explicit port
+      if normalized_uri.default_port == normalized_uri.port
+        variations << normalized_uri_string.sub(
+          /#{Regexp.escape(normalized_uri.request_uri)}$/,
+          ":#{normalized_uri.port}#{normalized_uri.request_uri}")
+      end
+
+      variations
+    end
+
+    private
+
+    def self.sort_query_params(query)
+      if query.nil? || query.empty?
+        nil
+      else
+        query.split('&').sort.join('&')
+      end
+    end
+
+  end
+
+end

data/lib/webmock/util/hash_counter.rb

@@ -0,0 +1,12 @@
+class HashCounter
+    attr_accessor :hash
+    def initialize
+        self.hash = {}
+    end
+    def put key, num=1
+        hash[key] = (hash[key] || 0) + num
+    end
+    def get key
+        hash[key] || 0
+    end
+end

data/lib/webmock/utility.rb

@@ -0,0 +1,65 @@
+#This file is taken from FakeWeb (fakeweb.rubyforge.org/) and adopted
+
+module WebMock
+  module Utility #:nodoc:
+
+    def self.decode_userinfo_from_header(header)
+      header.sub(/^Basic /, "").unpack("m").first
+    end
+
+    def self.encode_unsafe_chars_in_userinfo(userinfo)
+      unsafe_in_userinfo = /[^#{URI::REGEXP::PATTERN::UNRESERVED};&=+$,]|^(#{URI::REGEXP::PATTERN::ESCAPED})/
+      userinfo.split(":").map { |part| URI.escape(part, unsafe_in_userinfo) }.join(":")
+    end
+
+    def self.strip_default_port_from_uri(uri)
+      case uri
+      when %r{^http://}  then uri.sub(%r{:80(/|$)}, '\1')
+      when %r{^https://} then uri.sub(%r{:443(/|$)}, '\1')
+      else uri
+      end
+    end
+
+    def self.puts_warning_for_net_http_around_advice_libs_if_needed
+      libs = {"Samuel" => defined?(Samuel)}
+      warnings = libs.select { |_, loaded| loaded }.map do |name, _|
+        <<-TEXT.gsub(/ {10}/, '')
+          \e[1mWarning: WebMock was loaded after #{name}\e[0m
+          * #{name}'s code is being ignored when a request is handled by WebMock,
+            because both libraries work by patching Net::HTTP.
+          * To fix this, just reorder your requires so that WebMock is before #{name}.
+        TEXT
+      end
+      $stderr.puts "\n" + warnings.join("\n") + "\n" if warnings.any?
+    end
+
+    def self.record_loaded_net_http_replacement_libs
+      libs = {"RightHttpConnection" => defined?(RightHttpConnection)}
+      @loaded_net_http_replacement_libs = libs.map { |name, loaded| name if loaded }.compact
+    end
+
+    def self.puts_warning_for_net_http_replacement_libs_if_needed
+      libs = {"RightHttpConnection" => defined?(RightHttpConnection)}
+      warnings = libs.select { |_, loaded| loaded }.
+                    reject { |name, _| @loaded_net_http_replacement_libs.include?(name) }.
+                    map do |name, _|
+        <<-TEXT.gsub(/ {10}/, '')
+          \e[1mWarning: #{name} was loaded after WebMock\e[0m
+          * WebMock's code is being ignored, because #{name} replaces parts of
+            Net::HTTP without deferring to other libraries. This will break Net::HTTP requests.
+          * To fix this, just reorder your requires so that #{name} is before WebMock.
+        TEXT
+      end
+      $stderr.puts "\n" + warnings.join("\n") + "\n" if warnings.any?
+    end
+
+    def self.normalize_headers(headers)
+      return nil unless headers
+      array = headers.map { |name, value|
+        [name.to_s.split(/_|-/).map { |segment| segment.capitalize }.join("-"), value.to_s]
+      }
+      Hash[*array.flatten]
+    end
+
+  end
+end

data/lib/webmock/webmock.rb

@@ -0,0 +1,58 @@
+WebMock::Utility.record_loaded_net_http_replacement_libs
+WebMock::Utility.puts_warning_for_net_http_around_advice_libs_if_needed
+
+
+module WebMock
+
+  def stub_request(method, url)
+    RequestRegistry.instance.register_request_stub(RequestStub.new(method, url))
+  end
+  
+  alias_method :stub_http_request, :stub_request
+
+  def request(method, url)
+    RequestProfile.new(method, url)
+  end
+
+  def assert_requested(method, url, options = {})
+    expected_times_executed = options.delete(:times) || 1
+    request = RequestProfile.new(method, url, options[:body], options[:headers])
+    verifier = RequestExecutionVerifier.new(request, expected_times_executed)
+    assertion_failure(verifier.failure_message) unless verifier.verify
+  end
+
+  def assert_not_requested(method, url, options = {})
+    assert_requested(method, url, options.update(:times => 0))
+  end
+
+  def self.allow_net_connect!
+    Config.instance.allow_net_connect = true
+  end
+
+  def self.disable_net_connect!
+    Config.instance.allow_net_connect = false
+  end
+
+  def self.net_connect_allowed?
+    Config.instance.allow_net_connect
+  end
+
+  def self.registered_request?(request_profile)
+    RequestRegistry.instance.registered_request?(request_profile)
+  end
+
+  def self.response_for_request(request_profile, &block)
+    RequestRegistry.instance.response_for_request(request_profile, &block)
+  end
+
+  def reset_webmock
+    WebMock::RequestRegistry.instance.reset_webmock
+  end
+  
+  private
+  
+  def assertion_failure(message)
+    raise message
+  end
+
+end

data/spec/net_http_spec.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'webmock_spec'
+require 'ostruct'
+
+include WebMock
+
+def http_request(method, url, options = {})
+  url = URI.parse(url)
+  response = nil
+  clazz = Net::HTTP.const_get("#{method.to_s.capitalize}")
+  req = clazz.new(url.path, options[:headers])
+  req.basic_auth url.user, url.password if url.user
+  http = Net::HTTP.new(url.host, url.port)
+  http.use_ssl = true if url.scheme == "https"
+  response = http.start {|http|
+    http.request(req, options[:body])
+  }
+  OpenStruct.new({
+    :body => response.body,
+    :headers => response,
+    :status => response.code })
+end
+
+
+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
+  end
+end

data/spec/other_net_http_libs_spec.rb

@@ -0,0 +1,37 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "loading other Net::HTTP based libraries" do
+
+  def capture_output_from_requiring(libs, additional_code = "")
+    requires = libs.map { |lib| "require '#{lib}'" }.join("; ")
+    webmock_dir = "#{File.dirname(__FILE__)}/../lib"
+    vendor_dirs = Dir["#{File.dirname(__FILE__)}/vendor/*/lib"]
+    load_path_opts = vendor_dirs.unshift(webmock_dir).map { |dir| "-I#{dir}" }.join(" ")
+
+    # TODO: use the same Ruby executable that this test was invoked with
+    `ruby #{load_path_opts} -e "#{requires}; #{additional_code}" 2>&1`
+  end
+
+  it "should requiring samuel before webmock prints warning" do
+    output = capture_output_from_requiring %w(samuel webmock)
+    output.should match(%r(Warning: WebMock was loaded after Samuel))
+  end
+
+  it "should requiring samuel after webmock does not print warning" do
+    output = capture_output_from_requiring %w(webmock samuel)
+    output.should be_empty
+  end
+
+  it "should requiring right http connection before webmock and then connecting does not print warning" do
+    additional_code = "Net::HTTP.start('example.com')"
+    output = capture_output_from_requiring %w(right_http_connection webmock), additional_code
+    output.should be_empty
+  end
+
+  it "should requiring right http connection after webmock and then connecting prints warning" do
+    additional_code = "Net::HTTP.start('example.com')"
+    output = capture_output_from_requiring %w(webmock right_http_connection), additional_code
+    output.should match(%r(Warning: RightHttpConnection was loaded after WebMock))
+  end
+
+end

data/spec/request_execution_verifier_spec.rb

@@ -0,0 +1,51 @@
+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")
+    @verifier.request_profile = @request_profile
+  end
+
+
+  describe "failure message" 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"
+    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"
+    end
+
+  end
+
+  describe "verify" do
+
+    it "should succeed if request was executed expected number of times" do
+      RequestRegistry.instance.
+        should_receive(:times_executed).with(@request_profile).and_return(10)
+      @verifier.expected_times_executed = 10
+      @verifier.verify.should be_true
+    end
+
+    it "should fail if request was not executed expected number of times" do
+      RequestRegistry.instance.
+        should_receive(:times_executed).with(@request_profile).and_return(10)
+      @verifier.expected_times_executed = 5
+      @verifier.verify.should be_false
+    end
+
+  end
+
+  def verify
+    @times_executed =
+    RequestRegistry.instance.times_executed(@request_profile)
+    @times_executed == @expected_times_executed
+  end
+
+end

data/spec/request_profile_spec.rb

@@ -0,0 +1,166 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+include WebMock
+
+describe RequestProfile do
+
+  describe "initialization" do
+
+    it "should have assigned normalized uri" do
+      URL.should_receive(:normalize_uri).and_return("www.google.kom")
+      profile = RequestProfile.new(:get, "www.google.com")
+      profile.uri.should == "www.google.kom"
+    end
+
+    it "should have assigned uri without normalization if uri is URI" do
+      URL.should_not_receive(:normalize_uri)
+      uri = URI.parse("www.google.com")
+      profile = RequestProfile.new(:get, uri)
+      profile.uri.should == uri
+    end
+
+    it "should have assigned normalized headers" do
+      Utility.should_receive(:normalize_headers).with('A' => 'a').and_return('B' => 'b')
+      RequestProfile.new(:get, "www.google.com", nil, 'A' => 'a').headers.should == {'B' => 'b'}
+    end
+
+    it "should have assigned body" do
+      RequestProfile.new(:get, "www.google.com", "abc").body.should == "abc"
+    end
+
+  end
+
+  it "should report string" do
+    RequestProfile.new(:get, "www.google.com", "abc", {'A' => 'a', 'B' => 'b'}).to_s.should ==
+    "GET http://www.google.com/ with body 'abc' with headers {'A'=>'a', 'B'=>'b'}"
+  end
+
+
+  describe "with" do
+    before(:each) do
+      @request_profile = RequestProfile.new(:get, "www.google.com")
+    end
+
+    it "should assign body to request profile" do
+      @request_profile.with(:body => "abc")
+      @request_profile.body.should == "abc"
+    end
+
+    it "should assign normalized headers to request profile" do
+      Utility.should_receive(:normalize_headers).with('A' => 'a').and_return('B' => 'b')
+      @request_profile.with(:headers => {'A' => 'a'})
+      @request_profile.headers.should == {'B' => 'b'}
+    end
+
+  end
+
+  describe "when matching" do
+
+    it "should match if url matches and method matches" do
+      RequestProfile.new(:get, "www.google.com").
+        should match(RequestProfile.new(:get, "www.google.com"))
+    end
+
+    it "should match if url matches and method is any" do
+      RequestProfile.new(:get, "www.google.com").
+        should match(RequestProfile.new(:any, "www.google.com"))
+    end
+
+    it "should not match if other request profile has different method" do
+      RequestProfile.new(:get, "www.google.com").
+        should_not match(RequestProfile.new(:post, "www.google.com"))
+    end
+
+    it "should match if uri matches other uri" do
+      RequestProfile.new(:get, "www.google.com").
+        should match(RequestProfile.new(:get, "www.google.com"))
+    end
+
+    it "should match if uri matches other regex uri" do
+      RequestProfile.new(:get, "www.google.com").
+        should match(RequestProfile.new(:get, /.*google.*/))
+    end
+
+    it "should match for uris with same parameters" do
+      RequestProfile.new(:get, "www.google.com?a=1&b=2").
+        should match(RequestProfile.new(:get, "www.google.com?a=1&b=2"))
+    end
+
+    it "should not match for uris with different parameters" do
+      RequestProfile.new(:get, "www.google.com?a=2&b=1").
+        should_not match(RequestProfile.new(:get, "www.google.com?a=1&b=2"))
+    end
+
+    it "should match for parameters in different order" do
+      RequestProfile.new(:get, "www.google.com?a=1&b=2").
+        should match(RequestProfile.new(:get, "www.google.com?b=2&a=1"))
+    end
+
+    it "should match for same bodies" do
+      RequestProfile.new(:get, "www.google.com", "abc").
+        should match(RequestProfile.new(:get, "www.google.com", "abc"))
+    end
+
+    it "should not match for different bodies" do
+      RequestProfile.new(:get, "www.google.com", "abc").
+        should_not match(RequestProfile.new(:get, "www.google.com", "def"))
+    end
+
+    it "should match is other has nil body" do
+      RequestProfile.new(:get, "www.google.com", "abc").
+        should match(RequestProfile.new(:get, "www.google.com", nil))
+    end
+
+    it "should not match if other has empty body" do
+      RequestProfile.new(:get, "www.google.com", "abc").
+        should_not match(RequestProfile.new(:get, "www.google.com", ""))
+    end
+
+    it "should match for same headers" do
+      RequestProfile.new(:get, "www.google.com", nil, 'Content-Type' => 'image/jpeg').
+        should match(RequestProfile.new(:get, "www.google.com", nil, 'Content-Type' => 'image/jpeg'))
+    end
+
+    it "should not match for different values of the same header" do
+      RequestProfile.new(:get, "www.google.com", nil, 'Content-Type' => 'image/jpeg').
+        should_not match(RequestProfile.new(:get, "www.google.com", nil, 'Content-Type' => 'image/png'))
+    end
+
+    it "should match if request has more headers than other" do
+      RequestProfile.new(:get, "www.google.com", nil, 'Content-Type' => 'image/jpeg', 'Content-Length' => '8888').
+        should match(RequestProfile.new(:get, "www.google.com", nil, 'Content-Type' => 'image/jpeg'))
+    end
+
+    it "should not match if request has less headers that the other and all match" do
+      RequestProfile.new(:get, "www.google.com", nil, 'Content-Type' => 'image/jpeg').
+        should_not match(RequestProfile.new(:get, "www.google.com", nil, 'Content-Type' => 'image/jpeg', 'Content-Length' => '8888'))
+    end
+
+    it "should match even is header keys or values are in different format" do
+      RequestProfile.new(:get, "www.google.com", nil, :ContentLength => 8888, 'content_type' => 'image/png').
+        should match(RequestProfile.new(:get, "www.google.com", nil, 'ContentLength' => '8888', 'Content-type' => 'image/png'))
+    end
+
+    it "should match is other has nil headers" do
+      RequestProfile.new(:get, "www.google.com", nil, 'A' => 'a').
+        should match(RequestProfile.new(:get, "www.google.com", nil, nil))
+    end
+
+    it "should not match if other has empty headers" do
+      RequestProfile.new(:get, "www.google.com", nil, 'A' => 'a').
+        should_not match(RequestProfile.new(:get, "www.google.com", nil, {}))
+    end
+
+    it "should not match if profile has no headers but other has headers" do
+      RequestProfile.new(:get, "www.google.com", nil, nil).
+        should_not match(RequestProfile.new(:get, "www.google.com", nil, {'A'=>'a'}))
+    end
+
+    it "should not match if profile has empty headers but other has headers" do
+      RequestProfile.new(:get, "www.google.com", nil, {}).
+        should_not match(RequestProfile.new(:get, "www.google.com", nil, {'A'=>'a'}))
+    end
+
+  end
+
+end