webmock 1.20.3 → 1.20.4

data/spec/acceptance/patron/patron_spec.rb

@@ -35,7 +35,7 @@ unless RUBY_PLATFORM =~ /java/
         it "should work with get_file" do
           stub_request(:get, "www.example.com").to_return(:body => "abc")
           @sess.get_file("/", @file_path)
-          File.read(@file_path).should == "abc"
+          expect(File.read(@file_path)).to eq("abc")
         end
 
         it "should raise same error as Patron if file is not readable for get request" do
@@ -44,9 +44,9 @@ unless RUBY_PLATFORM =~ /java/
             tmpfile.chmod(0400)
           end
           begin
-            lambda {
+            expect {
               @sess.get_file("/", "/tmp/read_only_file")
-            }.should raise_error(ArgumentError, "Unable to open specified file.")
+            }.to raise_error(ArgumentError, "Unable to open specified file.")
           ensure
             File.unlink("/tmp/read_only_file")
           end
@@ -66,9 +66,9 @@ unless RUBY_PLATFORM =~ /java/
 
         it "should raise same error as Patron if file is not readable for post request" do
           stub_request(:post, "www.example.com").with(:body => "abc")
-          lambda {
+          expect {
             @sess.post_file("/", "/path/to/non/existing/file")
-          }.should raise_error(ArgumentError, "Unable to open specified file.")
+          }.to raise_error(ArgumentError, "Unable to open specified file.")
         end
 
       end
@@ -76,9 +76,9 @@ unless RUBY_PLATFORM =~ /java/
       describe "handling errors same way as patron" do
         it "should raise error if put request has neither upload_data nor file_name" do
           stub_request(:post, "www.example.com")
-          lambda {
+          expect {
             @sess.post("/", nil)
-          }.should raise_error(ArgumentError, "Must provide either data or a filename when doing a PUT or POST")
+          }.to raise_error(ArgumentError, "Must provide either data or a filename when doing a PUT or POST")
         end
       end
 
@@ -100,7 +100,7 @@ unless RUBY_PLATFORM =~ /java/
             stub_request(:get, "www.example.com").
               to_return(:body => "Øl")
 
-            @sess.get("").body.encoding.should == Encoding::UTF_8
+            expect(@sess.get("").body.encoding).to eq(Encoding::UTF_8)
           end
 
           it "should encode body to default internal" do
@@ -108,7 +108,7 @@ unless RUBY_PLATFORM =~ /java/
               to_return(:headers => {'Content-Type' => 'text/html; charset=iso-8859-1'},
                         :body => "Øl".encode("iso-8859-1"))
 
-            @sess.get("").body.encoding.should == Encoding.default_internal
+            expect(@sess.get("").body.encoding).to eq(Encoding.default_internal)
           end
 
           it "should encode body based on encoding-attribute in body" do
@@ -116,7 +116,7 @@ unless RUBY_PLATFORM =~ /java/
               to_return(:body => "<?xml encoding=\"iso-8859-1\">Øl</xml>".encode("iso-8859-1"))
 
 
-            @sess.get("").body.encoding.should == Encoding::ISO_8859_1
+            expect(@sess.get("").body.encoding).to eq(Encoding::ISO_8859_1)
           end
 
 
@@ -126,7 +126,7 @@ unless RUBY_PLATFORM =~ /java/
 
             @sess.default_response_charset = "iso-8859-1"
 
-            @sess.get("").body.encoding.should == Encoding::ISO_8859_1
+            expect(@sess.get("").body.encoding).to eq(Encoding::ISO_8859_1)
           end
 
         end

data/spec/acceptance/shared/allowing_and_disabling_net_connect.rb

@@ -6,19 +6,19 @@ shared_context "allowing and disabling net connect" do |*adapter_info|
       end
 
       it "should make a real web request if request is not stubbed" do
-        http_request(:get, webmock_server_url).status.should == "200"
+        expect(http_request(:get, webmock_server_url).status).to eq("200")
       end
 
       it "should make a real https request if request is not stubbed" do
         unless http_library == :httpclient
-          http_request(:get, "https://www.google.com/").
-            body.should =~ /.*google.*/
+          expect(http_request(:get, "https://www.google.com/").
+            body).to match(/.*google.*/)
         end
       end
 
       it "should return stubbed response if request was stubbed" do
         stub_request(:get, "www.example.com").to_return(:body => "abc")
