webmock 1.20.3 → 1.20.4

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 1.20.4
+
+  * Fixed support for `hash_including` matcher in RSpec 3
+
 ## 1.20.3
 
   * `with` method raises error if provided without options hash and without block

data/README.md

@@ -540,52 +540,51 @@ assert_not_requested(stub_post)
 ```ruby
 require 'webmock/rspec'
 
-WebMock.should have_requested(:get, "www.example.com").
+expect(WebMock).to have_requested(:get, "www.example.com").
   with(:body => "abc", :headers => {'Content-Length' => 3}).twice
 
-WebMock.should_not have_requested(:get, "www.something.com")
+expect(WebMock).not_to have_requested(:get, "www.something.com")
 
-WebMock.should have_requested(:post, "www.example.com").with { |req| req.body == "abc" }
+expect(WebMock).to have_requested(:post, "www.example.com").with { |req| req.body == "abc" }
 # Note that the block with `do ... end` instead of curly brackets won't work!
 # Why? See this comment https://github.com/bblimke/webmock/issues/174#issuecomment-34908908
 
-WebMock.should have_requested(:get, "www.example.com").with(:query => {"a" => ["b", "c"]})
+expect(WebMock).to have_requested(:get, "www.example.com").with(:query => {"a" => ["b", "c"]})
 
-WebMock.should have_requested(:get, "www.example.com").
+expect(WebMock).to have_requested(:get, "www.example.com").
   with(:query => hash_including({"a" => ["b", "c"]}))
 
-WebMock.should have_requested(:get, "www.example.com").
+expect(WebMock).to have_requested(:get, "www.example.com").
   with(:body => {"a" => ["b", "c"]}, :headers => {'Content-Type' => 'application/json'})
 ```
 
 ### Setting expectations in RSpec with `a_request`
 
 ```ruby
-a_request(:post, "www.example.com").
-  with(:body => "abc", :headers => {'Content-Length' => 3}).should have_been_made.once
+expect(a_request(:post, "www.example.com").
+  with(:body => "abc", :headers => {'Content-Length' => 3})).to have_been_made.once
 
-a_request(:post, "www.something.com").should have_been_made.times(3)
+expect(a_request(:post, "www.something.com")).to have_been_made.times(3)
 
-a_request(:post, "www.something.com").should have_been_made.at_least_once
+expect(a_request(:post, "www.something.com")).to have_been_made.at_least_once
 
-a_request(:post, "www.something.com").should have_been_made.at_least_times(3)
+expect(a_request(:post, "www.something.com")).to have_been_made.at_least_times(3)
 
-a_request(:post, "www.something.com").should have_been_made.at_most_twice
+expect(a_request(:post, "www.something.com")).to have_been_made.at_most_twice
 
-a_request(:post, "www.something.com").should have_been_made.at_most_times(3)
+expect(a_request(:post, "www.something.com")).to have_been_made.at_most_times(3)
 
-a_request(:any, "www.example.com").should_not have_been_made
+expect(a_request(:any, "www.example.com")).not_to have_been_made
 
-a_request(:post, "www.example.com").with { |req| req.body == "abc" }.should have_been_made
+expect(a_request(:post, "www.example.com").with { |req| req.body == "abc" }).to have_been_made
 
-a_request(:get, "www.example.com").with(:query => {"a" => ["b", "c"]}).should have_been_made
+expect(a_request(:get, "www.example.com").with(:query => {"a" => ["b", "c"]})).to have_been_made
 
-a_request(:get, "www.example.com").
-  with(:query => hash_including({"a" => ["b", "c"]})).should have_been_made
+expect(a_request(:get, "www.example.com").
+  with(:query => hash_including({"a" => ["b", "c"]}))).to have_been_made
 
-a_request(:post, "www.example.com").
-  with(:body => {"a" => ["b", "c"]}, :headers => {'Content-Type' => 'application/json'}).
-  should have_been_made
+expect(a_request(:post, "www.example.com").
+  with(:body => {"a" => ["b", "c"]}, :headers => {'Content-Type' => 'application/json'})).to have_been_made
 ```
 
 ### Setting expectations in RSpec on the stub
@@ -593,7 +592,7 @@ a_request(:post, "www.example.com").
 ```ruby
 stub = stub_request(:get, "www.example.com")
 # ... make requests ...
-stub.should have_been_requested
+expect(stub).to have_been_requested
 ```
 
 ## Clearing stubs and request history

