webmock 0.7.0

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "webmock"
+    gem.summary = %Q{Library for stubbing HTTP requests in Ruby.}
+    gem.description = %Q{WebMock allows stubbing HTTP requests and setting expectations on HTTP requests.}
+    gem.email = "bartosz.blimke@gmail.com"
+    gem.homepage = "http://github.com/bblimke/webmock"
+    gem.authors = ["Bartosz Blimke"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb'].exclude("spec/vendor")
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.test_files = FileList["test/**/*.rb"].exclude("test/test_helper.rb")
+  test.verbose = false
+  test.warning = true
+end
+
+task :spec => :check_dependencies
+
+task :test => :check_dependencies
+
+task :default => [:spec, :test]
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "webmock #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/webmock/webmock.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.7.0

data/lib/webmock.rb

@@ -0,0 +1,18 @@
+require 'singleton'
+
+require 'webmock/http_lib_adapters/net_http'
+
+require 'webmock/errors'
+require 'webmock/request_profile'
+require 'webmock/request_execution_verifier'
+require 'webmock/url'
+require 'webmock/request_stub'
+require 'webmock/utility'
+require 'webmock/config'
+require 'webmock/response'
+require 'webmock/util/hash_counter'
+require 'webmock/request_registry'
+require 'webmock/webmock'
+
+require 'webmock/adapters/rspec'
+require 'webmock/adapters/test_unit'

data/lib/webmock/adapters/rspec.rb

@@ -0,0 +1,23 @@
+if defined?(Spec::Runner) 
+  
+  require 'webmock/adapters/rspec/request_profile_matcher'
+  require 'webmock/adapters/rspec/webmock_matcher'
+  require 'webmock/adapters/rspec/matchers'
+  
+  Spec::Runner.configure { |config|
+  
+    config.include WebMock::Matchers
+  
+    config.before :each do
+      WebMock.reset_webmock
+    end
+  }
+  
+  module WebMock
+    private
+    def assertion_failure(message)
+      raise Spec::Expectations::ExpectationNotMetError.new(message)
+    end
+  end
+  
+end

data/lib/webmock/adapters/rspec/matchers.rb

@@ -0,0 +1,19 @@
+module WebMock
+  module Matchers
+    def have_been_made
+      WebMock::RequestProfileMatcher.new
+    end
+    
+    def have_not_been_made
+      WebMock::RequestProfileMatcher.new.times(0)
+    end
+    
+    def have_requested(method, url)
+      WebMock::WebMockMatcher.new(method, url)
+    end
+    
+    def have_not_requested(method, url)
+      WebMock::WebMockMatcher.new(method, url).times(0)
+    end
+  end
+end

data/lib/webmock/adapters/rspec/request_profile_matcher.rb

@@ -0,0 +1,37 @@
+module WebMock
+  class RequestProfileMatcher
+    
+    def initialize
+      @request_execution_verifier = RequestExecutionVerifier.new
+    end
+    
+    def once
+      @request_execution_verifier.expected_times_executed = 1
+      self
+    end
+    
+    def twice
+      @request_execution_verifier.expected_times_executed = 2
+      self
+    end
+    
+    def times(times)
+      @request_execution_verifier.expected_times_executed = times.to_i
+      self
+    end
+    
+    def matches?(request_profile)
+      @request_execution_verifier.request_profile = request_profile
+      @request_execution_verifier.verify
+    end
+    
+    def failure_message
+      @request_execution_verifier.failure_message
+    end
+    
+
+    def negative_failure_message
+      @request_execution_verifier.negative_failure_message
+    end
+  end
+end

data/lib/webmock/adapters/rspec/webmock_matcher.rb

@@ -0,0 +1,45 @@
+module WebMock
+  class WebMockMatcher
+
+    def initialize(method, url)
+      @request_execution_verifier = RequestExecutionVerifier.new
+      @request_execution_verifier.request_profile = RequestProfile.new(method, url)
+    end
+
+    def once
+      @request_execution_verifier.expected_times_executed = 1
+      self
+    end
+
+    def twice
+      @request_execution_verifier.expected_times_executed = 2
+      self
+    end
+
+    def with(options)
+      @request_execution_verifier.request_profile.body =
+        options[:body] if options.has_key?(:body)
+      @request_execution_verifier.request_profile.headers = 
+        options[:headers] if options.has_key?(:headers)
+      self
+    end
+
+    def times(times)
+      @request_execution_verifier.expected_times_executed = times.to_i
+      self
+    end
+
+    def matches?(webmock)
+      @request_execution_verifier.verify
+    end
+
+    def failure_message
+      @request_execution_verifier.failure_message
+    end
+
+
+    def negative_failure_message
+      @request_execution_verifier.negative_failure_message
+    end
+  end
+end

data/lib/webmock/adapters/test_unit.rb

@@ -0,0 +1,25 @@
+if defined?(Test::Unit::TestCase)
+  
+  class Test::Unit::TestCase
+    include WebMock
+    alias setup_without_webmock setup
+    def setup
+      reset_webmock
+      @original_allow_net_connect = WebMock.net_connect_allowed?
+      WebMock.disable_net_connect!
+    end
+
+    alias teardown_without_webmock teardown
+    def teardown
+      @original_allow_net_connect ? WebMock.allow_net_connect! : WebMock.disable_net_connect!
+    end
+  end
+  
+  module WebMock
+    private
+    def assertion_failure(message)
+       raise Test::Unit::AssertionFailedError.new(message)
+    end
+  end
+  
+end

data/lib/webmock/config.rb

@@ -0,0 +1,7 @@
+module WebMock
+  class Config 
+    include Singleton
+    
+    attr_accessor :allow_net_connect
+  end
+end

data/lib/webmock/errors.rb

@@ -0,0 +1,5 @@
+module WebMock
+  
+  class NetConnectNotAllowedError < StandardError; end;
+
+end

data/lib/webmock/http_lib_adapters/net_http.rb

@@ -0,0 +1,129 @@
+require 'net/http'
+require 'net/https'
+require 'stringio'
+
+
+class StubSocket #:nodoc:
+
+  def initialize(*args)
+  end
+
+  def closed?
+    @closed ||= true
+  end
+
+  def readuntil(*args)
+  end
+
+end
+
+module StubResponse
+  def read_body(*args, &block)
+    yield @body if block_given?
+    @body
+  end
+end
+
+module Net  #:nodoc: all
+
+  class BufferedIO
+    def initialize_with_webmock(io, debug_output = nil)
+      @read_timeout = 60
+      @rbuf = ''
+      @debug_output = debug_output
+
+      @io = case io
+      when Socket, OpenSSL::SSL::SSLSocket, IO
+        io
+      when String
+        if !io.include?("\0") && File.exists?(io) && !File.directory?(io)
+          File.open(io, "r")
+        else
+          StringIO.new(io)
+        end
+      end
+      raise "Unable to create local socket" unless @io
+    end
+    alias_method :initialize_without_webmock, :initialize
+    alias_method :initialize, :initialize_with_webmock
+  end
+
+  class HTTP
+    class << self
+      def socket_type_with_webmock
+        StubSocket
+      end
+      alias_method :socket_type_without_webmock, :socket_type
+      alias_method :socket_type, :socket_type_with_webmock
+    end
+
+    def request_with_webmock(request, body = nil, &block)
+      protocol = use_ssl? ? "https" : "http"
+
+      path = request.path
+      path = URI.parse(request.path).request_uri if request.path =~ /^http/
+
+      if request["authorization"] =~ /^Basic /
+        userinfo = WebMock::Utility.decode_userinfo_from_header(request["authorization"])
+        userinfo = WebMock::Utility.encode_unsafe_chars_in_userinfo(userinfo) + "@"
+      else
+        userinfo = ""
+      end
+
+      uri = "#{protocol}://#{userinfo}#{self.address}:#{self.port}#{path}"
+      method = request.method.downcase.to_sym
+
+      headers = Hash[*request.to_hash.map {|k,v| [k, v.flatten]}.flatten]
+      headers.reject! {|k,v| k =~ /[Aa]ccept/ && v = '*/*'}
+
+      request_profile = WebMock::RequestProfile.new(method, uri, body, headers)
+
+      if WebMock.registered_request?(request_profile)
+        @socket = Net::HTTP.socket_type.new
+        webmock_response = WebMock.response_for_request(request_profile)
+        build_net_http_response(webmock_response, &block)
+      elsif WebMock.net_connect_allowed?
+        WebMock::RequestRegistry.instance.requested.put(request_profile)
+        connect_without_webmock
+        request_without_webmock(request, body, &block)
+      else
+        uri = WebMock::Utility.strip_default_port_from_uri(uri)
+        message = "Real HTTP connections are disabled. Unregistered request: #{request.method} #{uri}"
+        message << " with body '#{body}'" if body
+        message << " with headers #{WebMock::Utility.normalize_headers(headers).inspect.gsub("\"","'")}" if 
+headers && !headers.empty?
+        raise WebMock::NetConnectNotAllowedError, message
+      end
+    end
+    alias_method :request_without_webmock, :request
+    alias_method :request, :request_with_webmock
+
+
+    def connect_with_webmock
+      unless @@alredy_checked_for_net_http_replacement_libs ||= false
+        WebMock::Utility.puts_warning_for_net_http_replacement_libs_if_needed
+        @@alredy_checked_for_net_http_replacement_libs = true
+      end
+      nil
+    end
+    alias_method :connect_without_webmock, :connect
+    alias_method :connect, :connect_with_webmock
+
+    def build_net_http_response(webmock_response, &block)
+      response = Net::HTTPResponse.send(:response_class, webmock_response.status.to_s).new("1.0", webmock_response.status.to_s, "")
+      response.instance_variable_set(:@body, webmock_response.body)
+      webmock_response.headers.to_a.each { |name, value| response[name] = value }
+
+      response.instance_variable_set(:@read, true)
+
+      response.extend StubResponse
+
+      webmock_response.raise_error_if_any
+
+      yield response if block_given?
+
+      response
+    end
+  end
+
+end

