webmock 1.6.2 → 1.6.4

data/Rakefile

@@ -1,31 +1,20 @@
-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_dependency "addressable", ">= 2.2.2"
-    gem.add_dependency "crack", ">=0.1.7"
-    gem.add_development_dependency "rspec", ">= 2.0.0"
-    gem.add_development_dependency "httpclient", ">= 2.1.5.2"
-    gem.add_development_dependency "patron", ">= 0.4.9" unless RUBY_PLATFORM =~ /java/
-    gem.add_development_dependency "em-http-request", ">= 0.2.14" unless RUBY_PLATFORM =~ /java/
-    gem.add_development_dependency "curb", ">= 0.7.8" unless RUBY_PLATFORM =~ /java/
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+namespace :spec do
+  desc 'Run specs against 1.8.6, REE, 1.8.7, 1.9.2 and jRuby'
+  task :rubies do
+    # JCF: I'd love to be able to use RVM's `rvm {rubies} specs` command but
+    # the require tests in spec/other_net_http_libs_spec.rb break when doing
+    # so.
+    spec_files = Dir[File.dirname(__FILE__) + '/spec/**/*_spec.rb'].join(' ')
+    sh "rvm 1.8.6@webmock,ree@webmock,1.8.7@webmock,1.9.2@webmock,jruby@webmock exec rspec #{spec_files}"
   end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
 end
 
 require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new do |t|
-  t.rspec_opts = ["-c", "-f progress", "-r ./spec/spec_helper.rb"] 
+  t.rspec_opts = ["-c", "-f progress", "-r ./spec/spec_helper.rb"]
   t.pattern = 'spec/**/*_spec.rb'
 end
 
@@ -36,18 +25,15 @@ Rake::TestTask.new(:test) do |test|
   test.warning = false
 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') : ""
+  $:.push File.expand_path('../lib', __FILE__)
+  require 'webmock/version'
 
   rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "webmock #{version}"
+  rdoc.title = "webmock #{WebMock::VERSION}"
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/webmock/webmock.rb')
 end

data/lib/webmock.rb

@@ -4,6 +4,7 @@ require 'addressable/uri'
 require 'crack'
 
 require 'webmock/deprecation'
+require 'webmock/version'
 
 require 'webmock/http_lib_adapters/net_http'
 require 'webmock/http_lib_adapters/httpclient'
@@ -33,4 +34,4 @@ require 'webmock/callback_registry'
 require 'webmock/request_registry'
 require 'webmock/stub_registry'
 require 'webmock/api'
-require 'webmock/webmock'
+require 'webmock/webmock'

data/lib/webmock/http_lib_adapters/curb.rb

@@ -65,7 +65,28 @@ if defined?(Curl)
           @header_str << webmock_response.headers.map do |k,v| 
             "#{k}: #{v.is_a?(Array) ? v.join(", ") : v}"
           end.join("\r\n")
+
+          location = webmock_response.headers['Location']
+          if self.follow_location? && location
+            @last_effective_url = location
+            webmock_follow_location(location)
+          end
+
+          @content_type = webmock_response.headers["Content-Type"]
+        end
+
+        @last_effective_url ||= self.url
+      end
+
+      def webmock_follow_location(location)
+        first_url = self.url
+        self.url = location
+
+        curb_or_webmock do
+          send( "http_#{@webmock_method}_without_webmock" )
         end
+
+        self.url = first_url
       end
 
       def invoke_curb_callbacks
@@ -194,6 +215,18 @@ if defined?(Curl)
       alias :header_str_without_webmock :header_str
       alias :header_str :header_str_with_webmock
 
+      def last_effective_url_with_webmock
+        @last_effective_url || last_effective_url_without_webmock
+      end
+      alias :last_effective_url_without_webmock :last_effective_url
+      alias :last_effective_url :last_effective_url_with_webmock
+
+      def content_type_with_webmock
+        @content_type || content_type_without_webmock
+      end
+      alias :content_type_without_webmock :content_type
+      alias :content_type :content_type_with_webmock
+
       %w[ success failure header body complete progress ].each do |callback|
         class_eval <<-METHOD, __FILE__, __LINE__
           def on_#{callback}_with_webmock &block

data/lib/webmock/http_lib_adapters/em_http_request.rb

@@ -113,6 +113,13 @@ if defined?(EventMachine::HttpRequest)
 
         headers.each do |header, value|
           value = value.join(", ") if value.is_a?(Array)
+
+          # WebMock's internal processing will not handle the body
+          # correctly if the header indicates that it is chunked, unless
+          # we also create all the chunks.
+          # It's far easier just to remove the header.
+          next if header =~ /transfer-encoding/i && value =~/chunked/i
+
           response_string << "#{header}: #{value}"
         end if headers
 

data/lib/webmock/http_lib_adapters/httpclient.rb

@@ -119,7 +119,7 @@ if defined?(::HTTPClient)
     request_signature = WebMock::RequestSignature.new(
       req.header.request_method.downcase.to_sym,
       uri.to_s,
-      :body => req.body.content,
+      :body => req.content,
       :headers => headers
     )
   end