data/lib/webmock/matchers/hash_including_matcher.rb

@@ -8,7 +8,7 @@ module WebMock
       end
 
       def ==(actual)
-        @expected.all? {|k,v| actual.has_key?(k) && v == actual[k]}
+        @expected.all? {|k,v| actual.has_key?(k) && v === actual[k]}
       rescue NoMethodError
         false
       end

data/lib/webmock/version.rb

@@ -1,3 +1,3 @@
 module WebMock
-  VERSION = '1.20.3' unless defined?(::WebMock::VERSION)
+  VERSION = '1.20.4' unless defined?(::WebMock::VERSION)
 end

data/spec/acceptance/curb/curb_spec.rb

@@ -12,8 +12,8 @@ unless RUBY_PLATFORM =~ /java/
     describe "when doing PUTs" do
       it "should stub them" do
         stub_request(:put, "www.example.com").with(:body => "01234")
-        http_request(:put, "http://www.example.com", :body => "01234").
-          status.should == "200"
+        expect(http_request(:put, "http://www.example.com", :body => "01234").
+          status).to eq("200")
       end
     end
   end
@@ -39,7 +39,7 @@ unless RUBY_PLATFORM =~ /java/
           test = c.body_str
         end
         @curl.http_get
-        test.should == body
+        expect(test).to eq(body)
       end
 
       it "should call on_missing with 4xx response" do
@@ -52,7 +52,7 @@ unless RUBY_PLATFORM =~ /java/
           test = code
         end
         @curl.http_get
-        test.should == response_code
+        expect(test).to eq(response_code)
       end
 
       it "should call on_failure with 5xx response" do
@@ -65,7 +65,7 @@ unless RUBY_PLATFORM =~ /java/
           test = code
         end
         @curl.http_get
-        test.should == response_code
+        expect(test).to eq(response_code)
       end
 
       it "should call on_body when response body is read" do
@@ -78,7 +78,7 @@ unless RUBY_PLATFORM =~ /java/
           test = data
         end
         @curl.http_get
-        test.should == body
+        expect(test).to eq(body)
       end
 
       it "should call on_body for each chunk with chunked response" do
@@ -92,7 +92,7 @@ unless RUBY_PLATFORM =~ /java/
           test << data
         end
         @curl.http_get
-        test.should == ["first_chunk", "second_chunk"]
+        expect(test).to eq(["first_chunk", "second_chunk"])
       end
 
       it "should call on_header when response headers are read" do
@@ -104,10 +104,10 @@ unless RUBY_PLATFORM =~ /java/
           test << data
         end
         @curl.http_get
-        test.should == [
+        expect(test).to eq([
           "HTTP/1.1 200 \r\n",
           'One: 1'
-        ]
+        ])
       end
 
       it "should call on_complete when request is complete" do
@@ -119,7 +119,7 @@ unless RUBY_PLATFORM =~ /java/
           test = curl.body_str
         end
         @curl.http_get
-        test.should == body
+        expect(test).to eq(body)
       end
 
       it "should call on_progress when portion of response body is read" do
@@ -127,12 +127,12 @@ unless RUBY_PLATFORM =~ /java/
 
         test = nil
         @curl.on_progress do |*args|
-          args.length.should == 4
-          args.each {|arg| arg.is_a?(Float).should == true }
+          expect(args.length).to eq(4)
+          args.each {|arg| expect(arg.is_a?(Float)).to eq(true) }
           test = true
         end
         @curl.http_get
-        test.should == true
+        expect(test).to eq(true)
       end
 
       it "should call callbacks in correct order on successful request" do
@@ -147,7 +147,7 @@ unless RUBY_PLATFORM =~ /java/
         @curl.on_progress {|*args| order << :on_progress }
         @curl.http_get
 
-        order.should == [:on_progress,:on_header,:on_body,:on_complete,:on_success]
+        expect(order).to eq([:on_progress,:on_header,:on_body,:on_complete,:on_success])
       end
 
       it "should call callbacks in correct order on failed request" do
@@ -162,7 +162,7 @@ unless RUBY_PLATFORM =~ /java/
         @curl.on_progress {|*args| order << :on_progress }
         @curl.http_get
 
-        order.should == [:on_progress,:on_header,:on_body,:on_complete,:on_failure]
+        expect(order).to eq([:on_progress,:on_header,:on_body,:on_complete,:on_failure])
       end
 
       it "should call callbacks in correct order on missing request" do
