Convert specs to RSpec 2.99.2 syntax with Transpec

This conversion is done by Transpec 3.2.2 with the following command:
    transpec

* 317 conversions
    from: obj.should
      to: expect(obj).to

* 160 conversions
    from: obj.stub(:message)
      to: allow(obj).to receive(:message)

* 100 conversions
    from: obj.should_receive(:message)
      to: expect(obj).to receive(:message)

* 30 conversions
    from: lambda { }.should
      to: expect { }.to

* 22 conversions
    from: obj.should_not_receive(:message)
      to: expect(obj).not_to receive(:message)

* 4 conversions
    from: obj.should_not
      to: expect(obj).not_to

* 2 conversions
    from: == expected
      to: eq(expected)

* 1 conversion
    from: expect(collection).to have_at_least(n).items
      to: expect(collection.size).to be >= n

* 1 conversion
    from: obj.unstub(:message)
      to: allow(obj).to receive(:message).and_call_original

For more details: https://github.com/yujinakayama/transpec#supported-conversions

Author: ab

spec/integration/httpbin_spec.rb

@@ -41,31 +41,31 @@ def execute_httpbin_json(suffix, opts={})
   describe '.execute' do
     it 'sends a user agent' do
       data = execute_httpbin_json('user-agent', method: :get)
-      data['user-agent'].should match(/rest-client/)
+      expect(data['user-agent']).to match(/rest-client/)
     end
 
     it 'receives cookies on 302' do
       expect {
         execute_httpbin('cookies/set?foo=bar', method: :get, max_redirects: 0)
       }.to raise_error(RestClient::Found) { |ex|
-        ex.http_code.should eq 302
-        ex.response.cookies['foo'].should eq 'bar'
+        expect(ex.http_code).to eq 302
+        expect(ex.response.cookies['foo']).to eq 'bar'
       }
     end
 
     it 'passes along cookies through 302' do
       data = execute_httpbin_json('cookies/set?foo=bar', method: :get)
-      data.should have_key('cookies')
-      data['cookies']['foo'].should eq 'bar'
+      expect(data).to have_key('cookies')
+      expect(data['cookies']['foo']).to eq 'bar'
     end
 
     it 'handles quote wrapped cookies' do
       expect {
         execute_httpbin('cookies/set?foo=' + CGI.escape('"bar:baz"'),
                         method: :get, max_redirects: 0)
       }.to raise_error(RestClient::Found) { |ex|
-        ex.http_code.should eq 302
-        ex.response.cookies['foo'].should eq '"bar:baz"'
+        expect(ex.http_code).to eq 302
+        expect(ex.response.cookies['foo']).to eq '"bar:baz"'
       }
     end
   end

spec/integration/integration_spec.rb

@@ -8,15 +8,15 @@
     body = 'abc'
     stub_request(:get, "www.example.com").to_return(:body => body, :status => 200)
     response = RestClient.get "www.example.com"
-    response.code.should eq 200
-    response.body.should eq body
+    expect(response.code).to eq 200
+    expect(response.body).to eq body
   end
 
   it "a simple request with gzipped content" do
     stub_request(:get, "www.example.com").with(:headers => { 'Accept-Encoding' => 'gzip, deflate' }).to_return(:body => "\037\213\b\b\006'\252H\000\003t\000\313T\317UH\257\312,HM\341\002\000G\242(\r\v\000\000\000", :status => 200,  :headers => { 'Content-Encoding' => 'gzip' } )
     response = RestClient.get "www.example.com"
-    response.code.should eq 200
-    response.body.should eq "i'm gziped\n"
+    expect(response.code).to eq 200
+    expect(response.body).to eq "i'm gziped\n"
   end
 
   it "a 404" do
@@ -26,10 +26,10 @@
       RestClient.get "www.example.com"
       raise
     rescue RestClient::ResourceNotFound => e
-      e.http_code.should eq 404
-      e.response.code.should eq 404
-      e.response.body.should eq body
-      e.http_body.should eq body
+      expect(e.http_code).to eq 404
+      expect(e.response.code).to eq 404
+      expect(e.response.body).to eq body
+      expect(e.http_body).to eq body
     end
   end
 
@@ -41,8 +41,8 @@
           'Content-Type' => 'text/plain; charset=UTF-8'
       })
       response = RestClient.get "www.example.com"
