arachni 1.2.1 → 1.3

data/spec/arachni/framework_spec.rb

@@ -11,18 +11,18 @@ describe Arachni::Framework do
                     ran = true
                 end
 
-                ran.should be_true
+                expect(ran).to be_truthy
             end
 
             it 'resets the framework' do
-                Arachni::Checks.constants.include?( :Taint ).should be_false
+                expect(Arachni::Checks.constants.include?( :Signature )).to be_falsey
 
                 Arachni::Framework.new do |f|
-                    f.checks.load_all.should == %w(taint)
-                    Arachni::Checks.constants.include?( :Taint ).should be_true
+                    expect(f.checks.load_all).to eq(%w(signature))
+                    expect(Arachni::Checks.constants.include?( :Signature )).to be_truthy
                 end
 
-                Arachni::Checks.constants.include?( :Taint ).should be_false
+                expect(Arachni::Checks.constants.include?( :Signature )).to be_falsey
             end
 
             context 'when an exception is raised' do
@@ -35,13 +35,13 @@ describe Arachni::Framework do
 
     describe '#version' do
         it "returns #{Arachni::VERSION}" do
-            subject.version.should == Arachni::VERSION
+            expect(subject.version).to eq(Arachni::VERSION)
         end
     end
 
     describe '#options' do
         it "provides access to #{Arachni::Options}" do
-            subject.options.should be_kind_of Arachni::Options
+            expect(subject.options).to be_kind_of Arachni::Options
         end
     end
 
@@ -49,29 +49,29 @@ describe Arachni::Framework do
         it 'follows redirects' do
             subject.options.url = @f_url + '/redirect'
             subject.run
-            subject.sitemap.should == {
+            expect(subject.sitemap).to eq({
                 "#{@f_url}/redirect"   => 302,
                 "#{@f_url}/redirected" => 200
-            }
+            })
         end
 
         it 'performs the scan' do
             subject.options.url = @url + '/elem_combo'
             subject.options.audit.elements :links, :forms, :cookies
-            subject.checks.load :taint
+            subject.checks.load :signature
             subject.plugins.load :wait
 
             subject.run
-            subject.report.issues.size.should == 3
+            expect(subject.report.issues.size).to eq(3)
 
-            subject.report.plugins[:wait][:results].should == { 'stuff' => true }
+            expect(subject.report.plugins[:wait][:results]).to eq({ 'stuff' => true })
         end
 
         it 'sets #status to scanning' do
             described_class.new do |f|
                 f.options.url = @url + '/elem_combo'
                 f.options.audit.elements :links, :forms, :cookies
-                f.checks.load :taint
+                f.checks.load :signature
 
                 t = Thread.new { f.run }
                 Timeout.timeout( 5 ) do
@@ -82,16 +82,16 @@ describe Arachni::Framework do
         end
 
         it 'handles heavy load' do
-            @options.paths.checks = fixtures_path + '/taint_check/'
+            @options.paths.checks = fixtures_path + '/signature_check/'
 
             Arachni::Framework.new do |f|
                 f.options.url = web_server_url_for :framework_multi
                 f.options.audit.elements :links
 
-                f.checks.load :taint
+                f.checks.load :signature
 
                 f.run
-                f.report.issues.size.should == 500
+                expect(f.report.issues.size).to eq(500)
             end
         end
 
@@ -100,12 +100,14 @@ describe Arachni::Framework do
                 f.options.url = @url + '/with_javascript'
                 f.options.audit.elements :links, :forms, :cookies
 
-                f.checks.load :taint
+                f.checks.load :signature
                 f.run
 
-                f.report.issues.
-                    map { |i| i.variations.first.vector.affected_input_name }.
-                    uniq.sort.should == %w(link_input form_input cookie_input).sort
+                expect(
+                    f.report.issues.
+                        map { |i| i.vector.affected_input_name }.
+                        uniq.sort
+                ).to eq(%w(link_input form_input cookie_input).sort)
             end
         end
 
@@ -114,12 +116,14 @@ describe Arachni::Framework do
                 f.options.url = @url + '/with_ajax'
                 f.options.audit.elements :links, :forms, :cookies
 
-                f.checks.load :taint
+                f.checks.load :signature
                 f.run
 
-                f.report.issues.
-                    map { |i| i.variations.first.vector.affected_input_name }.
-                    uniq.sort.should == %w(link_input form_input cookie_taint).sort
+                expect(
+                    f.report.issues.
+                        map { |i| i.vector.affected_input_name }.
+                        uniq.sort
+                ).to eq(%w(link_input form_input cookie_taint).sort)
             end
         end
 
@@ -128,10 +132,10 @@ describe Arachni::Framework do
                 described_class.new do |f|
                     f.options.url = @url + '/elem_combo'
                     f.options.audit.elements :links, :forms, :cookies
-                    f.checks.load :taint
+                    f.checks.load :signature
 
                     f.run
-                    f.status.should == :done
+                    expect(f.status).to eq(:done)
                 end
             end
         end
@@ -157,7 +161,7 @@ describe Arachni::Framework do
                     f.options.session.check_pattern = 'logged-in user'
 
                     f.run
-                    f.report.issues.size.should == 1
+                    expect(f.report.issues.size).to eq(1)
                 end
             end
         end
@@ -167,12 +171,16 @@ describe Arachni::Framework do
         let(:statistics) { subject.statistics }
 
         it 'includes http statistics' do
-            statistics[:http].should == subject.http.statistics
+            expect(statistics[:http]).to eq(subject.http.statistics)
+        end
+
+        it 'includes browser cluster statistics' do
+            expect(statistics[:browser_cluster]).to eq(Arachni::BrowserCluster.statistics)
         end
 
         [:found_pages, :audited_pages, :current_page].each  do |k|
             it "includes #{k}" do
-                statistics.should include k
+                expect(statistics).to include k
             end
         end
 
@@ -180,13 +188,13 @@ describe Arachni::Framework do
             context 'when the scan has been running' do
                 it 'returns the runtime in seconds' do
                     subject.run
-                    statistics[:runtime].should > 0
+                    expect(statistics[:runtime]).to be > 0
                 end
             end
 
             context 'when no scan has been running' do
                 it 'returns 0' do
-                    statistics[:runtime].should == 0
+                    expect(statistics[:runtime]).to eq(0)
                 end
             end
         end

data/spec/arachni/http/client/dynamic_404_handlers_spec.rb

@@ -22,7 +22,7 @@ describe Arachni::HTTP::Client::Dynamic404Handler do
                 bool = false
                 subject._404?( res ) { |c_bool| bool = c_bool }
                 client.run
-                bool.should be_false
+                expect(bool).to be_falsey
             end
         end
 
@@ -35,7 +35,7 @@ describe Arachni::HTTP::Client::Dynamic404Handler do
                 bool = false
                 subject._404?( res ) { |c_bool| bool = c_bool }
                 client.run
-                bool.should be_true
+                expect(bool).to be_truthy
             end
         end
 
@@ -48,7 +48,7 @@ describe Arachni::HTTP::Client::Dynamic404Handler do
                     subject._404?( response ) { |bool| check = bool }
                     client.run
 
-                    check.should be_nil
+                    expect(check).to be_nil
                 end
             end
 
@@ -60,7 +60,7 @@ describe Arachni::HTTP::Client::Dynamic404Handler do
                     bool = false
                     subject._404?( res ) { |c_bool| bool = c_bool }
                     client.run
-                    bool.should be_true
+                    expect(bool).to be_truthy
                 end
             end
             context 'which includes constantly changing text in the response' do
@@ -71,7 +71,7 @@ describe Arachni::HTTP::Client::Dynamic404Handler do
                     bool = false
                     subject._404?( res ) { |c_bool| bool = c_bool }
                     client.run
-                    bool.should be_true
+                    expect(bool).to be_truthy
                 end
             end
             context 'which returns a combination of the above' do
