arachni 1.2.1 → 1.3

data/spec/arachni/http/cookie_jar_spec.rb

@@ -11,8 +11,8 @@ describe Arachni::HTTP::CookieJar do
         it 'loads cookies from a Netscape cookie-jar file' do
             j = subject.class.from_file( cookiejar_file )
             cookies = j.cookies
-            cookies.size.should == 4
-            cookies.should == cookies
+            expect(cookies.size).to eq(4)
+            expect(cookies).to eq(cookies)
         end
 
         context 'when the provided file does not exist' do
@@ -29,15 +29,15 @@ describe Arachni::HTTP::CookieJar do
 
     describe '#initialize' do
         it 'returns a new instance' do
-            Arachni::HTTP::CookieJar.new.is_a?( Arachni::HTTP::CookieJar ).should be_true
+            expect(Arachni::HTTP::CookieJar.new.is_a?( Arachni::HTTP::CookieJar )).to be_truthy
         end
 
         context 'when a cookiejer option has been provided' do
             it 'loads cookies from a Netscape cookie-jar file' do
                 j = subject.class.from_file( cookiejar_file )
                 cookies = j.cookies
-                cookies.size.should == 4
-                cookies.should == Arachni::Utilities.cookies_from_file( '', cookiejar_file )
+                expect(cookies.size).to eq(4)
+                expect(cookies).to eq(Arachni::Utilities.cookies_from_file( '', cookiejar_file ))
             end
         end
 
@@ -51,28 +51,28 @@ describe Arachni::HTTP::CookieJar do
     describe '#<<' do
         context 'when a cookie with that name does not already exist' do
             it 'adds the cookie to the jar' do
-                subject.empty?.should be_true
+                expect(subject.empty?).to be_truthy
 
-                (subject << cookie).should == subject
-                subject.cookies.first.should == cookie
+                expect(subject << cookie).to eq(subject)
+                expect(subject.cookies.first).to eq(cookie)
 
-                subject.empty?.should be_false
+                expect(subject.empty?).to be_falsey
             end
         end
         context 'when a cookie with that name already exists' do
             it 'updates the jar (i.e. replace the cookie)' do
-                subject.empty?.should be_true
+                expect(subject.empty?).to be_truthy
 
-                (subject << cookie).should == subject
-                subject.cookies.first.should == cookie
+                expect(subject << cookie).to eq(subject)
+                expect(subject.cookies.first).to eq(cookie)
 
                 c = cookie.dup
                 c.inputs = { c.name => 'my val' }
 
-                (subject << c).should == subject
-                subject.cookies.first.should == c
+                expect(subject << c).to eq(subject)
+                expect(subject.cookies.first).to eq(c)
 
-                subject.empty?.should be_false
+                expect(subject.empty?).to be_falsey
             end
         end
     end
@@ -80,26 +80,26 @@ describe Arachni::HTTP::CookieJar do
     describe '#update' do
         context 'when cookies with the same name do not already exist' do
             it 'adds the cookies to the jar' do
-                subject.empty?.should be_true
+                expect(subject.empty?).to be_truthy
 
-                subject.update( cookies ).should == subject
-                subject.cookies.should == cookies
+                expect(subject.update( cookies )).to eq(subject)
+                expect(subject.cookies).to eq(cookies)
 
-                subject.empty?.should be_false
+                expect(subject.empty?).to be_falsey
             end
         end
         context 'when cookies with the same name already exist' do
             it 'updates the jar (i.e. replace the cookies)' do
-                subject.empty?.should be_true
+                expect(subject.empty?).to be_truthy
 
-                subject.update( cookies ).should == subject
-                subject.cookies.should == cookies
+                expect(subject.update( cookies )).to eq(subject)
+                expect(subject.cookies).to eq(cookies)
 
                 c = cookies.dup.map { |dc| dc.inputs = { dc.name => dc.name + '-updated' }; dc }
-                subject.update( c ).should == subject
-                subject.cookies.should == c
+                expect(subject.update( c )).to eq(subject)
+                expect(subject.cookies).to eq(c)
 