@@ -177,7 +177,7 @@ unless RUBY_PLATFORM =~ /java/
         @curl.on_progress {|*args| order << :on_progress }
         @curl.http_get
 
-        order.should == [:on_progress,:on_header,:on_body,:on_complete,:on_missing]
+        expect(order).to eq([:on_progress,:on_header,:on_body,:on_complete,:on_missing])
       end
     end
 
@@ -197,7 +197,7 @@ unless RUBY_PLATFORM =~ /java/
                       :headers => { 'Location' => 'http://www.example.com' })
 
           @curl.http_get
-          @curl.last_effective_url.should == 'http://example.com'
+          expect(@curl.last_effective_url).to eq('http://example.com')
         end
       end
 
@@ -207,7 +207,7 @@ unless RUBY_PLATFORM =~ /java/
         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'
+          expect(@curl.last_effective_url).to eq('http://example.com')
         end
 
         it 'should be the value of the location header when present' do
@@ -216,7 +216,7 @@ unless RUBY_PLATFORM =~ /java/
           stub_request(:any, 'www.example.com')
 
           @curl.http_get
-          @curl.last_effective_url.should == 'http://www.example.com'
+          expect(@curl.last_effective_url).to eq('http://www.example.com')
         end
 
         it 'should work with more than one redirect' do
@@ -227,7 +227,7 @@ unless RUBY_PLATFORM =~ /java/
           stub_request(:any, 'blog.example.com')
 
           @curl.http_get
-          @curl.last_effective_url.should == 'http://blog.example.com'
+          expect(@curl.last_effective_url).to eq('http://blog.example.com')
         end
 
         it 'should maintain the original url' do
@@ -236,7 +236,7 @@ unless RUBY_PLATFORM =~ /java/
           stub_request(:any, 'www.example.com')
 
           @curl.http_get
-          @curl.url.should == 'http://example.com'
+          expect(@curl.url).to eq('http://example.com')
         end
 
         it 'should have the redirected-to attrs (body, response code)' do
@@ -247,8 +247,8 @@ unless RUBY_PLATFORM =~ /java/
           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
+          expect(@curl.body_str).to eq('request B')
+          expect(@curl.response_code).to eq(200)
         end
 
         it 'should follow more than one redirect' do
@@ -259,8 +259,8 @@ unless RUBY_PLATFORM =~ /java/
           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'
+          expect(@curl.url).to eq('http://example.com')
+          expect(@curl.body_str).to eq('blog post')
         end
       end
     end
@@ -281,7 +281,7 @@ unless RUBY_PLATFORM =~ /java/
                       :headers  => { 'Content-Type' => content_type })
 
           @curl.http_get
-          @curl.content_type.should == content_type
+          expect(@curl.content_type).to eq(content_type)
         end
       end
 
@@ -294,7 +294,7 @@ unless RUBY_PLATFORM =~ /java/
                       :status   => 200 )
 
           @curl.http_get
-          @curl.content_type.should be_nil
+          expect(@curl.content_type).to be_nil
         end
       end
     end
@@ -312,7 +312,7 @@ unless RUBY_PLATFORM =~ /java/
                     :headers  => { 'Transfer-Encoding' => 'chunked' })
 
         @curl.http_get
-        @curl.should be_chunked_response
+        expect(@curl).to be_chunked_response
       end
 
       it "is false when Transfer-Encoding is not 'chunked'" do
@@ -321,7 +321,7 @@ unless RUBY_PLATFORM =~ /java/
                     :status   => 200)
 
         @curl.http_get
-        @curl.should_not be_chunked_response
+        expect(@curl).not_to be_chunked_response
       end
 
       it "is false when Transfer-Encoding is 'chunked' but body does not respond to each" do
@@ -330,7 +330,7 @@ unless RUBY_PLATFORM =~ /java/
                     :status   => 200)
 
         @curl.http_get
-        @curl.should_not be_chunked_response
+        expect(@curl).not_to be_chunked_response
       end
     end
   end
@@ -346,7 +346,7 @@ unless RUBY_PLATFORM =~ /java/
         c = Curl::Easy.new
         c.url = "http://www.example.com"
         c.http(:GET)
-        c.body_str.should == "abc"
+        expect(c.body_str).to eq("abc")
       end
 
       it "should alias body to body_str" do