-      response.encoding.should eq Encoding::UTF_8
-      response.valid_encoding?.should eq true
+      expect(response.encoding).to eq Encoding::UTF_8
+      expect(response.valid_encoding?).to eq true
     end
 
     it 'handles windows-1252' do
@@ -52,9 +52,9 @@
           'Content-Type' => 'text/plain; charset=windows-1252'
       })
       response = RestClient.get "www.example.com"
-      response.encoding.should eq Encoding::WINDOWS_1252
-      response.encode('utf-8').should eq "ÿ"
-      response.valid_encoding?.should eq true
+      expect(response.encoding).to eq Encoding::WINDOWS_1252
+      expect(response.encode('utf-8')).to eq "ÿ"
+      expect(response.valid_encoding?).to eq true
     end
 
     it 'handles binary' do
@@ -64,28 +64,28 @@
           'Content-Type' => 'application/octet-stream; charset=binary'
       })
       response = RestClient.get "www.example.com"
-      response.encoding.should eq Encoding::BINARY
-      lambda {
+      expect(response.encoding).to eq Encoding::BINARY
+      expect {
         response.encode('utf-8')
-      }.should raise_error(Encoding::UndefinedConversionError)
-      response.valid_encoding?.should eq true
+      }.to raise_error(Encoding::UndefinedConversionError)
+      expect(response.valid_encoding?).to eq true
     end
 
     it 'handles euc-jp' do
       body = "\xA4\xA2\xA4\xA4\xA4\xA6\xA4\xA8\xA4\xAA".
         force_encoding(Encoding::BINARY)
       body_utf8 = 'あいうえお'
-      body_utf8.encoding.should eq Encoding::UTF_8
+      expect(body_utf8.encoding).to eq Encoding::UTF_8
 
       stub_request(:get, 'www.example.com').to_return(
         :body => body, :status => 200, :headers => {
           'Content-Type' => 'text/plain; charset=EUC-JP'
       })
       response = RestClient.get 'www.example.com'
-      response.encoding.should eq Encoding::EUC_JP
-      response.valid_encoding?.should eq true
-      response.length.should eq 5
-      response.encode('utf-8').should eq body_utf8
+      expect(response.encoding).to eq Encoding::EUC_JP
+      expect(response.valid_encoding?).to eq true
+      expect(response.length).to eq 5
+      expect(response.encode('utf-8')).to eq body_utf8
     end
 
     it 'defaults to Encoding.default_external' do
@@ -95,7 +95,7 @@
         })
 
       response = RestClient.get 'www.example.com'
-      response.encoding.should eq Encoding.default_external
+      expect(response.encoding).to eq Encoding.default_external
     end
 
     it 'handles invalid encoding' do
@@ -105,7 +105,7 @@
         })
 
       response = RestClient.get 'www.example.com'
-      response.encoding.should eq Encoding.default_external
+      expect(response.encoding).to eq Encoding.default_external
     end
 
     it 'leaves images as binary' do
@@ -117,7 +117,7 @@
         })
 
       response = RestClient.get 'www.example.com'
-      response.encoding.should eq Encoding::BINARY
+      expect(response.encoding).to eq Encoding::BINARY
     end
   end
 end

spec/integration/request_spec.rb

@@ -75,7 +75,7 @@
         },
       )
       expect {request.execute }.to_not raise_error
-      ran_callback.should eq(true)
+      expect(ran_callback).to eq(true)
     end
 
     it "fails verification when the callback returns false",

spec/unit/abstract_response_spec.rb

@@ -22,124 +22,124 @@ def initialize net_http_res, request
   end
 
   it "fetches the numeric response code" do
-    @net_http_res.should_receive(:code).and_return('200')
-    @response.code.should eq 200
+    expect(@net_http_res).to receive(:code).and_return('200')
+    expect(@response.code).to eq 200
   end
 
   it "has a nice description" do
-    @net_http_res.should_receive(:to_hash).and_return({'Content-Type' => ['application/pdf']})
-    @net_http_res.should_receive(:code).and_return('200')
-    @response.description.should eq "200 OK | application/pdf  bytes\n"
+    expect(@net_http_res).to receive(:to_hash).and_return({'Content-Type' => ['application/pdf']})
+    expect(@net_http_res).to receive(:code).and_return('200')
+    expect(@response.description).to eq "200 OK | application/pdf  bytes\n"
   end
 
   describe '.beautify_headers' do
     it "beautifies the headers by turning the keys to symbols" do
       h = RestClient::AbstractResponse.beautify_headers('content-type' => [ 'x' ])