@@ -82,7 +82,7 @@ describe Arachni::HTTP::Client::Dynamic404Handler do
                     bool = false
                     subject._404?( res ) { |c_bool| bool = c_bool }
                     client.run
-                    bool.should be_true
+                    expect(bool).to be_truthy
                 end
             end
 
@@ -97,7 +97,7 @@ describe Arachni::HTTP::Client::Dynamic404Handler do
                         subject._404?( res ) { |c_bool| bool = c_bool }
                         client.run
 
-                        bool.should be_true
+                        expect(bool).to be_truthy
                     end
                 end
             end
@@ -118,7 +118,7 @@ describe Arachni::HTTP::Client::Dynamic404Handler do
                 bool = false
                 subject._404?( res ) { |c_bool| bool = c_bool }
                 client.run
-                bool.should be_true
+                expect(bool).to be_truthy
 
                 fingerprints = 0
                 client.on_complete do
@@ -128,7 +128,7 @@ describe Arachni::HTTP::Client::Dynamic404Handler do
                 res = nil
                 client.get( url + 'static/crap' ) { |c_res| res = c_res }
                 client.run
-                fingerprints.should > 0
+                expect(fingerprints).to be > 0
 
                 overhead = 0
                 client.on_complete do
@@ -138,15 +138,15 @@ describe Arachni::HTTP::Client::Dynamic404Handler do
                 bool = false
                 subject._404?( res ) { |c_bool| bool = c_bool }
                 client.run
-                bool.should be_true
+                expect(bool).to be_truthy
 
-                overhead.should == 0
+                expect(overhead).to eq(0)
             end
         end
 
         context "when the signature cache exceeds #{described_class::CACHE_SIZE} entries" do
             it 'it is pruned as soon as possible' do
-                subject.signatures.should be_empty
+                expect(subject.signatures).to be_empty
 
                 (2 * described_class::CACHE_SIZE).times do |i|
                     client.get( url + "static/#{i}/test" ) do |response|
@@ -155,7 +155,7 @@ describe Arachni::HTTP::Client::Dynamic404Handler do
                 end
                 client.run
 
-                subject.signatures.size.should == described_class::CACHE_SIZE
+                expect(subject.signatures.size).to eq(described_class::CACHE_SIZE)
             end
         end
     end
@@ -172,7 +172,7 @@ describe Arachni::HTTP::Client::Dynamic404Handler do
                     end
                     client.run
 
-                    subject.checked_and_static?( path ).should be_false
+                    expect(subject.checked_and_static?( path )).to be_falsey
                 end
             end
 
@@ -183,14 +183,14 @@ describe Arachni::HTTP::Client::Dynamic404Handler do
                     end
                     client.run
 
-                    subject.checked_and_static?( client.get_path( @url ) ).should be_true
+                    expect(subject.checked_and_static?( client.get_path( @url ) )).to be_truthy
                 end
             end
         end
 
         context 'when the page has not been fingerprinted' do
             it 'returns false' do
-                subject.checked_and_static?( path ).should be_false
+                expect(subject.checked_and_static?( path )).to be_falsey
             end
         end
     end
@@ -206,7 +206,7 @@ describe Arachni::HTTP::Client::Dynamic404Handler do
                     end
                     client.run
 
-                    subject.checked?( url ).should be_true
+                    expect(subject.checked?( url )).to be_truthy
                 end
             end
 
@@ -217,14 +217,14 @@ describe Arachni::HTTP::Client::Dynamic404Handler do
                     end
                     client.run
 
-                    subject.checked?( @url ).should be_true
+                    expect(subject.checked?( @url )).to be_truthy
                 end
             end
         end
 
         context 'when the page has not been fingerprinted' do
             it 'returns false' do
-                subject.checked?( url ).should be_false
+                expect(subject.checked?( url )).to be_falsey
             end
         end
     end
@@ -232,52 +232,52 @@ describe Arachni::HTTP::Client::Dynamic404Handler do
     describe 'needs_check?' do
         context 'when #checked?' do
             context false do
-                before(:each) { subject.stub(:checked?) { false } }
+                before(:each) { allow(subject).to receive(:checked?) { false } }
 
                 it 'returns true' do
-                    subject.needs_check?( @url ).should be_true
+                    expect(subject.needs_check?( @url )).to be_truthy
                 end
 
                 context 'and #checked_and_static?' do
                     context false do
-                        before(:each) { subject.stub(:checked_and_static?) { false } }
+                        before(:each) { allow(subject).to receive(:checked_and_static?) { false } }
 
                         it 'returns true' do
-                            subject.needs_check?( @url ).should be_true
+                            expect(subject.needs_check?( @url )).to be_truthy
                         end
                     end
 
                     context true do
-                        before(:each) { subject.stub(:checked_and_static?) { true } }
+                        before(:each) { allow(subject).to receive(:checked_and_static?) { true } }
 
                         it 'returns true' do
-                            subject.needs_check?( @url ).should be_true
+                            expect(subject.needs_check?( @url )).to be_truthy
                         end
                     end
                 end
             end
 
             context true do
-                before(:each) { subject.stub(:checked?) { true } }
+                before(:each) { allow(subject).to receive(:checked?) { true } }
 
                 it 'returns true' do
-                    subject.needs_check?( @url ).should be_true
+                    expect(subject.needs_check?( @url )).to be_truthy
                 end
 
                 context 'and #checked_and_static?' do
                     context true do
-                        before(:each) { subject.stub(:checked_and_static?) { true } }
+                        before(:each) { allow(subject).to receive(:checked_and_static?) { true } }
 
                         it 'returns false' do
-                            subject.needs_check?( @url ).should be_false
+                            expect(subject.needs_check?( @url )).to be_falsey
                         end
                     end
 
                     context false do
-                        before(:each) { subject.stub(:checked_and_static?) { false } }
+                        before(:each) { allow(subject).to receive(:checked_and_static?) { false } }
 
                         it 'returns true' do
-                            subject.needs_check?( @url ).should be_true
+                            expect(subject.needs_check?( @url )).to be_truthy
                         end
                     end
                 end
@@ -287,7 +287,7 @@ describe Arachni::HTTP::Client::Dynamic404Handler do
 
     describe '.info' do
         it 'returns a hash with an output name' do
-            described_class.info[:name].should == 'Dynamic404Handler'
+            expect(described_class.info[:name]).to eq('Dynamic404Handler')
         end
     end
 end

data/spec/arachni/http/client_spec.rb

@@ -21,18 +21,18 @@ describe Arachni::HTTP::Client do
         body = nil
         subject.get( @opts.url + 'gzip' ) { |res| body = res.body }
         subject.run
-        body.should == 'success'
+        expect(body).to eq('success')
     end
 
     it 'preserves set-cookies' do
         body = nil
         subject.get( @opts.url + 'set_and_preserve_cookies', update_cookies: true )
         subject.run
-        subject.cookies.first.value.should == "=stuf \00 here=="
+        expect(subject.cookies.first.value).to eq("=stuf \00 here==")
 
         subject.get( @opts.url + 'cookies' ) { |res| body = res.body }
         subject.run
-        YAML.load( body ).should == { 'stuff' => "=stuf \00 here==" }
+        expect(YAML.load( body )).to eq({ 'stuff' => "=stuf \00 here==" })
     end
 
     describe '#statistics' do
@@ -42,9 +42,9 @@ describe Arachni::HTTP::Client do
          :total_responses_per_second, :burst_response_time_sum,
          :burst_response_count, :burst_responses_per_second,
          :burst_average_response_time, :total_average_response_time,
-         :max_concurrency].each do |k|
+         :original_max_concurrency, :max_concurrency].each do |k|
             it "includes #{k}" do
-                statistics[k].should == subject.send(k)
+                expect(statistics[k]).to eq(subject.send(k))
             end
         end
 