-        http_request(:get, "http://www.example.com/").body.should == "abc"
+        expect(http_request(:get, "http://www.example.com/").body).to eq("abc")
       end
     end
 
@@ -29,18 +29,18 @@ shared_context "allowing and disabling net connect" do |*adapter_info|
 
       it "should return stubbed response if request was stubbed" do
         stub_request(:get, "www.example.com").to_return(:body => "abc")
-        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 return stubbed response if request with path was stubbed" do
         stub_request(:get, "www.example.com/hello_world").to_return(:body => "abc")
-        http_request(:get, "http://www.example.com/hello_world").body.should == "abc"
+        expect(http_request(:get, "http://www.example.com/hello_world").body).to eq("abc")
       end
 
       it "should raise exception if request was not stubbed" do
-        lambda {
+        expect {
           http_request(:get, "http://www.example.com/")
-        }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
+        }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
       end
     end
 
@@ -51,31 +51,31 @@ shared_context "allowing and disabling net connect" do |*adapter_info|
 
       it "should return stubbed response if request was stubbed" do
         stub_request(:get, "www.example.com").to_return(:body => "abc")
-        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 raise exception if request was not stubbed" do
-        lambda {
+        expect {
           http_request(:get, "http://www.example.com/")
-        }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
+        }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
       end
 
       it "should make a real request to localhost" do
-        lambda {
+        expect {
           http_request(:get, "http://localhost:12345/")
-        }.should raise_error(connection_refused_exception_class)
+        }.to raise_error(connection_refused_exception_class)
       end
 
       it "should make a real request to 127.0.0.1" do
-        lambda {
+        expect {
           http_request(:get, "http://127.0.0.1:12345/")
-        }.should raise_error(connection_refused_exception_class)
+        }.to raise_error(connection_refused_exception_class)
       end
 
       it "should make a real request to 0.0.0.0" do
-        lambda {
+        expect {
           http_request(:get, "http://0.0.0.0:12345/")
-        }.should raise_error(connection_refused_exception_class)
+        }.to raise_error(connection_refused_exception_class)
       end
     end
 
@@ -89,52 +89,52 @@ shared_context "allowing and disabling net connect" do |*adapter_info|
       context "when the host is not allowed" do
         it "should return stubbed response if request was stubbed" do
           stub_request(:get, "www.example.com").to_return(:body => "abc")
-          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 raise exception if request was not stubbed" do
-          lambda {
+          expect {
             http_request(:get, "http://www.example.com/")
-          }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
+          }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
         end
       end
 
       context "when the host with port is not allowed" do
         it "should return stubbed response if request was stubbed" do
           stub_request(:get, "http://localhost:2345").to_return(:body => "abc")
-          http_request(:get, "http://localhost:2345/").body.should == "abc"
+          expect(http_request(:get, "http://localhost:2345/").body).to eq("abc")
         end
 
         it "should raise exception if request was not stubbed" do
-          lambda {
+          expect {
             http_request(:get, "http://localhost:2345/")
-          }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://localhost:2345/))
+          }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://localhost:2345/))
         end
       end
 
       context "when the host is allowed" do
         it "should raise exception if request was not stubbed" do
-          lambda {
+          expect {
             http_request(:get, "http://www.example.com/")
-          }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
+          }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
         end
 
         it "should make a real request to allowed host", :net_connect => true do
-          http_request(:get, "http://httpstat.us/200").status.should == "200"
+          expect(http_request(:get, "http://httpstat.us/200").status).to eq("200")
         end
       end
 
       context "when the host with port is allowed" do
         it "should make a real request to allowed host", :net_connect => true do
-          http_request(:get, "http://#{host_with_port}/").status.should == "200"
+          expect(http_request(:get, "http://#{host_with_port}/").status).to eq("200")
         end
       end
 
       context "when the host is allowed but not port" do
         it "should make a real request to allowed host", :net_connect => true do
-          lambda {
+          expect {
             http_request(:get, "http://localhost:123/")
-          }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://localhost:123/))
+          }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://localhost:123/))
         end
       end
     end