@@ -355,7 +355,7 @@ unless RUBY_PLATFORM =~ /java/
         c = Curl::Easy.new
         c.url = "http://www.example.com"
         c.http(:GET)
-        c.body.should == "abc"
+        expect(c.body).to eq("abc")
       end
     end
 
@@ -369,13 +369,13 @@ unless RUBY_PLATFORM =~ /java/
         c.url = "http://www.example.com"
         c.post_body = "01234"
         c.http_post
-        c.response_code.should == 200
+        expect(c.response_code).to eq(200)
       end
 
       it "should work with several body arguments for post using the class method" do
         stub_request(:post, "www.example.com").with(:body => {:user => {:first_name=>'Bartosz', :last_name=>'Blimke'}})
         c = Curl::Easy.http_post "http://www.example.com", 'user[first_name]=Bartosz', 'user[last_name]=Blimke'
-        c.response_code.should == 200
+        expect(c.response_code).to eq(200)
       end
 
       it "should work with blank arguments for put" do
@@ -384,7 +384,7 @@ unless RUBY_PLATFORM =~ /java/
         c.url = "http://www.example.com"
         c.put_data = "01234"
         c.http_put
-        c.response_code.should == 200
+        expect(c.response_code).to eq(200)
       end
 
       it "should work with multiple arguments for post" do
@@ -395,7 +395,7 @@ unless RUBY_PLATFORM =~ /java/
         c.url = "http://www.example.com"
         c.http_post Curl::PostField.content('name', data[:name]),  Curl::PostField.content('address', data[:address])
 
-        c.response_code.should == 200
+        expect(c.response_code).to eq(200)
       end
 
     end

data/spec/acceptance/em_http_request/em_http_request_spec.rb

@@ -33,7 +33,7 @@ unless RUBY_PLATFORM =~ /java/
 
           make_request
 
-          urls.should eq([http_url, https_url])
+          expect(urls).to eq([http_url, https_url])
         end
 
         it 'invokes the after_request hook with both requests' do
@@ -42,7 +42,7 @@ unless RUBY_PLATFORM =~ /java/
 
           make_request
 
-          urls.should eq([http_url, https_url])
+          expect(urls).to eq([http_url, https_url])
         end
       end
 
@@ -65,7 +65,7 @@ unless RUBY_PLATFORM =~ /java/
             http = conn.get(:body => 'foo')
 
             http.callback do
-              WebMock.should have_requested(:get, "www.example.com").with(:body => 'bar')
+              expect(WebMock).to have_requested(:get, "www.example.com").with(:body => 'bar')
               EM.stop
             end
           end
@@ -90,7 +90,7 @@ unless RUBY_PLATFORM =~ /java/
             http = conn.get
 
             http.callback do
-              http.response.should be == 'bar'
+              expect(http.response).to eq('bar')
               EM.stop
             end
           end
@@ -112,7 +112,7 @@ unless RUBY_PLATFORM =~ /java/
               http.callback { EM.stop }
             end
 
-            yielded_response_body.should eq("hello world")
+            expect(yielded_response_body).to eq("hello world")
           end
         end
 
@@ -138,10 +138,10 @@ unless RUBY_PLATFORM =~ /java/
             called = true
             EM.stop
           end
-          called.should == false
+          expect(called).to eq(false)
         end
 
-        called.should == true
+        expect(called).to eq(true)
       end
 
       # not pretty, but it works
@@ -161,7 +161,7 @@ unless RUBY_PLATFORM =~ /java/
 
           it "should work" do
             stub_request(:post, /.*.testserver.com*/).to_return(:status => 200, :body => 'ok')
-            lambda {
+            expect {
               EM.run do
                 fiber = Fiber.new do
                   http = EM::HttpRequest.new("http://www.testserver.com").post :body => "foo=bar&baz=bang", :timeout => 60
@@ -169,7 +169,7 @@ unless RUBY_PLATFORM =~ /java/
                 end
                 fiber.resume
               end
-            }.should_not raise_error
+            }.not_to raise_error
           end
 
           after(:each) do
@@ -193,40 +193,40 @@ unless RUBY_PLATFORM =~ /java/
         http = EventMachine::HttpRequest.new('http://www.example.com/').get
         http.stream { |chunk| response = chunk; EM.stop  }
       }