@@ -58,7 +58,7 @@ describe Arachni::HTTP::Client do
                     code = 0
                     subject.get( "#{@opts.url}auth/simple-chars" ) { |res| code = res.code }
                     subject.run
-                    code.should == 401
+                    expect(code).to eq(401)
 
                     url = Arachni::Utilities.uri_parse( "#{@opts.url}auth/simple-chars" )
                     url.user = 'username'
@@ -68,7 +68,7 @@ describe Arachni::HTTP::Client do
                     body = nil
                     subject.get( @opts.url ) { |res| body = res.body }
                     subject.run
-                    body.should == 'authenticated!'
+                    expect(body).to eq('authenticated!')
                 end
             end
         end
@@ -82,7 +82,7 @@ describe Arachni::HTTP::Client do
                     subject.request( @url + '/fingerprint.php' ) { |c_res| res = c_res }
                     subject.run
 
-                    res.platforms.to_a.should == [:php]
+                    expect(res.platforms.to_a).to eq([:php])
                 end
             end
 
@@ -95,7 +95,7 @@ describe Arachni::HTTP::Client do
                     subject.request( @url + '/fingerprint.php' ) { |c_res| res = c_res }
                     subject.run
 
-                    res.platforms.should be_empty
+                    expect(res.platforms).to be_empty
                 end
             end
         end
@@ -107,14 +107,14 @@ describe Arachni::HTTP::Client do
                 it 'uses it as a max_concurrency' do
                     @opts.http.request_concurrency = 34
                     subject.reset
-                    subject.max_concurrency.should == 34
+                    expect(subject.max_concurrency).to eq(34)
                 end
             end
             context 'nil' do
                 it 'uses a default max concurrency setting' do
                     @opts.http.request_concurrency = nil
                     subject.reset
-                    subject.max_concurrency.should == Arachni::HTTP::Client::MAX_CONCURRENCY
+                    expect(subject.max_concurrency).to eq(Arachni::HTTP::Client::MAX_CONCURRENCY)
                 end
             end
         end
@@ -131,10 +131,10 @@ describe Arachni::HTTP::Client do
                         end
                     end
 
-                    responses.size.should == 10
+                    expect(responses.size).to eq(10)
 
                     subject.run
-                    responses.size.should == 11
+                    expect(responses.size).to eq(11)
                 end
             end
         end
@@ -146,14 +146,14 @@ describe Arachni::HTTP::Client do
                     timed_out = false
                     subject.request( @url + '/sleep' ) { |res| timed_out = res.timed_out? }
                     subject.run
-                    timed_out.should be_false
+                    expect(timed_out).to be_falsey
 
                     @opts.http.request_timeout = 1
                     subject.reset
                     timed_out = false
                     subject.request( @url + '/sleep' ) { |res| timed_out = res.timed_out? }
                     subject.run
-                    timed_out.should be_true
+                    expect(timed_out).to be_truthy
                 end
             end
             context 'nil' do
@@ -161,7 +161,7 @@ describe Arachni::HTTP::Client do
                     timed_out = false
                     subject.request( @url + '/sleep' ) { |res| timed_out = res.timed_out? }
                     subject.run
-                    timed_out.should be_false
+                    expect(timed_out).to be_falsey
                 end
             end
         end
@@ -175,7 +175,7 @@ describe Arachni::HTTP::Client do
                 code = 0
                 subject.get( @opts.url + 'auth/weird-chars' ) { |res| code = res.code }
                 subject.run
-                code.should == 401
+                expect(code).to eq(401)
 
                 Arachni::Options.http.authentication_username,
                     Arachni::Options.http.authentication_password =
@@ -184,8 +184,8 @@ describe Arachni::HTTP::Client do
                 response = nil
                 subject.get( @opts.url + 'auth/weird-chars' ) { |res| response = res }
                 subject.run
-                response.code.should == 200
-                response.body.should == 'authenticated!'
+                expect(response.code).to eq(200)
+                expect(response.body).to eq('authenticated!')
             end
         end
 
@@ -195,8 +195,8 @@ describe Arachni::HTTP::Client do
                 subject.get( @opts.url + 'user-agent' ) { |res| body = res.body }
                 subject.run
 
-                body.should == @opts.http.user_agent
-                @opts.http.user_agent.should == Arachni::OptionGroups::HTTP.defaults[:user_agent]
+                expect(body).to eq(@opts.http.user_agent)
+                expect(@opts.http.user_agent).to eq(Arachni::OptionGroups::HTTP.defaults[:user_agent])
             end
             context String do
                 it 'uses it as a user-agent' do
@@ -207,7 +207,7 @@ describe Arachni::HTTP::Client do
                     body = nil
                     subject.get( @opts.url + 'user-agent' ) { |res| body = res.body }
                     subject.run
-                    body.should == ua
+                    expect(body).to eq(ua)
                 end
             end
         end
@@ -219,7 +219,7 @@ describe Arachni::HTTP::Client do
                     code = nil
                     subject.get( @opts.url + 'redirect', follow_location: true ) { |res| code = res.code }
                     subject.run
-                    code.should == 302
+                    expect(code).to eq(302)
 
                     @opts.http.request_redirect_limit = 10
                     subject.reset
@@ -227,7 +227,7 @@ describe Arachni::HTTP::Client do
                     body = nil
                     subject.get( @opts.url + 'redirect', follow_location: true ) { |res| body = res.body }
                     subject.run
-                    body.should == 'This is the end.'
+                    expect(body).to eq('This is the end.')
                 end
             end
             context 'nil' do
@@ -237,7 +237,7 @@ describe Arachni::HTTP::Client do
                     body = nil
                     subject.get( @opts.url + 'redirect', follow_location: true ) { |res| body = res.body }
                     subject.run
-                    body.should == 'This is the end.'
+                    expect(body).to eq('This is the end.')
                 end
             end
         end
@@ -245,10 +245,10 @@ describe Arachni::HTTP::Client do
 
     describe '#sandbox' do
         it 'preserves state, runs the block and then restores state' do
-            subject.cookies.should be_empty
+            expect(subject.cookies).to be_empty
             subject.get( @opts.url + 'set_and_preserve_cookies', update_cookies: true )
             subject.run
-            subject.cookies.should be_any
+            expect(subject.cookies).to be_any
 
             headers = subject.headers.dup
 
@@ -260,13 +260,13 @@ describe Arachni::HTTP::Client do
             subject.get( @opts.url + 'out', mode: :sync )
 
             subject.sandbox do
-                subject.cookies.should be_any
+                expect(subject.cookies).to be_any
                 subject.cookie_jar.clear
-                subject.cookies.should be_empty
+                expect(subject.cookies).to be_empty
 
-                subject.headers.should == headers
+                expect(subject.headers).to eq(headers)
                 subject.headers['X-Custom'] = 'stuff'
-                subject.headers.include?( 'X-Custom' ).should be_true
+                expect(subject.headers.include?( 'X-Custom' )).to be_truthy
 
                 subject.on_complete do |r|
                     signals << :in
@@ -278,24 +278,24 @@ describe Arachni::HTTP::Client do
             subject.get( @opts.url + 'out', mode: :sync )
 
             signals.delete( :out )
-            signals.size.should == 1
+            expect(signals.size).to eq(1)
 
-            subject.headers.include?( 'X-Custom' ).should be_false
-            subject.cookies.should be_any
+            expect(subject.headers.include?( 'X-Custom' )).to be_falsey
+            expect(subject.cookies).to be_any
         end
     end
 
     describe '#url' do
         it 'returns the URL in opts' do
-            subject.url.should == @opts.url.to_s
+            expect(subject.url).to eq(@opts.url.to_s)
         end
     end
 
     describe '#headers' do
         it 'provides access to default headers' do
             headers = subject.headers