data/lib/webmock/request_execution_verifier.rb

@@ -0,0 +1,22 @@
+module WebMock
+  class RequestExecutionVerifier
+    
+    attr_accessor :request_profile, :expected_times_executed, :times_executed
+
+    def initialize(request_profile = nil, expected_times_executed = nil)
+      @request_profile = request_profile
+      @expected_times_executed = expected_times_executed || 1
+    end
+
+    def verify
+      @times_executed = 
+      RequestRegistry.instance.times_executed(@request_profile)
+      @times_executed == @expected_times_executed
+    end
+
+    def failure_message
+      %Q(The request #{request_profile.to_s} was expected to execute #{expected_times_executed} time#{ (expected_times_executed == 1) ? '' : 's'} but it executed #{times_executed} time#{ (times_executed == 1) ? '' : 's'})
+    end
+
+  end
+end

data/lib/webmock/request_profile.rb

@@ -0,0 +1,67 @@
+module WebMock
+
+  class RequestProfile < Struct.new(:method, :uri, :body, :headers)
+
+    def initialize(method, uri, body = nil, headers = nil)
+      super
+      self.uri = WebMock::URL.normalize_uri(self.uri) unless self.uri.is_a?(URI)
+      self.headers = Utility.normalize_headers(self.headers)
+    end
+
+    def with(options)
+      self.body = options[:body] if options.has_key?(:body)
+      self.headers = Utility.normalize_headers(options[:headers]) if options.has_key?(:headers)
+      self
+    end
+
+    #self needs to be a subset of other. Other needs to be more general.
+    def match(other)
+      match_method(other) &&
+      match_body(other) &&
+      match_headers(other) &&
+      match_url(other)
+    end
+
+    def to_s
+      string = "#{self.method.to_s.upcase} #{self.uri}"
+      string << " with body '#{body}'" if body
+      if headers && !headers.empty?
+        string << " with headers #{WebMock::Utility.normalize_headers(headers).inspect.gsub("\"","'")}"
+      end
+      string
+    end
+
+    private
+
+    def match_url(other)
+      raise "Can't match regexp request profile" if self.uri.is_a?(Regexp)
+      @uris_to_check ||= WebMock::URL.variations_of_uri_as_strings(self.uri)
+      if other.uri.is_a?(URI)
+        @uris_to_check.include?(other.uri.to_s)
+      elsif other.uri.is_a?(Regexp)
+        @uris_to_check.any? { |u| u.match(other.uri) }
+      else
+        false
+      end
+    end
+
+    def match_headers(other)
+      return false if self.headers && !self.headers.empty? && other.headers && other.headers.empty?
+      if other.headers && !other.headers.empty?
+        other.headers.each do | key, value |
+          return false unless (self.headers && self.headers.has_key?(key) && value == self.headers[key])
+        end
+      end
+      return true
+    end
+
+    def match_body(other)
+      other.body == self.body || other.body.nil?
+    end
+
+    def match_method(other)
+      other.method == self.method || other.method == :any
+    end
+  end
+
+end