-      h.keys.first.should eq :content_type
+      expect(h.keys.first).to eq :content_type
     end
 
     it "beautifies the headers by turning the values to strings instead of one-element arrays" do
       h = RestClient::AbstractResponse.beautify_headers('x' => [ 'text/html' ] )
-      h.values.first.should eq 'text/html'
+      expect(h.values.first).to eq 'text/html'
     end
 
     it 'joins multiple header values by comma' do
-      RestClient::AbstractResponse.beautify_headers(
+      expect(RestClient::AbstractResponse.beautify_headers(
         {'My-Header' => ['one', 'two']}
-      ).should eq({:my_header => 'one, two'})
+      )).to eq({:my_header => 'one, two'})
     end
 
     it 'leaves set-cookie headers as array' do
-      RestClient::AbstractResponse.beautify_headers(
+      expect(RestClient::AbstractResponse.beautify_headers(
         {'Set-Cookie' => ['cookie1=foo', 'cookie2=bar']}
-      ).should eq({:set_cookie => ['cookie1=foo', 'cookie2=bar']})
+      )).to eq({:set_cookie => ['cookie1=foo', 'cookie2=bar']})
     end
   end
 
   it "fetches the headers" do
-    @net_http_res.should_receive(:to_hash).and_return('content-type' => [ 'text/html' ])
-    @response.headers.should eq({ :content_type => 'text/html' })
+    expect(@net_http_res).to receive(:to_hash).and_return('content-type' => [ 'text/html' ])
+    expect(@response.headers).to eq({ :content_type => 'text/html' })
   end
 
   it "extracts cookies from response headers" do
-    @net_http_res.should_receive(:to_hash).and_return('set-cookie' => ['session_id=1; path=/'])
-    @response.cookies.should eq({ 'session_id' => '1' })
+    expect(@net_http_res).to receive(:to_hash).and_return('set-cookie' => ['session_id=1; path=/'])
+    expect(@response.cookies).to eq({ 'session_id' => '1' })
   end
 
   it "extract strange cookies" do
-    @net_http_res.should_receive(:to_hash).and_return('set-cookie' => ['session_id=ZJ/HQVH6YE+rVkTpn0zvTQ==; path=/'])
-    @response.headers.should eq({:set_cookie => ['session_id=ZJ/HQVH6YE+rVkTpn0zvTQ==; path=/']})
-    @response.cookies.should eq({ 'session_id' => 'ZJ/HQVH6YE+rVkTpn0zvTQ==' })
+    expect(@net_http_res).to receive(:to_hash).and_return('set-cookie' => ['session_id=ZJ/HQVH6YE+rVkTpn0zvTQ==; path=/'])
+    expect(@response.headers).to eq({:set_cookie => ['session_id=ZJ/HQVH6YE+rVkTpn0zvTQ==; path=/']})
+    expect(@response.cookies).to eq({ 'session_id' => 'ZJ/HQVH6YE+rVkTpn0zvTQ==' })
   end
 
   it "doesn't escape cookies" do
-    @net_http_res.should_receive(:to_hash).and_return('set-cookie' => ['session_id=BAh7BzoNYXBwX25hbWUiEGFwcGxpY2F0aW9uOgpsb2dpbiIKYWRtaW4%3D%0A--08114ba654f17c04d20dcc5228ec672508f738ca; path=/'])
-    @response.cookies.should eq({ 'session_id' => 'BAh7BzoNYXBwX25hbWUiEGFwcGxpY2F0aW9uOgpsb2dpbiIKYWRtaW4%3D%0A--08114ba654f17c04d20dcc5228ec672508f738ca' })
+    expect(@net_http_res).to receive(:to_hash).and_return('set-cookie' => ['session_id=BAh7BzoNYXBwX25hbWUiEGFwcGxpY2F0aW9uOgpsb2dpbiIKYWRtaW4%3D%0A--08114ba654f17c04d20dcc5228ec672508f738ca; path=/'])
+    expect(@response.cookies).to eq({ 'session_id' => 'BAh7BzoNYXBwX25hbWUiEGFwcGxpY2F0aW9uOgpsb2dpbiIKYWRtaW4%3D%0A--08114ba654f17c04d20dcc5228ec672508f738ca' })
   end
 
   describe '.cookie_jar' do
     it 'extracts cookies into cookie jar' do