-            headers['Accept'].should == 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'
-            headers['User-Agent'].should == 'Arachni/v' + Arachni::VERSION
+            expect(headers['Accept']).to eq('text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8')
+            expect(headers['User-Agent']).to eq('Arachni/v' + Arachni::VERSION)
         end
 
         context "when #{Arachni::OptionGroups::HTTP}#request_headers is set" do
@@ -306,9 +306,9 @@ describe Arachni::HTTP::Client do
                 }
                 subject.reset
                 headers = subject.headers
-                headers['From'].should == @opts.http.request_headers['From']
-                headers['Accept'].should == 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'
-                headers['User-Agent'].should == @opts.http.request_headers['User-Agent']
+                expect(headers['From']).to eq(@opts.http.request_headers['From'])
+                expect(headers['Accept']).to eq('text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8')
+                expect(headers['User-Agent']).to eq(@opts.http.request_headers['User-Agent'])
             end
         end
 
@@ -316,24 +316,24 @@ describe Arachni::HTTP::Client do
             it 'includes it in the From field' do
                 @opts.authorized_by = 'The Dude'
                 subject.reset
-                subject.headers['From'].should == @opts.authorized_by
+                expect(subject.headers['From']).to eq(@opts.authorized_by)
             end
         end
     end
 
     describe '#cookie_jar' do
         it 'provides access to the Cookie-jar' do
-            subject.cookie_jar.is_a?( Arachni::HTTP::CookieJar ).should be_true
+            expect(subject.cookie_jar.is_a?( Arachni::HTTP::CookieJar )).to be_truthy
         end
 
         context "when #{Arachni::OptionGroups::HTTP}#cookie_jar_filepath is set" do
             it 'adds the contained cookies to the CookieJar' do
                 @opts.http.cookie_jar_filepath = fixtures_path + 'cookies.txt'
-                subject.cookie_jar.cookies.should be_empty
+                expect(subject.cookie_jar.cookies).to be_empty
                 subject.reset
                 cookies = subject.cookie_jar.cookies
-                cookies.size.should == 4
-                cookies.should == Arachni::Utilities.cookies_from_file( '', @opts.http.cookie_jar_filepath )
+                expect(cookies.size).to eq(4)
+                expect(cookies).to eq(Arachni::Utilities.cookies_from_file( '', @opts.http.cookie_jar_filepath ))
             end
             context 'but the path is invalid' do
                 it 'raises Arachni::HTTP::CookieJar::Error::CookieJarFileNotFound' do
@@ -350,33 +350,33 @@ describe Arachni::HTTP::Client do
                     'cookie2' => 'val2',
                 }
 
-                subject.cookie_jar.cookies.should be_empty
+                expect(subject.cookie_jar.cookies).to be_empty
 
                 subject.reset
 
                 cookies = subject.cookie_jar.cookies
-                cookies.size.should == 2
+                expect(cookies.size).to eq(2)
 
-                cookies[0].inputs.should == { 'cookie1' => 'val1' }
-                cookies[1].inputs.should == { 'cookie2' => 'val2' }
+                expect(cookies[0].inputs).to eq({ 'cookie1' => 'val1' })
+                expect(cookies[1].inputs).to eq({ 'cookie2' => 'val2' })
             end
         end
 
         context "when #{Arachni::OptionGroups::HTTP}#cookie_string is set" do
             it 'parses the string and add those cookies to the CookieJar' do
                 @opts.http.cookie_string = 'my_cookie_name=val1;blah_name=val2; stuff=%25blah; another_name=another_val'
-                subject.cookie_jar.cookies.should be_empty
+                expect(subject.cookie_jar.cookies).to be_empty
                 subject.reset
                 cookies = subject.cookie_jar.cookies
-                cookies.size.should == 4
-                cookies.first.name.should == 'my_cookie_name'
-                cookies.first.value.should == 'val1'
-                cookies[1].name.should == 'blah_name'
-                cookies[1].value.should == 'val2'
-                cookies[2].name.should == 'stuff'
-                cookies[2].value.should == '%blah'
-                cookies.last.name.should == 'another_name'
-                cookies.last.value.should == 'another_val'
+                expect(cookies.size).to eq(4)
+                expect(cookies.first.name).to eq('my_cookie_name')
+                expect(cookies.first.value).to eq('val1')
+                expect(cookies[1].name).to eq('blah_name')
+                expect(cookies[1].value).to eq('val2')
+                expect(cookies[2].name).to eq('stuff')
+                expect(cookies[2].value).to eq('%blah')
+                expect(cookies.last.name).to eq('another_name')
+                expect(cookies.last.value).to eq('another_val')
             end
         end
     end
@@ -384,10 +384,10 @@ describe Arachni::HTTP::Client do
     describe '#cookies' do
         it 'returns the current cookies' do
             @opts.http.cookie_string = 'my_cookie_name=val1;blah_name=val2; another_name=another_val'
-            subject.cookie_jar.cookies.should be_empty
+            expect(subject.cookie_jar.cookies).to be_empty
             subject.reset
-            subject.cookies.size.should == 3
-            subject.cookies.should == subject.cookie_jar.cookies
+            expect(subject.cookies.size).to eq(3)
+            expect(subject.cookies).to eq(subject.cookie_jar.cookies)
         end
     end
 
@@ -396,11 +396,11 @@ describe Arachni::HTTP::Client do
             called = false
             subject.after_run { called = true }
             subject.run
-            called.should be_true
+            expect(called).to be_truthy
 
             called = false
             subject.run
-            called.should be_false
+            expect(called).to be_falsey
         end
 
         context 'when the callback creates new requests' do
@@ -412,11 +412,11 @@ describe Arachni::HTTP::Client do
                     end
                 end
                 subject.run
-                called.should be_true
+                expect(called).to be_truthy
 
                 called = false
                 subject.run
-                called.should be_false
+                expect(called).to be_falsey
             end
         end
 
@@ -427,7 +427,7 @@ describe Arachni::HTTP::Client do
                     subject.after_run { called = true }
                 end
                 subject.run
-                called.should be_true
+                expect(called).to be_truthy
             end
         end
     end
@@ -439,39 +439,39 @@ describe Arachni::HTTP::Client do
 
             subject.run
 
-            response.should be_kind_of Arachni::HTTP::Response
+            expect(response).to be_kind_of Arachni::HTTP::Response
         end
 
         it 'returns true' do
-            subject.run.should be_true
+            expect(subject.run).to be_truthy
         end
 
         it 'calls the after_each_run callbacks EVERY TIME' do
             called = false
             subject.after_each_run { called = true }
             subject.run
-            called.should be_true
+            expect(called).to be_truthy
             called = false
             subject.run
-            called.should be_true
+            expect(called).to be_truthy
         end
 
         it 'calculates the burst average response time' do
             subject.run
-            subject.burst_runtime.should > 0
+            expect(subject.burst_runtime).to be > 0
         end
 
         it 'updates burst_response_time_sum, burst_response_count,' +
                ' burst_average_response_time and burst_responses_per_second' +
                ' during runtime and resets them afterwards' do
-            subject.total_runtime.to_i.should          == 0
-            subject.total_average_response_time.should == 0
-            subject.total_responses_per_second.should  == 0
+            expect(subject.total_runtime.to_i).to          eq(0)
+            expect(subject.total_average_response_time).to eq(0)
+            expect(subject.total_responses_per_second).to  eq(0)
 
-            subject.burst_response_time_sum.should     == 0
-            subject.burst_response_count.should        == 0
-            subject.burst_average_response_time.should == 0
-            subject.burst_responses_per_second.should  == 0
+            expect(subject.burst_response_time_sum).to     eq(0)
+            expect(subject.burst_response_count).to        eq(0)
+            expect(subject.burst_average_response_time).to eq(0)
+            expect(subject.burst_responses_per_second).to  eq(0)
 
             total_runtime               = 0
             total_average_response_time = 0