data/spec/acceptance/shared/callbacks.rb

@@ -9,7 +9,7 @@ shared_context "callbacks" do |*adapter_info|
       WebMock.after_request {
         @called = true
       }
-      @called.should == nil
+      expect(@called).to eq(nil)
     end
 
     it "should invoke a callback after request is made" do
@@ -17,7 +17,7 @@ shared_context "callbacks" do |*adapter_info|
         @called = true
       }
       http_request(:get, "http://www.example.com/")
-      @called.should == true
+      expect(@called).to eq(true)
     end
 
     it "should not invoke a callback if this http library should be ignored" do
@@ -25,7 +25,7 @@ shared_context "callbacks" do |*adapter_info|
         @called = true
       }
       http_request(:get, "http://www.example.com/")
-      @called.should == nil
+      expect(@called).to eq(nil)
     end
 
     it "should invoke a callback even if other http libraries should be ignored" do
@@ -33,7 +33,7 @@ shared_context "callbacks" do |*adapter_info|
         @called = true
       }
       http_request(:get, "http://www.example.com/")
-      @called.should == true
+      expect(@called).to eq(true)
     end
 
     it "should pass request signature to the callback" do
@@ -41,7 +41,7 @@ shared_context "callbacks" do |*adapter_info|
         @request_signature = request_signature
       end
       http_request(:get, "http://www.example.com/")
-      @request_signature.uri.to_s.should == "http://www.example.com:80/"
+      expect(@request_signature.uri.to_s).to eq("http://www.example.com:80/")
     end
 
     after(:each) do
@@ -60,7 +60,7 @@ shared_context "callbacks" do |*adapter_info|
       end
 
       http_request(:get, "http://www.example.com/")
-      global_stub_request_sig.should be(after_request_request_sig)
+      expect(global_stub_request_sig).to be(after_request_request_sig)
     end
 
     context "passing response to callback" do
@@ -79,18 +79,18 @@ shared_context "callbacks" do |*adapter_info|
         end
 
         it "should pass response to callback with the status and message" do
-          @response.status.should == [200, "hello"]
+          expect(@response.status).to eq([200, "hello"])
         end
 
         it "should pass response to callback with headers" do
-          @response.headers.should == {
+          expect(@response.headers).to eq({
             'Content-Length' => '666',
             'Hello' => 'World'
-          }
+          })
         end
 
         it "should pass response to callback with body" do
-          @response.body.should == "foo bar"
+          expect(@response.body).to eq("foo bar")
         end
       end
 
@@ -105,16 +105,16 @@ shared_context "callbacks" do |*adapter_info|
         end
 
         it "should pass real response to callback with status and message" do
-          @response.status[0].should == 201
-          @response.status[1].should == "Created" unless adapter_info.include?(:no_status_message)
+          expect(@response.status[0]).to eq(201)
+          expect(@response.status[1]).to eq("Created") unless adapter_info.include?(:no_status_message)
         end
 
         it "should pass real response to callback with headers" do
-          @response.headers["Content-Length"].should == "11"
+          expect(@response.headers["Content-Length"]).to eq("11")
         end
 
         it "should pass response to callback with body" do
-          @response.body.size.should == 11
+          expect(@response.body.size).to eq(11)
         end
       end
     end
@@ -123,16 +123,16 @@ shared_context "callbacks" do |*adapter_info|
       WebMock.after_request { @called = 1 }
       WebMock.after_request { @called += 1 }
       http_request(:get, "http://www.example.com/")
-      @called.should == 2
+      expect(@called).to eq(2)
     end
 
     it "should invoke callbacks only for real requests if requested", :net_connect => true do
       WebMock.after_request(:real_requests_only => true) { @called = true }
       http_request(:get, "http://www.example.com/")
-      @called.should == nil
+      expect(@called).to eq(nil)
       WebMock.allow_net_connect!
       http_request(:get, "http://www.example.net/")
-      @called.should == true
+      expect(@called).to eq(true)
     end
 
     it "should not invoke any callbacks after callbacks were reset" do
@@ -140,7 +140,7 @@ shared_context "callbacks" do |*adapter_info|
       WebMock.reset_callbacks
       stub_request(:get, "http://www.example.com/")
       http_request(:get, "http://www.example.com/")