data/lib/webmock/request_pattern.rb

@@ -143,11 +143,11 @@ module WebMock
 
         case BODY_FORMATS[content_type]
         when :json then
-          Crack::JSON.parse(body) == @pattern
+          matching_hashes?(Crack::JSON.parse(body), @pattern)
         when :xml then
-          Crack::XML.parse(body) == @pattern
+          matching_hashes?(Crack::XML.parse(body), @pattern)
         else
-          Addressable::URI.parse('?' + body).query_values == @pattern
+          matching_hashes?(Addressable::URI.parse('?' + body).query_values, @pattern)
         end
       else
         empty_string?(@pattern) && empty_string?(body) ||
@@ -162,6 +162,43 @@ module WebMock
 
     private
 
+    # Compare two hashes for equality
+    #
+    # For two hashes to match they must have the same length and all
+    # values must match when compared using `#===`.
+    #
+    # The following hashes are examples of matches:
+    #
+    #     {a: /\d+/} and {a: '123'}
+    #
+    #     {a: '123'} and {a: '123'}
+    #
+    #     {a: {b: /\d+/}} and {a: {b: '123'}}
+    #
+    #     {a: {b: 'wow'}} and {a: {b: 'wow'}}
+    #
+    # @param [Hash] query_parameters typically the result of parsing
+    #   JSON, XML or URL encoded parameters.
+    #
+    # @param [Hash] pattern which contains keys with a string, hash or
+    #   regular expression value to use for comparison.
+    #
+    # @return [Boolean] true if the paramaters match the comparison
+    #   hash, false if not.
+    def matching_hashes?(query_parameters, pattern)
+      return false unless query_parameters.size == pattern.size
+      query_parameters.each do |key, actual|
+        expected = pattern[key]
+
+        if actual.is_a?(Hash) && expected.is_a?(Hash)
+          return false unless matching_hashes?(actual, expected)
+        else
+          return false unless expected === actual
+        end
+      end
+      true
+    end
+
     def empty_string?(string)
       string.nil? || string == ""
     end

data/lib/webmock/version.rb

@@ -0,0 +1,3 @@
+module WebMock
+  VERSION = '1.6.4'
+end

data/lib/webmock/webmock.rb

@@ -22,9 +22,7 @@ module WebMock
   end
 
   def self.version
-    open(File.join(File.dirname(__FILE__), '../../VERSION')) { |f|
-      f.read.strip
-    }
+    VERSION
   end
 
   def self.allow_net_connect!(options = {})

data/spec/curb_spec.rb

@@ -77,7 +77,7 @@ unless RUBY_PLATFORM =~ /java/
           test = data
         end
         @curl.http_get
-        test.should match /One: 1/
+        test.should match(/One: 1/)
       end
 
       it "should call on_complete when request is complete" do
@@ -133,6 +133,124 @@ unless RUBY_PLATFORM =~ /java/
         order.should == [:on_progress,:on_header,:on_body,:on_complete,:on_failure]
       end
     end
+
+    describe '#last_effective_url' do
+      before(:each) do
+        @curl = Curl::Easy.new
+        @curl.url = "http://example.com"
+      end
+
+      context 'when not following redirects' do
+        before { @curl.follow_location = false }
+
+        it 'should be the same as #url even with a location header' do
+          stub_request(:any, 'example.com').
+            to_return(:body    => "abc",
+                      :status  => 302,
+                      :headers => { 'Location' => 'http://www.example.com' })
+
+          @curl.http_get
+          @curl.last_effective_url.should == 'http://example.com'
+        end
+      end
+
+      context 'when following redirects' do
+        before { @curl.follow_location = true }
+
+        it 'should be the same as #url when no location header is present' do
+          stub_request(:any, "example.com")
+          @curl.http_get
+          @curl.last_effective_url.should == 'http://example.com'
+        end
+
+        it 'should be the value of the location header when present' do
+          stub_request(:any, 'example.com').
+            to_return(:headers => { 'Location' => 'http://www.example.com' })
+          stub_request(:any, 'www.example.com')
+
+          @curl.http_get
+          @curl.last_effective_url.should == 'http://www.example.com'
+        end
+
+        it 'should work with more than one redirect' do
+          stub_request(:any, 'example.com').
+            to_return(:headers => { 'Location' => 'http://www.example.com' })
+          stub_request(:any, 'www.example.com').
+            to_return(:headers => { 'Location' => 'http://blog.example.com' })
+          stub_request(:any, 'blog.example.com')
+
+          @curl.http_get
+          @curl.last_effective_url.should == 'http://blog.example.com'
+        end
+
+        it 'should maintain the original url' do
+          stub_request(:any, 'example.com').
+            to_return(:headers => { 'Location' => 'http://www.example.com' })
+          stub_request(:any, 'www.example.com')
+
+          @curl.http_get
+          @curl.url.should == 'http://example.com'
+        end
+
+        it 'should have the redirected-to attrs (body, response code)' do
+          stub_request(:any, 'example.com').
+            to_return(:body => 'request A',
+                      :status => 302,
+                      :headers => { 'Location' => 'http://www.example.com' })
+          stub_request(:any, 'www.example.com').to_return(:body => 'request B')
+
+          @curl.http_get
+          @curl.body_str.should == 'request B'
+          @curl.response_code.should == 200
+        end
+
+        it 'should follow more than one redirect' do
+          stub_request(:any, 'example.com').
+            to_return(:headers => { 'Location' => 'http://www.example.com' })
+          stub_request(:any, 'www.example.com').
+            to_return(:headers => { 'Location' => 'http://blog.example.com' })
+          stub_request(:any, 'blog.example.com').to_return(:body => 'blog post')
+
+          @curl.http_get
+          @curl.url.should == 'http://example.com'
+          @curl.body_str.should == 'blog post'
+        end
+      end
+    end
+    
+    describe "#content_type" do
+      before(:each) do
+        @curl = Curl::Easy.new
+        @curl.url = "http://example.com"
+      end
+
+      context "when response includes Content-Type header" do
+        it "returns correct content_type" do
+          content_type = "application/json"
+
+          stub_request(:any, 'example.com').
+            to_return(:body     => "abc",
+                      :status   => 200,
+                      :headers  => { 'Content-Type' => content_type })
+
+          @curl.http_get
+          @curl.content_type.should == content_type
+        end
+      end
+
+      context "when response does not include Content-Type header" do
+        it "returns nil for content_type" do
+          content_type = "application/json"
+
+          stub_request(:any, 'example.com').
+            to_return(:body     => "abc",
+                      :status   => 200 )
+
+          @curl.http_get
+          @curl.content_type.should be_nil
+        end
+      end
+    end
   end
 
   describe "Webmock with Curb" do