@@ -497,21 +497,21 @@ describe Arachni::HTTP::Client do
 
             subject.run
 
-            total_runtime.should               > 0
-            total_average_response_time.should > 0
-            total_responses_per_second.should  > 0
+            expect(total_runtime).to               be > 0
+            expect(total_average_response_time).to be > 0
+            expect(total_responses_per_second).to  be > 0
 
-            burst_response_time_sum.should     > 0
-            burst_response_count.should        > 0
-            burst_average_response_time.should > 0
-            burst_responses_per_second.should  > 0
+            expect(burst_response_time_sum).to     be > 0
+            expect(burst_response_count).to        be > 0
+            expect(burst_average_response_time).to be > 0
+            expect(burst_responses_per_second).to  be > 0
         end
 
         context "when a #{RuntimeError} occurs" do
             it 'returns nil' do
-                subject.instance.stub(:client_run){ raise }
+                allow(subject.instance).to receive(:client_run){ raise }
 
-                subject.run.should be_nil
+                expect(subject.run).to be_nil
             end
         end
     end
@@ -527,26 +527,36 @@ describe Arachni::HTTP::Client do
                 end
             end
             subject.run
-            cnt.should < n
+            expect(cnt).to be < n
+        end
+    end
+
+    describe '#original_max_concurrency' do
+        it 'returns the original max concurrency' do
+            expect(subject.original_max_concurrency).to eq(20)
+            expect(subject.original_max_concurrency).to eq(subject.max_concurrency)
+
+            subject.max_concurrency = 10
+            expect(subject.original_max_concurrency).to eq(20)
         end
     end
 
     describe '#max_concurrency' do
         it 'defaults to 20' do
-            subject.max_concurrency.should == 20
+            expect(subject.max_concurrency).to eq(20)
         end
         it 'respects the http_request_concurrency option' do
             @opts.http.request_concurrency = 50
             subject.reset
-            subject.max_concurrency.should == 50
+            expect(subject.max_concurrency).to eq(50)
         end
     end
 
     describe '#max_concurrency=' do
         it 'sets the max_concurrency setting' do
-            subject.max_concurrency.should_not == 30
+            expect(subject.max_concurrency).not_to eq(30)
             subject.max_concurrency = 30
-            subject.max_concurrency.should == 30
+            expect(subject.max_concurrency).to eq(30)
         end
     end
 
@@ -555,7 +565,7 @@ describe Arachni::HTTP::Client do
             url = nil
             subject.request{ |res| url = res.url }
             subject.run
-            url.start_with?( @opts.url.to_s ).should be_true
+            expect(url.start_with?( @opts.url.to_s )).to be_truthy
         end
 
         it 'raises exception when no URL is available' do
@@ -566,21 +576,22 @@ describe Arachni::HTTP::Client do
 
         it "fills in #{Arachni::HTTP::Request}#headers_string" do
             host = "#{Arachni::URI(@url).host}:#{Arachni::URI(@url).port}"
-            subject.request( @url, mode: :sync ).request.headers_string.should ==
+            expect(subject.request( @url, mode: :sync ).request.headers_string).to eq(
                 "GET / HTTP/1.1\r\nHost: #{host}\r\nAccept-Encoding: gzip, " +
                     "deflate\r\nUser-Agent: Arachni/v#{Arachni::VERSION}\r\nAccept: text/html," +
                     "application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n\r\n"
+            )
         end
 
         it "fills in #{Arachni::HTTP::Request}#effective_body" do
-            subject.request( @url,
+            expect(subject.request( @url,
                body: {
                    '1' => ' 2',
                    ' 3' => '4'
                },
                mode:   :sync,
                method: :post
-            ).request.effective_body.should == "1=%202&%203=4"
+            ).request.effective_body).to eq("1=%202&%203=4")
         end
 
         describe :fingerprint do
@@ -594,7 +605,7 @@ describe Arachni::HTTP::Client do
                     subject.request( @url + '/fingerprint.php' ) { |c_res| res = c_res }
                     subject.run
 
-                    res.platforms.to_a.should == [:php]
+                    expect(res.platforms.to_a).to eq([:php])
                 end
             end
 
@@ -604,7 +615,7 @@ describe Arachni::HTTP::Client do
                     subject.request( @url + '/fingerprint.php', fingerprint: true ) { |c_res| res = c_res }
                     subject.run
 
-                    res.platforms.to_a.should == [:php]
+                    expect(res.platforms.to_a).to eq([:php])
                 end
             end
 
@@ -614,7 +625,7 @@ describe Arachni::HTTP::Client do
                     subject.request( @url + '/fingerprint.php', fingerprint: false ) { |c_res| res = c_res }
                     subject.run
 
-                    res.platforms.should be_empty
+                    expect(res.platforms).to be_empty
                 end
             end
         end
@@ -625,28 +636,28 @@ describe Arachni::HTTP::Client do
                     context 'when response bodies are larger that its value' do
                         it 'ignores them' do
                             @opts.http.response_max_size = 0
-                            subject.request( @url + '/http_response_max_size',
+                            expect(subject.request( @url + '/http_response_max_size',
                                              mode: :sync
-                            ).body.should be_empty
+                            ).body).to be_empty
 
                             @opts.http.response_max_size = 1
-                            subject.request( @url + '/http_response_max_size',
+                            expect(subject.request( @url + '/http_response_max_size',
                                              mode: :sync
-                            ).body.should be_empty
+                            ).body).to be_empty
 
                             @opts.http.response_max_size = 999999
-                            subject.request( @url + '/http_response_max_size',
+                            expect(subject.request( @url + '/http_response_max_size',
                                              mode: :sync
-                            ).body.should be_empty
+                            ).body).to be_empty
                         end
                     end
 
                     context 'when response bodies are not larger that its value' do
                         it 'reads them' do
                             @opts.http.response_max_size = 1000000
-                            subject.request( @url + '/http_response_max_size',
+                            expect(subject.request( @url + '/http_response_max_size',
                                              mode: :sync
-                            ).body.should_not be_empty
+                            ).body).not_to be_empty
                         end
                     end
                 end
@@ -655,29 +666,29 @@ describe Arachni::HTTP::Client do
             context 'when specified' do
                 context 'when response bodies are larger that its value' do
                     it 'ignores them' do
-                        subject.request( @url + '/http_response_max_size',
+                        expect(subject.request( @url + '/http_response_max_size',
                                          mode: :sync,
                                          response_max_size: 0
-                        ).body.should be_empty
+                        ).body).to be_empty
 
-                        subject.request( @url + '/http_response_max_size',
+                        expect(subject.request( @url + '/http_response_max_size',
                                          mode: :sync,
                                          response_max_size: 1
-                        ).body.should be_empty
+                        ).body).to be_empty
 
-                        subject.request( @url + '/http_response_max_size',
+                        expect(subject.request( @url + '/http_response_max_size',
                                          mode: :sync,
                                          response_max_size: 999999
-                        ).body.should be_empty
+                        ).body).to be_empty
                     end
                 end
 
                 context 'when response bodies are not larger that its value' do
                     it 'reads them' do
-                        subject.request( @url + '/http_response_max_size',
+                        expect(subject.request( @url + '/http_response_max_size',
                                          mode: :sync,
                                          response_max_size: 1000000
-                        ).body.should_not be_empty
+                        ).body).not_to be_empty
                     end
                 end
 
@@ -688,30 +699,30 @@ describe Arachni::HTTP::Client do
                                          response_max_size: 0
                         )
 
-                        r.headers.should_not include 'Content-Type'
-                        r.body.should be_empty
+                        expect(r.headers).not_to include 'Content-Type'
+                        expect(r.body).to be_empty
 
                         r = subject.request( @url + '/http_response_max_size/without_content_length',
                                          mode: :sync,
                                          response_max_size: 1
                         )