-      @called.should == nil
+      expect(@called).to eq(nil)
     end
   end
 end

data/spec/acceptance/shared/complex_cross_concern_behaviors.rb

@@ -14,8 +14,8 @@ shared_context "complex cross-concern behaviors" do |*adapter_info|
 
     played_back_response = http_request(:get, webmock_server_url)
 
-    played_back_response.headers.keys.should include('Set-Cookie')
-    played_back_response.should == real_response
+    expect(played_back_response.headers.keys).to include('Set-Cookie')
+    expect(played_back_response).to eq(real_response)
   end
 
   let(:no_content_url) { 'http://httpstat.us/204' }
@@ -28,7 +28,7 @@ shared_context "complex cross-concern behaviors" do |*adapter_info|
         stub_request(:get, no_content_url).to_return(:status => 204, :body => stub_val)
         stubbed_response = http_request(:get, no_content_url)
 
-        stubbed_response.body.should eq(real_response.body)
+        expect(stubbed_response.body).to eq(real_response.body)
       end
     end
   end

data/spec/acceptance/shared/enabling_and_disabling_webmock.rb

@@ -42,18 +42,18 @@ end
 shared_context "disabled WebMock" do
   it "should not register executed requests" do
     http_request(:get, webmock_server_url)
-    a_request(:get, webmock_server_url).should_not have_been_made
+    expect(a_request(:get, webmock_server_url)).not_to have_been_made
   end
 
   it "should not block unstubbed requests" do
-    lambda {
+    expect {
       http_request(:get, webmock_server_url)
-    }.should_not raise_error
+    }.not_to raise_error
   end
 
   it "should return real response even if there are stubs" do
     stub_request(:get, /.*/).to_return(:body => "x")
-    http_request(:get, webmock_server_url).body.should == "hello world"
+    expect(http_request(:get, webmock_server_url).body).to eq("hello world")
   end
 
   it "should not invoke any callbacks" do
@@ -62,7 +62,7 @@ shared_context "disabled WebMock" do
     @called = nil
     WebMock.after_request { @called = 1 }
     http_request(:get, webmock_server_url)
-    @called.should == nil
+    expect(@called).to eq(nil)
   end
 end
 
@@ -70,18 +70,18 @@ shared_context "enabled WebMock" do
   it "should register executed requests" do
     WebMock.allow_net_connect!
     http_request(:get, webmock_server_url)
-    a_request(:get, webmock_server_url).should have_been_made
+    expect(a_request(:get, webmock_server_url)).to have_been_made
   end
 
   it "should block unstubbed requests" do
-    lambda {
+    expect {
       http_request(:get, "http://www.example.com/")
-    }.should raise_error(WebMock::NetConnectNotAllowedError)
+    }.to raise_error(WebMock::NetConnectNotAllowedError)
   end
 
   it "should return stubbed response" do
     stub_request(:get, /.*/).to_return(:body => "x")
-    http_request(:get, "http://www.example.com/").body.should == "x"
+    expect(http_request(:get, "http://www.example.com/").body).to eq("x")
   end
 
   it "should invoke callbacks" do
@@ -90,6 +90,6 @@ shared_context "enabled WebMock" do
     @called = nil
     WebMock.after_request { @called = 1 }
     http_request(:get, webmock_server_url)
-    @called.should == 1
+    expect(@called).to eq(1)
   end
 end

data/spec/acceptance/shared/precedence_of_stubs.rb

@@ -3,13 +3,13 @@ shared_context "precedence of stubs" do |*adapter_info|
     it "should use the last declared matching request stub" do
       stub_request(:get, "www.example.com").to_return(:body => "abc")
       stub_request(:get, "www.example.com").to_return(:body => "def")
-      http_request(:get, "http://www.example.com/").body.should == "def"
+      expect(http_request(:get, "http://www.example.com/").body).to eq("def")
     end
 
     it "should not be affected by the type of uri or request method" do
       stub_request(:get, "www.example.com").to_return(:body => "abc")
       stub_request(:any, /.*example.*/).to_return(:body => "def")
-      http_request(:get, "http://www.example.com/").body.should == "def"
+      expect(http_request(:get, "http://www.example.com/").body).to eq("def")
     end
   end
 end