-                subject.empty?.should be_false
+                expect(subject.empty?).to be_falsey
             end
         end
 
@@ -108,61 +108,61 @@ describe Arachni::HTTP::CookieJar do
                 it 'updates the cookie jar with it' do
                     c = Arachni::Cookie.new( url: 'http://test.com', inputs: { name: 'value' } )
 
-                    subject.should be_empty
+                    expect(subject).to be_empty
 
                     subject.update( c )
-                    subject.cookies.first.name.should == 'name'
-                    subject.cookies.first.value.should == 'value'
+                    expect(subject.cookies.first.name).to eq('name')
+                    expect(subject.cookies.first.value).to eq('value')
                 end
             end
 
             context Hash do
                 it 'converts it to Cookie and update the cookie jar with it' do
-                    subject.should be_empty
+                    expect(subject).to be_empty
 
                     Arachni::Options.url = 'http://test.com'
                     subject.update( name: 'value' )
-                    subject.cookies.first.name.should == 'name'
-                    subject.cookies.first.value.should == 'value'
+                    expect(subject.cookies.first.name).to eq('name')
+                    expect(subject.cookies.first.value).to eq('value')
                 end
             end
 
             context String do
                 it 'parses it into a Cookie and update the cookie jar with it' do
-                    subject.should be_empty
+                    expect(subject).to be_empty
 
                     Arachni::Options.url = 'http://test.com'
                     subject.update( 'name=value' )
-                    subject.cookies.first.name.should == 'name'
-                    subject.cookies.first.value.should == 'value'
+                    expect(subject.cookies.first.name).to eq('name')
+                    expect(subject.cookies.first.value).to eq('value')
                 end
 
                 context 'when in the form of a Set-Cookie header' do
                     it 'parses it into a Cookie and update the cookie jar with it' do
-                        subject.should be_empty
+                        expect(subject).to be_empty
 
                         Arachni::Options.url = 'http://test.com'
                         subject.update( 'some_param=9e4ca2cc0f18a49f7c1881f78bebf7df; path=/; expires=Wed, 02-Oct-2020 23:53:46 GMT; HttpOnly' )
-                        subject.cookies.first.name.should == 'some_param'
-                        subject.cookies.first.value.should == '9e4ca2cc0f18a49f7c1881f78bebf7df'
+                        expect(subject.cookies.first.name).to eq('some_param')
+                        expect(subject.cookies.first.value).to eq('9e4ca2cc0f18a49f7c1881f78bebf7df')
                     end
                 end
 
                 context 'when in the form of a Set-Cookie header' do
                     it 'parses it into a Cookie and update the cookie jar with it' do
-                        subject.should be_empty
+                        expect(subject).to be_empty
 
                         Arachni::Options.url = 'http://test.com'
                         subject.update( 'some_param=9e4ca2cc0f18a49f7c1881f78bebf7df; path=/; expires=Wed, 02-Oct-2020 23:53:46 GMT; HttpOnly' )
-                        subject.cookies.first.name.should == 'some_param'
-                        subject.cookies.first.value.should == '9e4ca2cc0f18a49f7c1881f78bebf7df'
+                        expect(subject.cookies.first.name).to eq('some_param')
+                        expect(subject.cookies.first.value).to eq('9e4ca2cc0f18a49f7c1881f78bebf7df')
                     end
                 end
             end
 
             context Array do
                 it 'iterates and if necessary parses the entries and update the cookie jar with them' do