-                        r.headers.should_not include 'Content-Type'
-                        r.body.should be_empty
+                        expect(r.headers).not_to include 'Content-Type'
+                        expect(r.body).to be_empty
 
                         r = subject.request( @url + '/http_response_max_size/without_content_length',
                                          mode: :sync,
                                          response_max_size: 999999
                         )
-                        r.headers.should_not include 'Content-Type'
-                        r.body.should be_empty
+                        expect(r.headers).not_to include 'Content-Type'
+                        expect(r.body).to be_empty
 
                         r = subject.request( @url + '/http_response_max_size/without_content_length',
                                          mode: :sync,
                                          response_max_size: 1000000
                         )
 
-                        r.headers.should_not include 'Content-Type'
-                        r.body.should_not be_empty
+                        expect(r.headers).not_to include 'Content-Type'
+                        expect(r.body).not_to be_empty
                     end
                 end
             end
@@ -719,10 +730,10 @@ describe Arachni::HTTP::Client do
             context 'when < 0' do
                 it 'does not enforce a limit' do
                     @opts.http.response_max_size = 0
-                    subject.request( @url + '/http_response_max_size',
+                    expect(subject.request( @url + '/http_response_max_size',
                                    mode: :sync,
                                    response_max_size: -1
-                    ).body.should_not be_empty
+                    ).body).not_to be_empty
                 end
             end
 
@@ -731,32 +742,32 @@ describe Arachni::HTTP::Client do
                                      mode: :sync,
                                      response_max_size: 0
                 ) do |r|
-                    r.headers.should_not include 'Content-Type'
-                    r.body.should be_empty
+                    expect(r.headers).not_to include 'Content-Type'
+                    expect(r.body).to be_empty
                 end
 
                 subject.request( @url + '/http_response_max_size/without_content_length',
                                  mode: :sync,
                                  response_max_size: 1
                 ) do |r|
-                    r.headers.should_not include 'Content-Type'
-                    r.body.should be_empty
+                    expect(r.headers).not_to include 'Content-Type'
+                    expect(r.body).to be_empty
                 end
 
                 subject.request( @url + '/http_response_max_size/without_content_length',
                                  mode: :sync,
                                  response_max_size: 999999
                 ) do |r|
-                    r.headers.should_not include 'Content-Type'
-                    r.body.should be_empty
+                    expect(r.headers).not_to include 'Content-Type'
+                    expect(r.body).to be_empty
                 end
 
                 subject.request( @url + '/http_response_max_size/without_content_length',
                                  mode: :sync,
                                  response_max_size: 1000000
                 ) do |r|
-                    r.headers.should_not include 'Content-Type'
-                    r.body.should_not be_empty
+                    expect(r.headers).not_to include 'Content-Type'
+                    expect(r.body).not_to be_empty
                 end
 
                 subject.run
@@ -769,29 +780,29 @@ describe Arachni::HTTP::Client do
                     body = nil
                     subject.request( @url + '/cookies', no_cookie_jar: true ) { |res| body = res.body }
                     subject.run
-                    YAML.load( body ).should == {}
+                    expect(YAML.load( body )).to eq({})
                 end
             end
             context false do
                 it 'uses the cookie_jar' do
                     @opts.http.cookie_string = 'my_cookie_name=val1;blah_name=val2;another_name=another_val'
-                    subject.cookie_jar.cookies.should be_empty
+                    expect(subject.cookie_jar.cookies).to be_empty
                     subject.reset
 
                     body = nil
 
                     subject.request( @url + '/cookies', no_cookie_jar: false ) { |res| body = res.body }
                     subject.run
-                    YAML.load( body ).should == {
+                    expect(YAML.load( body )).to eq({
                         'my_cookie_name' => 'val1',
                         'blah_name' => 'val2',
                         'another_name' => 'another_val'
-                    }
+                    })
                 end
                 context 'when custom cookies are provided' do
                     it 'merges them with the cookie_jar and override it' do
                         @opts.http.cookie_string = 'my_cookie_name=val1;blah_name=val2;another_name=another_val'
-                        subject.cookie_jar.cookies.should be_empty
+                        expect(subject.cookie_jar.cookies).to be_empty
                         subject.reset
 
                         body = nil
@@ -800,30 +811,30 @@ describe Arachni::HTTP::Client do
                         subject.request( @url + '/cookies', cookies: custom_cookies,
                                        no_cookie_jar: false ) { |res| body = res.body }
                         subject.run
-                        YAML.load( body ).should == {
+                        expect(YAML.load( body )).to eq({
                             'my_cookie_name' => 'val1',
                             'blah_name' => 'val3',
                             'another_name' => 'another_val',
                             'newcookie' => 'newval'
-                        }
+                        })
                     end
                 end
             end
             context 'nil' do
                 it 'defaults to false' do
                     @opts.http.cookie_string = 'my_cookie_name=val1;blah_name=val2;another_name=another_val'
-                    subject.cookie_jar.cookies.should be_empty
+                    expect(subject.cookie_jar.cookies).to be_empty
                     subject.reset
 
                     body = nil
 
                     subject.request( @url + '/cookies' ) { |res| body = res.body }
                     subject.run
-                    YAML.load( body ).should == {
+                    expect(YAML.load( body )).to eq({
                         'my_cookie_name' => 'val1',
                         'blah_name' => 'val2',
                         'another_name' => 'another_val'
-                    }
+                    })
                 end
             end
         end
@@ -834,7 +845,7 @@ describe Arachni::HTTP::Client do
                 body = nil
                 subject.request( @url + '/body', method: :post, body: req_body ) { |res| body = res.body }
                 subject.run
-                body.should == req_body
+                expect(body).to eq(req_body)
             end
         end
 
@@ -844,7 +855,7 @@ describe Arachni::HTTP::Client do
                     body = nil
                     subject.request( @url ) { |res| body = res.body }
                     subject.run
-                    body.should == 'GET'
+                    expect(body).to eq('GET')
                 end
             end
             describe :get do
@@ -852,7 +863,7 @@ describe Arachni::HTTP::Client do
                     body = nil
                     subject.request( @url, method: :get ) { |res| body = res.body }
                     subject.run
-                    body.should == 'GET'
+                    expect(body).to eq('GET')
                 end
 
                 context 'when there are both query string and hash params' do
@@ -865,7 +876,7 @@ describe Arachni::HTTP::Client do
                         url = @url + '/echo?param1=value1&param3=value3'
                         subject.request( url, parameters: params, method: :get ){ |res| body = res.body }
                         subject.run
-                        YAML.load( body ).should eq params.merge( 'param3' => 'value3' )
+                        expect(YAML.load( body )).to eq params.merge( 'param3' => 'value3' )
                     end
                 end
             end
@@ -874,7 +885,7 @@ describe Arachni::HTTP::Client do
                     body = nil
                     subject.request( @url, method: :post ) { |res| body = res.body }
                     subject.run
-                    body.should == 'POST'
+                    expect(body).to eq('POST')
                 end
             end
             describe :put do
@@ -882,7 +893,7 @@ describe Arachni::HTTP::Client do
                     body = nil
                     subject.request( @url, method: :put ) { |res| body = res.body }
                     subject.run
-                    body.should == 'PUT'
+                    expect(body).to eq('PUT')
                 end
             end
             describe :options do
@@ -890,7 +901,7 @@ describe Arachni::HTTP::Client do
                     body = nil
                     subject.request( @url, method: :options ) { |res| body = res.body }
                     subject.run
-                    body.should == 'OPTIONS'
+                    expect(body).to eq('OPTIONS')
                 end
             end
             describe :delete do
@@ -898,7 +909,7 @@ describe Arachni::HTTP::Client do
                     body = nil
                     subject.request( @url, method: :delete ) { |res| body = res.body }
                     subject.run
-                    body.should == 'DELETE'
+                    expect(body).to eq('DELETE')
                 end
             end
         end