-      response.should == "abc"
+      expect(response).to eq("abc")
     end
 
     it "should work with responses that use chunked transfer encoding" do
       stub_request(:get, "www.example.com").to_return(:body => "abc", :headers => { 'Transfer-Encoding' => 'chunked' })
-      http_request(:get, "http://www.example.com").body.should == "abc"
+      expect(http_request(:get, "http://www.example.com").body).to eq("abc")
     end
 
     it "should work with optional query params" do
       stub_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"
+      expect(http_request(:get, "http://www.example.com/?x=3", :query => {"a" => ["b", "c"]}).body).to eq("abc")
     end
 
     it "should work with optional query params declared as string" do
       stub_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&a[]=c").body.should == "abc"
+      expect(http_request(:get, "http://www.example.com/?x=3", :query => "a[]=b&a[]=c").body).to eq("abc")
     end
 
     it "should work when the body is passed as a Hash" do
       stub_request(:post, "www.example.com").with(:body => {:a => "1", :b => "2"}).to_return(:body => "ok")
-      http_request(:post, "http://www.example.com", :body => {:a => "1", :b => "2"}).body.should == "ok"
+      expect(http_request(:post, "http://www.example.com", :body => {:a => "1", :b => "2"}).body).to eq("ok")
     end
 
     if defined?(EventMachine::HttpConnection)
       it "should work when a file is passed as body" do
         stub_request(:post, "www.example.com").with(:body => File.read(__FILE__)).to_return(:body => "ok")
-        http_request(:post, "http://www.example.com", :file => __FILE__).body.should == "ok"
+        expect(http_request(:post, "http://www.example.com", :file => __FILE__).body).to eq("ok")
       end
     end
 
     it "should work with UTF-8 strings" do
       body = "Привет, Мир!"
       stub_request(:post, "www.example.com").to_return(:body => body)
-      http_request(:post, "http://www.example.com").body.bytesize.should == body.bytesize
+      expect(http_request(:post, "http://www.example.com").body.bytesize).to eq(body.bytesize)
     end
 
     describe "mocking EM::HttpClient API" do
@@ -250,11 +250,11 @@ unless RUBY_PLATFORM =~ /java/
       subject { client(uri) }
 
       it 'should support #uri' do
-        subject.uri.should == Addressable::URI.parse(uri)
+        expect(subject.uri).to eq(Addressable::URI.parse(uri))
       end
 
       it 'should support #last_effective_url' do
-        subject.last_effective_url.should == Addressable::URI.parse(uri)
+        expect(subject.last_effective_url).to eq(Addressable::URI.parse(uri))
       end
 
       context "with a query" do
@@ -262,9 +262,9 @@ unless RUBY_PLATFORM =~ /java/
         subject { client("http://www.example.com/?a=1", :query => { 'b' => 2 }) }
 
         it "#request_signature doesn't mutate the original uri" do
-          subject.uri.should == Addressable::URI.parse("http://www.example.com/?a=1")
+          expect(subject.uri).to eq(Addressable::URI.parse("http://www.example.com/?a=1"))
           signature = WebMock::RequestRegistry.instance.requested_signatures.hash.keys.first
-          signature.uri.should == Addressable::URI.parse(uri)
+          expect(signature.uri).to eq(Addressable::URI.parse(uri))
         end
       end
 
@@ -293,7 +293,7 @@ unless RUBY_PLATFORM =~ /java/
 
                 http.errback { fail(http.error) }
                 http.callback {
-                  http.get_response_cookie(cookie_name).should == cookie_value
+                  expect(http.get_response_cookie(cookie_name)).to eq(cookie_value)
                   EM.stop
                 }
               }
@@ -314,8 +314,8 @@ unless RUBY_PLATFORM =~ /java/
 
                 http.errback { fail(http.error) }
                 http.callback {
-                  http.get_response_cookie(cookie_name).should == cookie_value
-                  http.get_response_cookie(cookie_2_name).should == cookie_2_value
+                  expect(http.get_response_cookie(cookie_name)).to eq(cookie_value)
+                  expect(http.get_response_cookie(cookie_2_name)).to eq(cookie_2_value)
                   EM.stop
                 }
               }
@@ -333,7 +333,7 @@ unless RUBY_PLATFORM =~ /java/
 
                 http.errback { fail(http.error) }
                 http.callback {
-                  http.get_response_cookie('not_found_cookie').should == nil
+                  expect(http.get_response_cookie('not_found_cookie')).to eq(nil)
                   EM.stop
                 }
               }