-      @net_http_res.should_receive(:to_hash).and_return('set-cookie' => ['session_id=1; path=/'])
-      @response.cookie_jar.should be_a HTTP::CookieJar
+      expect(@net_http_res).to receive(:to_hash).and_return('set-cookie' => ['session_id=1; path=/'])
+      expect(@response.cookie_jar).to be_a HTTP::CookieJar
 
       cookie = @response.cookie_jar.cookies.first
-      cookie.domain.should eq 'example.com'
-      cookie.name.should eq 'session_id'
-      cookie.value.should eq '1'
-      cookie.path.should eq '/'
+      expect(cookie.domain).to eq 'example.com'
+      expect(cookie.name).to eq 'session_id'
+      expect(cookie.value).to eq '1'
+      expect(cookie.path).to eq '/'
     end
 
     it 'handles cookies when URI scheme is implicit' do
       net_http_res = double('net http response')
-      net_http_res.should_receive(:to_hash).and_return('set-cookie' => ['session_id=1; path=/'])
+      expect(net_http_res).to receive(:to_hash).and_return('set-cookie' => ['session_id=1; path=/'])
       request = double(url: 'example.com', uri: URI.parse('http://example.com'),
                        method: 'get', cookie_jar: HTTP::CookieJar.new)
       response = MyAbstractResponse.new(net_http_res, request)
-      response.cookie_jar.should be_a HTTP::CookieJar
+      expect(response.cookie_jar).to be_a HTTP::CookieJar
 
       cookie = response.cookie_jar.cookies.first
-      cookie.domain.should eq 'example.com'
-      cookie.name.should eq 'session_id'
-      cookie.value.should eq '1'
-      cookie.path.should eq '/'
+      expect(cookie.domain).to eq 'example.com'
+      expect(cookie.name).to eq 'session_id'
+      expect(cookie.value).to eq '1'
+      expect(cookie.path).to eq '/'
     end
   end
 
   it "can access the net http result directly" do
-    @response.net_http_res.should eq @net_http_res
+    expect(@response.net_http_res).to eq @net_http_res
   end
 
   describe "#return!" do
     it "should return the response itself on 200-codes" do
-      @net_http_res.should_receive(:code).and_return('200')
-      @response.return!.should be_equal(@response)
+      expect(@net_http_res).to receive(:code).and_return('200')
+      expect(@response.return!).to be_equal(@response)
     end
 
     it "should raise RequestFailed on unknown codes" do
-      @net_http_res.should_receive(:code).and_return('1000')
-      lambda { @response.return! }.should raise_error RestClient::RequestFailed
+      expect(@net_http_res).to receive(:code).and_return('1000')
+      expect { @response.return! }.to raise_error RestClient::RequestFailed
     end
 
     it "should raise an error on a redirection after non-GET/HEAD requests" do
-      @net_http_res.should_receive(:code).and_return('301')
-      @request.should_receive(:method).and_return('put')
-      @response.should_not_receive(:follow_redirection)
-      lambda { @response.return! }.should raise_error RestClient::RequestFailed
+      expect(@net_http_res).to receive(:code).and_return('301')
+      expect(@request).to receive(:method).and_return('put')
+      expect(@response).not_to receive(:follow_redirection)
+      expect { @response.return! }.to raise_error RestClient::RequestFailed
     end
 
     it "should follow 302 redirect" do
-      @net_http_res.should_receive(:code).and_return('302')
-      @response.should_receive(:check_max_redirects).and_return('fake-check')
-      @response.should_receive(:follow_redirection).and_return('fake-redirection')
-      @response.return!.should eq 'fake-redirection'
+      expect(@net_http_res).to receive(:code).and_return('302')
+      expect(@response).to receive(:check_max_redirects).and_return('fake-check')
+      expect(@response).to receive(:follow_redirection).and_return('fake-redirection')
+      expect(@response.return!).to eq 'fake-redirection'
     end
 
     it "should gracefully handle 302 redirect with no location header" do
       @net_http_res = response_double(code: 302, location: nil)
       @request = request_double()
       @response = MyAbstractResponse.new(@net_http_res, @request)
-      @response.should_receive(:check_max_redirects).and_return('fake-check')
-      lambda { @response.return! }.should raise_error RestClient::Found
+      expect(@response).to receive(:check_max_redirects).and_return('fake-check')
+      expect { @response.return! }.to raise_error RestClient::Found
     end
   end
 end