@@ -909,7 +920,7 @@ describe Arachni::HTTP::Client do
                 params = { 'param' => 'value' }
                 subject.request( @url + '/echo', parameters: params ) { |res| body = res.body }
                 subject.run
-                params.should eq YAML.load( body )
+                expect(params).to eq YAML.load( body )
             end
 
             it 'preserves nullbytes' do
@@ -917,7 +928,7 @@ describe Arachni::HTTP::Client do
                 params = { "pa\0ram" => "v\0alue" }
                 subject.request( @url + '/echo', parameters: params ) { |res| body = res.body }
                 subject.run
-                params.should eq YAML.load( body )
+                expect(params).to eq YAML.load( body )
             end
         end
 
@@ -927,7 +938,7 @@ describe Arachni::HTTP::Client do
                 params = { '% param\ +=&;' => '% value\ +=&;', 'nil' => nil }
                 subject.request( @url + '/echo', method: :post, body: params ) { |res| body = res.body }
                 subject.run
-                YAML.load( body ).should == { '% param\ +=&;' => '% value\ +=&;', 'nil' => '' }
+                expect(YAML.load( body )).to eq({ '% param\ +=&;' => '% value\ +=&;', 'nil' => '' })
             end
 
             it 'preserves nullbytes' do
@@ -935,7 +946,7 @@ describe Arachni::HTTP::Client do
                 params = { "st\0uff" => "test\0" }
                 subject.request( @url + '/echo', method: :post, body: params, ) { |res| body = res.body }
                 subject.run
-                YAML.load( body ).should == params
+                expect(YAML.load( body )).to eq(params)
             end
         end
 
@@ -945,7 +956,7 @@ describe Arachni::HTTP::Client do
                     timed_out = false
                     subject.request( @url + '/sleep' ) { |res| timed_out = res.timed_out? }
                     subject.run
-                    timed_out.should be_false
+                    expect(timed_out).to be_falsey
                 end
             end
             describe Numeric do
@@ -953,12 +964,12 @@ describe Arachni::HTTP::Client do
                     timed_out = false
                     subject.request( @url + '/sleep', timeout: 4_000 ) { |res| timed_out = res.timed_out? }
                     subject.run
-                    timed_out.should be_true
+                    expect(timed_out).to be_truthy
 
                     timed_out = false
                     subject.request( @url + '/sleep', timeout: 6_000 ) { |res| timed_out = res.timed_out? }
                     subject.run
-                    timed_out.should be_false
+                    expect(timed_out).to be_falsey
                 end
             end
         end
@@ -969,7 +980,7 @@ describe Arachni::HTTP::Client do
                 code = 0
                 subject.get( @opts.url + 'auth/weird-chars' ) { |res| code = res.code }
                 subject.run
-                code.should == 401
+                expect(code).to eq(401)
 
                 response = nil
                 subject.get(
@@ -977,8 +988,8 @@ describe Arachni::HTTP::Client do
                     username: 'u se rname$@#@#%$3#@%@#',
                     password: 'p a  :wo\'rd$@#@#%$3#@%@#' ) { |res| response = res }
                 subject.run
-                response.code.should == 200
-                response.body.should == 'authenticated!'
+                expect(response.code).to eq(200)
+                expect(response.body).to eq('authenticated!')
             end
         end
 
@@ -988,23 +999,23 @@ describe Arachni::HTTP::Client do
                 body = nil
                 subject.request( @url + '/cookies', cookies: cookies ) { |res| body = res.body }
                 subject.run
-                YAML.load( body ).should == cookies
+                expect(YAML.load( body )).to eq(cookies)
             end
 
             describe 'nil' do
                 it 'uses te cookies in the CookieJar' do
                     @opts.http.cookie_string = 'my_cookie_name=val1;blah_name=val2;another_name=another_val'
-                    subject.cookie_jar.cookies.should be_empty
+                    expect(subject.cookie_jar.cookies).to be_empty
                     subject.reset
 
                     body = nil
                     subject.request( @url + '/cookies' ) { |res| body = res.body }
                     subject.run
-                    YAML.load( body ).should == {
+                    expect(YAML.load( body )).to eq({
                         'my_cookie_name' => 'val1',
                         'blah_name' => 'val2',
                         'another_name' => 'another_val'
-                    }
+                    })
                 end
 
                 it 'only sends the appropriate cookies for the domain' do
@@ -1022,7 +1033,7 @@ describe Arachni::HTTP::Client do
                     body = nil
                     subject.request( @url + '/cookies' ) { |res| body = res.body }
                     subject.run
-                    YAML.load( body ).should == { 'key2' => 'val2' }
+                    expect(YAML.load( body )).to eq({ 'key2' => 'val2' })
                 end
             end
 
@@ -1032,12 +1043,12 @@ describe Arachni::HTTP::Client do
                     body = nil
                     subject.request( @url + '/cookies', cookies: cookies ) { |res| body = res.body }
                     subject.run
-                    YAML.load( body ).should == cookies
+                    expect(YAML.load( body )).to eq(cookies)
                 end
 
                 it 'merges them with the cookie-jar' do
                     @opts.http.cookie_string = 'my_cookie_name=val1;blah_name=val2;another_name=another_val'
-                    subject.cookie_jar.cookies.should be_empty
+                    expect(subject.cookie_jar.cookies).to be_empty
                     subject.reset
 
                     body = nil
@@ -1049,11 +1060,11 @@ describe Arachni::HTTP::Client do
                     ) { |res| body = res.body }
                     subject.run
 
-                    YAML.load( body ).should == {
+                    expect(YAML.load( body )).to eq({
                         'my_cookie_name' => 'updated_val',
                         'blah_name' => 'val2',
                         'another_name' => 'another_val'
-                    }
+                    })
                 end
 
                 context 'when also given a Cookie header' do
@@ -1070,7 +1081,7 @@ describe Arachni::HTTP::Client do
                         subject.request( @url + '/cookies', options ) { |res| body = res.body }
                         subject.run
 
-                        YAML.load( body ).should == { 'test' => '1', 'name' => 'val' }
+                        expect(YAML.load( body )).to eq({ 'test' => '1', 'name' => 'val' })
                     end
                 end
             end
@@ -1082,7 +1093,7 @@ describe Arachni::HTTP::Client do
                     performed = false
                     subject.request( @url ) { performed = true }
                     subject.run
-                    performed.should be_true
+                    expect(performed).to be_truthy
                 end
             end
             describe :async do
@@ -1090,16 +1101,16 @@ describe Arachni::HTTP::Client do
                     performed = false
                     subject.request( @url, mode: :sync ) { performed = true }
                     subject.run
-                    performed.should be_true
+                    expect(performed).to be_truthy
                 end
             end
             describe :sync do
                 it 'performs the request synchronously and returns the response' do
-                    subject.request( @url, mode: :sync ).should be_kind_of Arachni::HTTP::Response
+                    expect(subject.request( @url, mode: :sync )).to be_kind_of Arachni::HTTP::Response
                 end
 
                 it 'assigns a #request to the returned response' do
-                    subject.request( @url, mode: :sync ).request.should be_kind_of Arachni::HTTP::Request
+                    expect(subject.request( @url, mode: :sync ).request).to be_kind_of Arachni::HTTP::Request
                 end
 
                 context 'when a block is given' do
@@ -1109,8 +1120,8 @@ describe Arachni::HTTP::Client do
                             called << r
                         end
 
-                        response.should be_kind_of Arachni::HTTP::Response
-                        called.should == [response]
+                        expect(response).to be_kind_of Arachni::HTTP::Response
+                        expect(called).to eq([response])
                     end
                 end
             end
@@ -1123,7 +1134,7 @@ describe Arachni::HTTP::Client do
                     subject.request( @url + '/headers' ) { |res| body = res.body }
                     subject.run
                     sent_headers = YAML.load( body )