data/spec/em_http_request_spec.rb

@@ -20,6 +20,11 @@ unless RUBY_PLATFORM =~ /java/
       response.should == "abc"
     end
 
+    it "should work with responses that use chunked transfer encoding" do
+      stub_http_request(:get, "www.example.com").to_return(:body => "abc", :headers => { 'Transfer-Encoding' => 'chunked' })
+      http_request(:get, "http://www.example.com").body.should == "abc"
+    end
+
     it "should work with optional query params" do
       stub_http_request(:get, "www.example.com/?x=3&a[]=b&a[]=c").to_return(:body => "abc")
       http_request(:get, "http://www.example.com/?x=3", :query => {"a" => ["b", "c"]}).body.should == "abc"

data/spec/httpclient_spec_helper.rb

@@ -64,12 +64,16 @@ module HTTPClientSpecHelper
 
     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.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)
-
-    socket.should_receive(:readpartial).any_number_of_times.and_raise(EOFError)
   end
   
   def http_library

data/spec/net_http_spec.rb

@@ -57,7 +57,7 @@ describe "Webmock with Net:HTTP" do
     req = Net::HTTP::Post.new("/")
     Net::HTTP.start("www.example.com") {|http|
       http.request(req, StringIO.new("my_params"))
-    }.body.should =~ /Example Web Page/
+    }.body.should =~ /^$/
   end
 
   it "should handle requests with block passed to read_body", :net_connect => true do
@@ -71,7 +71,7 @@ describe "Webmock with Net:HTTP" do
         end
       end
     end
-    body.should =~ /Example Web Page/
+    body.should =~ /^$/
   end
 
   it "should return a Net::ReadAdapter from response.body when a stubbed request is made with a block and #read_body" do
@@ -128,7 +128,7 @@ describe "Webmock with Net:HTTP" do
   end
 
   describe 'after_request callback support', :net_connect => true do
-    let(:expected_body_regex) { /You have reached this web page by typing.*example\.com/ }
+    let(:expected_body_regex) { /^$/ }
 
     before(:each) do
       WebMock.allow_net_connect!

data/spec/patron_spec.rb

@@ -38,9 +38,16 @@ unless RUBY_PLATFORM =~ /java/
 
         it "should raise same error as Patron if file is not readable for get request" do
           stub_http_request(:get, "www.example.com")
-          lambda {
-            @sess.get_file("/", "/non_existing_file")
-          }.should raise_error(ArgumentError, "Unable to open specified file.")
+          File.open("/tmp/read_only_file", "w") do |tmpfile|
+            tmpfile.chmod(0400)
+          end
+          begin
+            lambda {
+              @sess.get_file("/", "/tmp/read_only_file")
+            }.should raise_error(ArgumentError, "Unable to open specified file.")
+          ensure
+            File.unlink("/tmp/read_only_file")
+          end
         end
 
         it "should work with put_file" do
@@ -58,7 +65,7 @@ unless RUBY_PLATFORM =~ /java/
         it "should raise same error as Patron if file is not readable for post request" do
           stub_http_request(:post, "www.example.com").with(:body => "abc")
           lambda {
-            @sess.post_file("/", "/non_existing_file")
+            @sess.post_file("/", "/path/to/non/existing/file")
           }.should raise_error(ArgumentError, "Unable to open specified file.")
         end