-                    subject.should be_empty
+                    expect(subject).to be_empty
 
                     Arachni::Options.url = 'http://test.com'
                     subject.update([
@@ -174,19 +174,19 @@ describe Arachni::HTTP::CookieJar do
 
                     cookies = subject.cookies
 
-                    cookies.size.should == 3
+                    expect(cookies.size).to eq(3)
 
                     c = cookies.shift
-                    c.name.should == 'cookie_name'
-                    c.value.should == 'cookie_value'
+                    expect(c.name).to eq('cookie_name')
+                    expect(c.value).to eq('cookie_value')
 
                     c = cookies.shift
-                    c.name.should == 'hash_name'
-                    c.value.should == 'hash_value'
+                    expect(c.name).to eq('hash_name')
+                    expect(c.value).to eq('hash_value')
 
                     c = cookies.shift
-                    c.name.should == 'string_name'
-                    c.value.should == 'string_value'
+                    expect(c.name).to eq('string_name')
+                    expect(c.value).to eq('string_value')
                 end
             end
 
@@ -255,19 +255,19 @@ describe Arachni::HTTP::CookieJar do
 
             subject.update( cookies.values )
 
-            subject.for_url( 'http://domain.com/my/path' ).should == [cookies[:with_path], cookies[:without_path]]
-            subject.for_url( 'http://domain.com/my/path/' ).should == [cookies[:with_path], cookies[:without_path]]
-            subject.for_url( 'http://domain.com' ).should == [cookies[:without_path]]
-            subject.for_url( 'http://domain.com/' ).should == [cookies[:without_path]]
+            expect(subject.for_url( 'http://domain.com/my/path' )).to eq([cookies[:with_path], cookies[:without_path]])
+            expect(subject.for_url( 'http://domain.com/my/path/' )).to eq([cookies[:with_path], cookies[:without_path]])
+            expect(subject.for_url( 'http://domain.com' )).to eq([cookies[:without_path]])
+            expect(subject.for_url( 'http://domain.com/' )).to eq([cookies[:without_path]])
 
-            subject.for_url( 'http://mydomain.com' ).should == [cookies[:another_domain], cookies[:tailmatching]]
-            subject.for_url( 'http://sub.mydomain.com' ).should == [cookies[:tailmatching]]
-            subject.for_url( 'http://deep.sub.mydomain.com' ).should == [cookies[:tailmatching]]
+            expect(subject.for_url( 'http://mydomain.com' )).to eq([cookies[:another_domain], cookies[:tailmatching]])
+            expect(subject.for_url( 'http://sub.mydomain.com' )).to eq([cookies[:tailmatching]])
+            expect(subject.for_url( 'http://deep.sub.mydomain.com' )).to eq([cookies[:tailmatching]])
 
-            subject.for_url( 'http://sub.domain.com' ).should == [cookies[:subdomain], cookies[:subdomain_tailmatching]]
-            subject.for_url( 'http://deeeep.deep.sub.domain.com' ).should == [cookies[:subdomain_tailmatching]]
+            expect(subject.for_url( 'http://sub.domain.com' )).to eq([cookies[:subdomain], cookies[:subdomain_tailmatching]])
+            expect(subject.for_url( 'http://deeeep.deep.sub.domain.com' )).to eq([cookies[:subdomain_tailmatching]])
 
-            subject.for_url( 'http://expired.com' ).should be_empty
+            expect(subject.for_url( 'http://expired.com' )).to be_empty
         end
     end
 
@@ -292,21 +292,21 @@ describe Arachni::HTTP::CookieJar do
         describe 'include_expired' do
             context true do
                 it 'returns all cookies' do
-                    subject.cookies( true ).size.should == 2
+                    expect(subject.cookies( true ).size).to eq(2)
                 end
             end
             context false do
                 it 'returns non expired cookies only' do
                     c = subject.cookies( false )
-                    c.size.should == 1
-                    c.first.name.should == 'my_name'
+                    expect(c.size).to eq(1)
+                    expect(c.first.name).to eq('my_name')
                 end
             end
             context 'nil' do
                 it 'returns non expired cookies only' do
                     c = subject.cookies( false )
-                    c.size.should == 1
-                    c.first.name.should == 'my_name'
+                    expect(c.size).to eq(1)
+                    expect(c.first.name).to eq('my_name')
                 end
             end
         end
@@ -315,23 +315,23 @@ describe Arachni::HTTP::CookieJar do
     describe '#clear' do
         it 'empties the jar' do
             subject.load( cookiejar_file )
-            subject.empty?.should be_false
+            expect(subject.empty?).to be_falsey
             subject.clear
-            subject.empty?.should be_true
+            expect(subject.empty?).to be_truthy
         end
     end
 
     describe '#empty?' do
         context 'when the cookie jar is empty' do
             it 'returns true' do
-                subject.empty?.should be_true
+                expect(subject.empty?).to be_truthy
             end
         end
         context 'when the cookie jar is not empty' do
             it 'returns false' do
-                subject.empty?.should be_true
+                expect(subject.empty?).to be_truthy
                 subject.load( cookiejar_file )
-                subject.empty?.should be_false
+                expect(subject.empty?).to be_falsey
             end
         end
     end
@@ -339,14 +339,14 @@ describe Arachni::HTTP::CookieJar do
     describe '#any?' do
         context 'when the cookie jar is empty' do
             it 'returns false' do
-                subject.any?.should be_false
+                expect(subject.any?).to be_falsey
             end
         end
         context 'when the cookie jar is not empty' do
             it 'returns true' do
-                subject.any?.should be_false
+                expect(subject.any?).to be_falsey
                 subject.load( cookiejar_file )
-                subject.any?.should be_true
+                expect(subject.any?).to be_truthy
             end
         end
     end
@@ -365,7 +365,7 @@ describe Arachni::HTTP::CookieJar do
             subject << c
             subject.merge! other
 
-            subject.cookies.should == [c, other.cookies].flatten
+            expect(subject.cookies).to eq([c, other.cookies].flatten)
         end
     end
 end

data/spec/arachni/http/headers_spec.rb

@@ -15,14 +15,14 @@ describe Arachni::HTTP::Headers do
         end
 
         it 'merges them into an array' do
-            subject['set-cookie'].should == cookies.values
+            expect(subject['set-cookie']).to eq(cookies.values)
         end
     end
 
     describe '#delete' do
         it 'deleted a header field' do
             h = described_class.new( 'x-my-field' => 'stuff' )
-            h.delete( 'X-My-Field' ).should == 'stuff'
+            expect(h.delete( 'X-My-Field' )).to eq('stuff')
         end
     end
 
@@ -30,12 +30,12 @@ describe Arachni::HTTP::Headers do
         context 'when the field is included' do
             it 'returns true' do
                 h = described_class.new( 'X-My-Field' => 'stuff' )
-                h.include?( 'x-my-field' ).should be_true
+                expect(h.include?( 'x-my-field' )).to be_truthy
             end
         end
         context 'when the field is not included' do
             it 'returns false' do
-                described_class.new.include?( 'x-my-field' ).should be_false
+                expect(described_class.new.include?( 'x-my-field' )).to be_falsey
             end
         end
     end
@@ -43,7 +43,7 @@ describe Arachni::HTTP::Headers do
     describe 'set_cookie' do
         context 'when there are no set-cookie fields' do
             it 'returns an empty array' do
-                described_class.new.cookies.should == []
+                expect(described_class.new.cookies).to eq([])
             end
         end
 
@@ -53,24 +53,24 @@ describe Arachni::HTTP::Headers do
                 'name2=value2; Expires=Wed, 09 Jun 2021 10:18:14 GMT'
             ]
 
-            described_class.new( 'Set-Cookie' => set_coookies ).set_cookie.should == set_coookies
+            expect(described_class.new( 'Set-Cookie' => set_coookies ).set_cookie).to eq(set_coookies)
         end
     end
 
     describe 'cookies' do
         context 'when there are no cookies' do
             it 'returns an empty array' do
-                described_class.new.cookies.should == []
+                expect(described_class.new.cookies).to eq([])
             end
         end
 
         it 'returns an array of cookies as hashes' do
-            described_class.new(
+            expect(described_class.new(
                 'Set-Cookie' => [
                     'name=value; Expires=Wed, 09 Jun 2020 10:18:14 GMT',
                     'name2=value2; Expires=Wed, 09 Jun 2021 10:18:14 GMT'
                 ]
-            ).cookies.should == [
+            ).cookies).to eq([
                 {
                     name:         'name',
                     value:        'value',
@@ -101,7 +101,7 @@ describe Arachni::HTTP::Headers do
                     domain:       nil,
                     httponly:     false
                 }
-            ]
+            ])
         end
     end
 
@@ -109,10 +109,10 @@ describe Arachni::HTTP::Headers do
         it 'returns the content-type' do
             ct = 'http://test.com'
             h = { 'location' => ct }
-            described_class.new( h ).location.should == ct
+            expect(described_class.new( h ).location).to eq(ct)
 
             h = { 'Location' => ct }
-            described_class.new( h ).location.should == ct
+            expect(described_class.new( h ).location).to eq(ct)
         end
     end
 
@@ -120,10 +120,10 @@ describe Arachni::HTTP::Headers do
         it 'returns the content-type' do
             ct = 'text/html'
             h = { 'content-type' => ct }
-            described_class.new( h ).content_type.should == ct
+            expect(described_class.new( h ).content_type).to eq(ct)
 
             h = { 'Content-Type' => ct }
-            described_class.new( h ).content_type.should == ct
+            expect(described_class.new( h ).content_type).to eq(ct)
         end
     end
 end

data/spec/arachni/http/proxy_server_spec.rb

@@ -29,7 +29,7 @@ describe Arachni::HTTP::ProxyServer do
     end
 
     def test_proxy( proxy )
-        via_proxy( proxy, @url ).body.should == 'GET'
+        expect(via_proxy( proxy, @url ).body).to eq('GET')
     end
 
     it 'supports SSL interception' do
@@ -38,7 +38,7 @@ describe Arachni::HTTP::ProxyServer do
         proxy = described_class.new
         proxy.start_async
 
-        via_proxy( proxy, url ).body.should == 'HTTPS GET'
+        expect(via_proxy( proxy, url ).body).to eq('HTTPS GET')
     end
 
     it 'removes any size limits on the HTTP responses' do
@@ -57,7 +57,7 @@ describe Arachni::HTTP::ProxyServer do
                 proxy = described_class.new( address: address )
                 proxy.start_async
 
-                proxy.address.split( ':' ).first.should == address
+                expect(proxy.address.split( ':' ).first).to eq(address)
                 test_proxy proxy
             end
         end
@@ -69,7 +69,7 @@ describe Arachni::HTTP::ProxyServer do
                 proxy = described_class.new( port: port )
                 proxy.start_async
 
-                proxy.address.split( ':' ).last.should == port.to_s
+                expect(proxy.address.split( ':' ).last).to eq(port.to_s)
                 test_proxy proxy
             end
         end
@@ -81,8 +81,8 @@ describe Arachni::HTTP::ProxyServer do
 
                 sleep_url = @url + 'sleep'
 
-                Typhoeus::Request.get( sleep_url ).code.should_not == 0
-                via_proxy( proxy, sleep_url ).code.should == 0
+                expect(Typhoeus::Request.get( sleep_url ).code).not_to eq(0)
+                expect(via_proxy( proxy, sleep_url ).code).to eq(0)
             end
         end
 
@@ -98,7 +98,7 @@ describe Arachni::HTTP::ProxyServer do
                     threads << Thread.new { via_proxy( proxy, sleep_url ) }
                 end
                 threads.each(&:join)
-                (Time.now - time).to_i.should == 5
+                expect((Time.now - time).to_i).to eq(5)
 
                 proxy = described_class.new( concurrency: 1 )
                 proxy.start_async
@@ -108,7 +108,7 @@ describe Arachni::HTTP::ProxyServer do
                     threads << Thread.new { via_proxy( proxy, sleep_url ) }
                 end
                 threads.each(&:join)
-                (Time.now - time).to_i.should == 10
+                expect((Time.now - time).to_i).to eq(10)
             end
         end
 
@@ -117,42 +117,42 @@ describe Arachni::HTTP::ProxyServer do
                 called = false
                 proxy = described_class.new(
                     request_handler: proc do |request, _|
-                        request.should be_kind_of Arachni::HTTP::Request
+                        expect(request).to be_kind_of Arachni::HTTP::Request
                         called = true
                     end
                 )
                 proxy.start_async
                 test_proxy proxy
 
-                called.should be_true
+                expect(called).to be_truthy
             end
 
             it 'sets a block to handle each HTTP response before the request is forwarded to the origin server' do
                 called = false
                 proxy = described_class.new(
                     request_handler: proc do |_, response|
-                        response.should be_kind_of Arachni::HTTP::Response
+                        expect(response).to be_kind_of Arachni::HTTP::Response
                         called = true
                     end
                 )
                 proxy.start_async
                 test_proxy proxy
 
-                called.should be_true
+                expect(called).to be_truthy
             end
 
             it 'assigns the request to the response' do
                 called = false
                 proxy = described_class.new(
                     request_handler: proc do |_, response|
-                        response.request.should be_kind_of Arachni::HTTP::Request
+                        expect(response.request).to be_kind_of Arachni::HTTP::Request
                         called = true
                     end
                 )
                 proxy.start_async
                 test_proxy proxy
 
-                called.should be_true
+                expect(called).to be_truthy
             end
 
             it 'fills in raw request data' do
@@ -166,7 +166,7 @@ describe Arachni::HTTP::ProxyServer do
                 proxy.start_async
                 post_via_proxy( proxy, @url )
 
-                request.headers_string.should ==
+                expect(request.headers_string).to eq(
                     "POST / HTTP/1.1\r\n" <<
                     "Accept-Encoding: gzip, deflate\r\n" <<
                     "User-Agent: Typhoeus - https://github.com/typhoeus/typhoeus\r\n" <<
@@ -175,8 +175,9 @@ describe Arachni::HTTP::ProxyServer do
                         "Proxy-Connection: Keep-Alive\r\n" <<
                         "Content-Type: application/x-www-form-urlencoded\r\n" <<
                         "Content-Length: 7\r\n\r\n"
+                )
 
-                request.effective_body.should == '1=2&3=4'
+                expect(request.effective_body).to eq('1=2&3=4')
             end
 
             context 'if the block returns false' do
@@ -184,8 +185,8 @@ describe Arachni::HTTP::ProxyServer do
                     called = false
                     proxy = described_class.new(
                         request_handler: proc do |request, response|
-                            request.should be_kind_of Arachni::HTTP::Request
-                            response.should be_kind_of Arachni::HTTP::Response
+                            expect(request).to be_kind_of Arachni::HTTP::Request
+                            expect(response).to be_kind_of Arachni::HTTP::Response
                             called = true
 
                             response.code = 200
@@ -196,9 +197,9 @@ describe Arachni::HTTP::ProxyServer do
                     )
                     proxy.start_async
 
-                    via_proxy( proxy, @url ).body.should == 'stuff'
+                    expect(via_proxy( proxy, @url ).body).to eq('stuff')
 
-                    called.should be_true
+                    expect(called).to be_truthy
                 end
             end
         end
@@ -208,7 +209,7 @@ describe Arachni::HTTP::ProxyServer do
                 called = false
                 proxy = described_class.new(
                     response_handler: proc do |request, _|
-                        request.should be_kind_of Arachni::HTTP::Request
+                        expect(request).to be_kind_of Arachni::HTTP::Request
                         called = true
                     end
                 )
@@ -216,14 +217,14 @@ describe Arachni::HTTP::ProxyServer do
 
                 test_proxy proxy
 
-                called.should be_true
+                expect(called).to be_truthy
             end
 
             it 'sets a block to handle each HTTP response once the origin server has responded' do
                 called = false
                 proxy = described_class.new(
                     response_handler: proc do |_, response|
-                        response.should be_kind_of Arachni::HTTP::Response
+                        expect(response).to be_kind_of Arachni::HTTP::Response
                         called = true
                     end
                 )
@@ -231,29 +232,29 @@ describe Arachni::HTTP::ProxyServer do
 
                 test_proxy proxy
 
-                called.should be_true
+                expect(called).to be_truthy
             end
 
             it 'assigns the request to the response' do
                 called = false
                 proxy = described_class.new(
                     response_handler: proc do |_, response|
-                        response.request.should be_kind_of Arachni::HTTP::Request
+                        expect(response.request).to be_kind_of Arachni::HTTP::Request
                         called = true
                     end
                 )
                 proxy.start_async
                 test_proxy proxy
 
-                called.should be_true
+                expect(called).to be_truthy
             end
 
             it 'can manipulate the response' do
                 called = false
                 proxy = described_class.new(
                     response_handler: proc do |request, response|
-                        request.should be_kind_of Arachni::HTTP::Request
-                        response.should be_kind_of Arachni::HTTP::Response
+                        expect(request).to be_kind_of Arachni::HTTP::Request
+                        expect(response).to be_kind_of Arachni::HTTP::Response
                         called = true
 
                         response.body = 'stuff'
@@ -263,10 +264,10 @@ describe Arachni::HTTP::ProxyServer do
 
                 response = via_proxy( proxy, @url )
 
-                response.code.should == 200
-                response.body.should == 'stuff'
+                expect(response.code).to eq(200)
+                expect(response.body).to eq('stuff')
 
-                called.should be_true
+                expect(called).to be_truthy
             end
         end
     end
@@ -283,7 +284,7 @@ describe Arachni::HTTP::ProxyServer do
         context 'when the server is not running' do
             it 'returns false' do
                 proxy = described_class.new
-                proxy.running?.should be_false
+                expect(proxy.running?).to be_falsey
             end
         end
 
@@ -291,7 +292,7 @@ describe Arachni::HTTP::ProxyServer do
             it 'returns true' do
                 proxy = described_class.new
                 proxy.start_async
-                proxy.running?.should be_true
+                expect(proxy.running?).to be_truthy
             end
         end
     end
@@ -302,7 +303,7 @@ describe Arachni::HTTP::ProxyServer do
             port    = Arachni::Utilities.available_port
 
             proxy = described_class.new( address: address, port: port )
-            proxy.address.should == "#{address}:#{port}"
+            expect(proxy.address).to eq("#{address}:#{port}")
             proxy.start_async
             test_proxy proxy
         end
@@ -314,10 +315,10 @@ describe Arachni::HTTP::ProxyServer do
                 proxy = described_class.new
                 proxy.start_async
 
-                proxy.has_connections?.should be_false
+                expect(proxy.has_connections?).to be_falsey
                 Thread.new { via_proxy( proxy, @url + 'sleep' ) }
                 sleep 1
-                proxy.has_connections?.should be_true
+                expect(proxy.has_connections?).to be_truthy
             end
         end
 
@@ -326,9 +327,9 @@ describe Arachni::HTTP::ProxyServer do
                 proxy = described_class.new
                 proxy.start_async
 
-                proxy.has_connections?.should be_false
+                expect(proxy.has_connections?).to be_falsey
                 via_proxy( proxy, @url + 'sleep' )
-                proxy.has_connections?.should be_false
+                expect(proxy.has_connections?).to be_falsey
             end
         end
     end
@@ -339,12 +340,12 @@ describe Arachni::HTTP::ProxyServer do
                 proxy = described_class.new
                 proxy.start_async
 
-                proxy.active_connections.should == 0
+                expect(proxy.active_connections).to eq(0)
                 3.times do
                     Thread.new { via_proxy( proxy, @url + 'sleep' ) }
                 end
                 sleep 1
-                proxy.active_connections.should == 3
+                expect(proxy.active_connections).to eq(3)
             end
         end
 
@@ -353,9 +354,9 @@ describe Arachni::HTTP::ProxyServer do
                 proxy = described_class.new
                 proxy.start_async
 
-                proxy.active_connections.should == 0
+                expect(proxy.active_connections).to eq(0)
                 via_proxy( proxy, @url + 'sleep' )
-                proxy.active_connections.should == 0
+                expect(proxy.active_connections).to eq(0)
             end
         end
     end