-                    subject.headers.each { |k, v| sent_headers[k].should == v }
+                    subject.headers.each { |k, v| expect(sent_headers[k]).to eq(v) }
                 end
             end
 
@@ -1134,7 +1145,7 @@ describe Arachni::HTTP::Client do
                     subject.request( @url + '/headers', headers: headers ) { |res| body = res.body }
                     subject.run
                     sent_headers = YAML.load( body )
-                    subject.headers.merge( headers ).each { |k, v| sent_headers[k].should == v }
+                    subject.headers.merge( headers ).each { |k, v| expect(sent_headers[k]).to eq(v) }
                 end
             end
         end
@@ -1150,7 +1161,7 @@ describe Arachni::HTTP::Client do
                     subject.update_cookies( cookies )
                     subject.request( @url + '/update_cookies' )
                     subject.run
-                    subject.cookies.should == cookies
+                    expect(subject.cookies).to eq(cookies)
                 end
             end
 
@@ -1164,7 +1175,7 @@ describe Arachni::HTTP::Client do
                     subject.update_cookies( cookies )
                     subject.request( @url + '/update_cookies', update_cookies: false )
                     subject.run
-                    subject.cookies.should == cookies
+                    expect(subject.cookies).to eq(cookies)
                 end
             end
 
@@ -1180,7 +1191,7 @@ describe Arachni::HTTP::Client do
                     subject.update_cookies( cookies )
                     subject.request( @url + '/update_cookies', update_cookies: true )
                     subject.run
-                    subject.cookies.first.value.should == cookies.first.value + ' [UPDATED!]'
+                    expect(subject.cookies.first.value).to eq(cookies.first.value + ' [UPDATED!]')
                 end
             end
         end
@@ -1191,8 +1202,8 @@ describe Arachni::HTTP::Client do
                     res = nil
                     subject.request( @url + '/follow_location' ) { |c_res| res = c_res }
                     subject.run
-                    res.url.start_with?( @url + '/follow_location' ).should be_true
-                    res.body.should == ''
+                    expect(res.url.start_with?( @url + '/follow_location' )).to be_truthy
+                    expect(res.body).to eq('')
                 end
             end
             describe false do
@@ -1200,8 +1211,8 @@ describe Arachni::HTTP::Client do
                     res = nil
                     subject.request( @url + '/follow_location', follow_location: false ) { |c_res| res = c_res }
                     subject.run
-                    res.url.start_with?( @url + '/follow_location' ).should be_true
-                    res.body.should == ''
+                    expect(res.url.start_with?( @url + '/follow_location' )).to be_truthy
+                    expect(res.body).to eq('')
                 end
             end
             describe true do
@@ -1209,8 +1220,8 @@ describe Arachni::HTTP::Client do
                     res = nil
                     subject.request( @url + '/follow_location', follow_location: true ) { |c_res| res = c_res }
                     subject.run
-                    res.url.should == @url + '/redir_2'
-                    res.body.should == "Welcome to redir_2!"
+                    expect(res.url).to eq(@url + '/redir_2')
+                    expect(res.body).to eq("Welcome to redir_2!")
                 end
             end
         end
@@ -1218,11 +1229,11 @@ describe Arachni::HTTP::Client do
         context 'when cookie-jar lookup fails' do
             it 'only uses the given cookies' do
                 @opts.http.cookie_string = 'my_cookie_name=val1;blah_name=val2;another_name=another_val'
-                subject.cookie_jar.cookies.should be_empty
+                expect(subject.cookie_jar.cookies).to be_empty
                 subject.reset
-                subject.cookie_jar.cookies.should be_any
+                expect(subject.cookie_jar.cookies).to be_any
 
-                subject.cookie_jar.stub(:for_url) { raise }
+                allow(subject.cookie_jar).to receive(:for_url) { raise }
 
                 body = nil
                 subject.request(
@@ -1231,7 +1242,7 @@ describe Arachni::HTTP::Client do
                 ) { |res| body = res.body }
                 subject.run
 
-                YAML.load( body ).should == { 'blah' => 'val' }
+                expect(YAML.load( body )).to eq({ 'blah' => 'val' })
             end
         end
     end
@@ -1241,13 +1252,13 @@ describe Arachni::HTTP::Client do
             body = nil
             subject.get { |res| body = res.body }
             subject.run
-            body.should == 'GET'
+            expect(body).to eq('GET')
         end
     end
 
     describe '#trace' do
         it 'queues a TRACE request' do
-            subject.trace.method.should == :trace
+            expect(subject.trace.method).to eq(:trace)
         end
     end
 
@@ -1256,7 +1267,7 @@ describe Arachni::HTTP::Client do
             body = nil
             subject.post { |res| body = res.body }
             subject.run
-            body.should == 'POST'
+            expect(body).to eq('POST')
         end
 
         it 'passes :parameters as a #request :body' do
@@ -1264,7 +1275,7 @@ describe Arachni::HTTP::Client do
             params = { '% param\ +=&;' => '% value\ +=&;', 'nil' => nil }
             subject.post( @url + '/echo', parameters: params ) { |res| body = res.body }
             subject.run
-            YAML.load( body ).should == { '% param\ +=&;' => '% value\ +=&;', 'nil' => '' }
+            expect(YAML.load( body )).to eq({ '% param\ +=&;' => '% value\ +=&;', 'nil' => '' })
         end
     end
 
@@ -1274,7 +1285,7 @@ describe Arachni::HTTP::Client do
             cookies = { 'name' => "v%+;al\00=" }
             subject.cookie( @url + '/cookies', parameters: cookies ) { |res| body = res.body }
             subject.run
-            YAML.load( body ).should == cookies
+            expect(YAML.load( body )).to eq(cookies)
         end
     end
 
@@ -1284,7 +1295,7 @@ describe Arachni::HTTP::Client do
             headers = { 'name' => 'val' }
             subject.header( @url + '/headers', parameters: headers ) { |res| body = res.body }
             subject.run
-            YAML.load( body )['Name'].should == headers.values.first
+            expect(YAML.load( body )['Name']).to eq(headers.values.first)
         end
     end
 
@@ -1300,7 +1311,7 @@ describe Arachni::HTTP::Client do
             subject.queue request
             subject.run
 
-            r.should be_kind_of Arachni::HTTP::Response
+            expect(r).to be_kind_of Arachni::HTTP::Response
         end
     end
 
@@ -1312,9 +1323,9 @@ describe Arachni::HTTP::Client do
                 inputs: { 'key2' => 'val2' }
             )
 
-            subject.cookies.should be_empty
+            expect(subject.cookies).to be_empty
             subject.update_cookies( cookies )
-            subject.cookies.should == cookies
+            expect(subject.cookies).to eq(cookies)
         end
     end
 
@@ -1335,8 +1346,8 @@ describe Arachni::HTTP::Client do
             end
             subject.parse_and_set_cookies( res )
 
-            callback_cookies.should == cookies
-            callback_response.should == res
+            expect(callback_cookies).to eq(cookies)
+            expect(callback_response).to eq(res)
         end
     end
 
@@ -1349,16 +1360,16 @@ describe Arachni::HTTP::Client do
             )
             res = Arachni::HTTP::Response.new( url: @url, headers: { 'Set-Cookie' => 'name=value' } )
 
-            @opts.http.cookies.should be_empty
-            subject.cookies.should be_empty
+            expect(@opts.http.cookies).to be_empty
+            expect(subject.cookies).to be_empty
             subject.parse_and_set_cookies( res )
-            subject.cookies.should == cookies
+            expect(subject.cookies).to eq(cookies)
         end
     end
 
     describe '.info' do
         it 'returns a hash with an output name' do
-            described_class.info[:name].should == 'HTTP'
+            expect(described_class.info[:name]).to eq('HTTP')
         end
     end