arachni 1.2.1 → 1.3

data/spec/arachni/browser_cluster_spec.rb

@@ -23,7 +23,7 @@ describe Arachni::BrowserCluster do
 
             @cluster = described_class.new
             @cluster.workers.each do |browser|
-                browser.javascript.run('return window.innerWidth').should == 100
+                expect(browser.javascript.run('return window.innerWidth')).to eq(100)
             end
         end
 
@@ -32,20 +32,20 @@ describe Arachni::BrowserCluster do
 
             @cluster = described_class.new
             @cluster.workers.each do |browser|
-                browser.javascript.run('return window.innerHeight').should == 200
+                expect(browser.javascript.run('return window.innerHeight')).to eq(200)
             end
         end
 
         describe :pool_size do
             it 'sets the amount of browsers to instantiate' do
                 @cluster = described_class.new( pool_size: 3 )
-                @cluster.workers.size.should == 3
+                expect(@cluster.workers.size).to eq(3)
             end
 
             it "defaults to #{Arachni::OptionGroups::BrowserCluster}#pool_size" do
                 Arachni::Options.browser_cluster.pool_size = 10
                 @cluster = described_class.new
-                @cluster.workers.size.should == 10
+                expect(@cluster.workers.size).to eq(10)
             end
         end
 
@@ -61,7 +61,7 @@ describe Arachni::BrowserCluster do
                 @cluster.queue( job ){}
                 @cluster.wait
 
-                cj.id.should == job.id
+                expect(cj.id).to eq(job.id)
             end
         end
 
@@ -76,7 +76,7 @@ describe Arachni::BrowserCluster do
 
                 @cluster.queue( job ){}
 
-                cj.id.should == job.id
+                expect(cj.id).to eq(job.id)
                 @cluster.wait
             end
         end
@@ -93,11 +93,36 @@ describe Arachni::BrowserCluster do
                 @cluster.queue( job ){}
                 @cluster.wait
 
-                cj.id.should == job.id
+                expect(cj.id).to eq(job.id)
             end
         end
     end
 
+    describe '.statistics' do
+        it 'includes :queued_job_count' do
+            @cluster = described_class.new
+
+            current = described_class.statistics[:queued_job_count]
+            @cluster.with_browser{}
+            @cluster.with_browser{}
+            @cluster.with_browser{}
+
+            expect(described_class.statistics[:queued_job_count] - current).to eq 3
+        end
+
+        it 'includes :completed_job_count' do
+            @cluster = described_class.new
+
+            current = described_class.statistics[:completed_job_count]
+            @cluster.with_browser{}
+            @cluster.with_browser{}
+            @cluster.with_browser{}
+            @cluster.wait
+
+            expect(described_class.statistics[:completed_job_count] - current).to eq 3
+        end
+    end
+
     describe '#with_browser' do
         it 'provides a worker to the block' do
             worker = nil
@@ -108,7 +133,7 @@ describe Arachni::BrowserCluster do
             end
             @cluster.wait
 
-            worker.should be_kind_of described_class::Worker
+            expect(worker).to be_kind_of described_class::Worker
         end
     end
 
@@ -122,14 +147,14 @@ describe Arachni::BrowserCluster do
             end
             @cluster.wait
 
-            pages.first.body.should include "window._#{@cluster.javascript_token}"
+            expect(pages.first.body).to include "window._#{@cluster.javascript_token}"
         end
     end
 
     describe '#pending_job_counter' do
         it 'returns the amount of pending jobs' do
             @cluster = described_class.new
-            @cluster.pending_job_counter.should == 0
+            expect(@cluster.pending_job_counter).to eq(0)
 
             while_in_progress = []
             @cluster.queue( job ) do
@@ -137,12 +162,12 @@ describe Arachni::BrowserCluster do
             end
             @cluster.wait
 
-            while_in_progress.should be_any
+            expect(while_in_progress).to be_any
             while_in_progress.each do |pending_job_counter|
-                pending_job_counter.should > 0
+                expect(pending_job_counter).to be > 0
             end
 
-            @cluster.pending_job_counter.should == 0
+            expect(@cluster.pending_job_counter).to eq(0)
         end
     end
 
@@ -152,7 +177,7 @@ describe Arachni::BrowserCluster do
             @cluster = described_class.new
 
             @cluster.queue( job ) do |result|
-                result.job.id.should == job.id
+                expect(result.job.id).to eq(job.id)
                 pages << result.page
             end
             @cluster.wait
@@ -175,10 +200,10 @@ describe Arachni::BrowserCluster do
             end
             @cluster.wait
 
-            results.size.should == 1
+            expect(results.size).to eq(1)
             result = results.first
-            result.my_data.should == 'Some stuff'
-            result.job.id.should == custom_job.id
+            expect(result.my_data).to eq('Some stuff')
+            expect(result.job.id).to eq(custom_job.id)
         end
 
         context 'when no callback has been provided' do
@@ -203,7 +228,7 @@ describe Arachni::BrowserCluster do
 
                     job.never_ending = true
                     @cluster.queue( job ) do |result|
-                        result.job.never_ending?.should be_true
+                        expect(result.job.never_ending?).to be_truthy
                         pages << result.page
                     end
                     @cluster.wait
@@ -211,11 +236,11 @@ describe Arachni::BrowserCluster do
 
                     pages = []
                     @cluster.queue( job ) do |result|
-                        result.job.never_ending?.should be_true
+                        expect(result.job.never_ending?).to be_truthy
                         pages << result.page
                     end
                     @cluster.wait
-                    pages.should be_empty
+                    expect(pages).to be_empty
                 end
             end
         end
@@ -437,7 +462,7 @@ describe Arachni::BrowserCluster do
             end
             @cluster.wait
 
-            calls.should > 1
+            expect(calls).to be > 1
 
             @cluster.shutdown
 
@@ -449,7 +474,7 @@ describe Arachni::BrowserCluster do
             end
             @cluster.wait
 
-            calls.should == 1
+            expect(calls).to eq(1)
         end
 
         it 'returns true' do
@@ -461,7 +486,7 @@ describe Arachni::BrowserCluster do
             end
             @cluster.wait
 
-            return_val.should == true
+            expect(return_val).to eq(true)
         end
     end
 
@@ -472,7 +497,7 @@ describe Arachni::BrowserCluster do
                 @cluster.queue( job ) {}
                 @cluster.wait
 
-                @cluster.job_done?( job ).should == true
+                expect(@cluster.job_done?( job )).to eq(true)
             end
         end
 
@@ -481,7 +506,7 @@ describe Arachni::BrowserCluster do
                 @cluster = described_class.new
                 @cluster.queue( job ) { }
 
-                @cluster.job_done?( job ).should == false
+                expect(@cluster.job_done?( job )).to eq(false)
             end
         end
 
@@ -493,7 +518,7 @@ describe Arachni::BrowserCluster do
                 @cluster.queue( job ) {}
                 @cluster.wait
 
-                @cluster.job_done?( job ).should == false
+                expect(@cluster.job_done?( job )).to eq(false)
             end
         end
 
@@ -501,7 +526,7 @@ describe Arachni::BrowserCluster do
             it 'returns true' do
                 @cluster = described_class.new
                 @cluster.job_done( job )
-                @cluster.job_done?( job ).should == true
+                expect(@cluster.job_done?( job )).to eq(true)
             end
         end
 
@@ -522,16 +547,16 @@ describe Arachni::BrowserCluster do
                 pages << result.page
             end
 
-            pages.should be_empty
-            @cluster.done?.should be_false
+            expect(pages).to be_empty
+            expect(@cluster.done?).to be_falsey
             @cluster.wait
-            @cluster.done?.should be_true
-            pages.should be_any
+            expect(@cluster.done?).to be_truthy
+            expect(pages).to be_any
         end
 
         it 'returns self' do
             @cluster = described_class.new
-            @cluster.wait.should == @cluster
+            expect(@cluster.wait).to eq(@cluster)
         end
 
         context 'when the cluster has ben shutdown' do
@@ -548,7 +573,7 @@ describe Arachni::BrowserCluster do
             it 'returns false' do
                 @cluster = described_class.new
                 @cluster.queue( job ) {}
-                @cluster.done?.should be_false
+                expect(@cluster.done?).to be_falsey
             end
         end
 
@@ -556,9 +581,9 @@ describe Arachni::BrowserCluster do
             it 'returns true' do
                 @cluster = described_class.new
                 @cluster.queue( job ) {}
-                @cluster.done?.should be_false
+                expect(@cluster.done?).to be_falsey
                 @cluster.wait
-                @cluster.done?.should be_true
+                expect(@cluster.done?).to be_truthy
             end
         end
 
@@ -577,14 +602,14 @@ describe Arachni::BrowserCluster do
             @cluster.queue( job ) {}
             @cluster.wait
 
-            @cluster.sitemap.
-                reject { |k, v| k.start_with? Arachni::Browser::Javascript::SCRIPT_BASE_URL }.
-                should == {
+            expect(@cluster.sitemap.
+                reject { |k, v| k.start_with? Arachni::Browser::Javascript::SCRIPT_BASE_URL }).
+                to eq({
                     "#{url}explore"   => 200,
                     "#{url}post-ajax" => 404,
                     "#{url}href-ajax" => 200,
                     "#{url}get-ajax?ajax-token=my-token" => 200
-                }
+                })
         end
     end
 

data/spec/arachni/browser_spec.rb

@@ -63,15 +63,15 @@ describe Arachni::Browser do
     describe '.has_executable?' do
         context 'when there is no executable browser' do
             it 'returns false' do
-                Selenium::WebDriver::PhantomJS.stub(:path){ false }
-                described_class.has_executable?.should be_false
+                allow(Selenium::WebDriver::PhantomJS).to receive(:path){ false }
+                expect(described_class.has_executable?).to be_falsey
             end
         end
 
         context 'when there is an executable browser' do
             it 'returns true' do
-                Selenium::WebDriver::PhantomJS.stub(:path){ __FILE__ }
-                described_class.has_executable?.should be_true
+                allow(Selenium::WebDriver::PhantomJS).to receive(:path){ __FILE__ }
+                expect(described_class.has_executable?).to be_truthy
             end
         end
     end
@@ -79,8 +79,8 @@ describe Arachni::Browser do
     describe '.executable' do
         it 'returns the path to the browser executable' do
             stub = __FILE__
-            Selenium::WebDriver::PhantomJS.stub(:path){ stub }
-            described_class.executable.should == stub
+            allow(Selenium::WebDriver::PhantomJS).to receive(:path){ stub }
+            expect(described_class.executable).to eq(stub)
         end
     end
 
@@ -99,7 +99,7 @@ describe Arachni::Browser do
                     Arachni::Options.scope.exclude_path_patterns << /sleep/
 
                     subject.load @url + '/ajax_sleep'
-                    subject.to_page.should be_true
+                    expect(subject.to_page).to be_truthy
                 end
             end
 
@@ -112,7 +112,7 @@ describe Arachni::Browser do
                     Arachni::Options.scope.exclude_path_patterns << /sleep/
 
                     subject.load @url + '/ajax_sleep'
-                    subject.to_page.code.should == 0
+                    expect(subject.to_page.code).to eq(0)
                 end
             end
 
@@ -125,7 +125,7 @@ describe Arachni::Browser do
                     Arachni::Options.scope.exclude_path_patterns << /sleep/
 
                     subject.load @url + '/ajax_sleep'
-                    subject.to_page.code.should == 0
+                    expect(subject.to_page.code).to eq(0)
                 end
             end
         end
@@ -136,11 +136,11 @@ describe Arachni::Browser do
 
                 width = 100
                 @browser = described_class.new( width: width )
-                subject.javascript.run('return window.innerWidth').should == width
+                expect(subject.javascript.run('return window.innerWidth')).to eq(width)
             end
 
             it 'defaults to 1600' do
-                subject.javascript.run('return window.innerWidth').should == 1600
+                expect(subject.javascript.run('return window.innerWidth')).to eq(1600)
             end
         end
 
@@ -150,11 +150,11 @@ describe Arachni::Browser do
 
                 height = 100
                 @browser = described_class.new( height: height )
-                subject.javascript.run('return window.innerHeight').should == height
+                expect(subject.javascript.run('return window.innerHeight')).to eq(height)
             end
 
             it 'defaults to 1200' do
-                subject.javascript.run('return window.innerHeight').should == 1200
+                expect(subject.javascript.run('return window.innerHeight')).to eq(1200)
             end
         end
 
@@ -163,14 +163,14 @@ describe Arachni::Browser do
                 it 'stores snapshot pages' do
                     @browser.shutdown
                     @browser = described_class.new
-                    @browser.load( @url + '/explore' ).flush_pages.should be_any
+                    expect(@browser.load( @url + '/explore' ).flush_pages).to be_any
                 end
 
                 it 'stores captured pages' do
                     @browser.shutdown
                     @browser = described_class.new
                     @browser.start_capture
-                    @browser.load( @url + '/with-ajax' ).flush_pages.should be_any
+                    expect(@browser.load( @url + '/with-ajax' ).flush_pages).to be_any
                 end
             end
 
@@ -178,14 +178,14 @@ describe Arachni::Browser do
                 it 'stores snapshot pages' do
                     @browser.shutdown
                     @browser = described_class.new( store_pages: true )
-                    @browser.load( @url + '/explore' ).trigger_events.flush_pages.should be_any
+                    expect(@browser.load( @url + '/explore' ).trigger_events.flush_pages).to be_any
                 end
 
                 it 'stores captured pages' do
                     @browser.shutdown
                     @browser = described_class.new( store_pages: true )
                     @browser.start_capture
-                    @browser.load( @url + '/with-ajax' ).flush_pages.should be_any
+                    expect(@browser.load( @url + '/with-ajax' ).flush_pages).to be_any
                 end
             end
 
@@ -193,21 +193,21 @@ describe Arachni::Browser do
                 it 'stores snapshot pages' do
                     @browser.shutdown
                     @browser = described_class.new( store_pages: false )
-                    @browser.load( @url + '/explore' ).trigger_events.flush_pages.should be_empty
+                    expect(@browser.load( @url + '/explore' ).trigger_events.flush_pages).to be_empty
                 end
 
                 it 'stores captured pages' do
                     @browser.shutdown
                     @browser = described_class.new( store_pages: false )
                     @browser.start_capture
-                    @browser.load( @url + '/with-ajax' ).flush_pages.should be_empty
+                    expect(@browser.load( @url + '/with-ajax' ).flush_pages).to be_empty
                 end
             end
         end
 
         context 'when browser process spawn fails' do
             it "raises #{described_class::Error::Spawn}" do
-                described_class.any_instance.stub(:spawn_phantomjs) { nil }
+                allow_any_instance_of(described_class).to receive(:spawn_phantomjs) { nil }
                 expect { described_class.new }.to raise_error described_class::Error::Spawn
             end
         end
@@ -219,9 +219,9 @@ describe Arachni::Browser do
 
             lines = subject.source.lines.to_a
 
-            lines.should be_any
+            expect(lines).to be_any
             subject.source_with_line_numbers.lines.each.with_index do |l, i|
-                l.should == "#{i+1} - #{lines[i]}"
+                expect(l).to eq("#{i+1} - #{lines[i]}")
             end
         end
     end
@@ -229,13 +229,13 @@ describe Arachni::Browser do
     describe '#load_delay' do
         it 'returns nil' do
             subject.load @url
-            subject.load_delay.should be_nil
+            expect(subject.load_delay).to be_nil
         end
 
         context 'when the page has JS timeouts' do
             it 'returns the maximum time the browser should wait for the page based on Timeout' do
                 subject.load( "#{@url}load_delay" )
-                subject.load_delay.should == 2000
+                expect(subject.load_delay).to eq(2000)
             end
         end
     end
@@ -243,7 +243,7 @@ describe Arachni::Browser do
     describe '#wait_for_timers' do
         it 'returns' do
             subject.load @url
-            subject.wait_for_timers.should be_nil
+            expect(subject.wait_for_timers).to be_nil
         end
 
         context 'when the page has JS timeouts' do
@@ -253,7 +253,7 @@ describe Arachni::Browser do
 
                 time = Time.now
                 subject.wait_for_timers
-                (Time.now - time).should > seconds
+                expect(Time.now - time).to be > seconds
             end
 
             it "caps them at #{Arachni::OptionGroups::HTTP}#request_timeout" do
@@ -263,7 +263,7 @@ describe Arachni::Browser do
 
                 time = Time.now
                 subject.wait_for_timers
-                (Time.now - time).should < 0.2
+                expect(Time.now - time).to be < 0.2
             end
         end
     end
@@ -288,7 +288,7 @@ describe Arachni::Browser do
                     received << page
                 end
 
-                captured.should == received
+                expect(captured).to eq(received)
             end
 
             context '#store_pages?' do
@@ -298,12 +298,12 @@ describe Arachni::Browser do
                     it 'stores it in #page_snapshots' do
                         captured = subject.capture_snapshot
 
-                        subject.page_snapshots.should == captured
+                        expect(subject.page_snapshots).to eq(captured)
                     end
 
                     it 'returns it' do
-                        captured.size.should == 1
-                        captured.first.should == subject.to_page
+                        expect(captured.size).to eq(1)
+                        expect(captured.first).to eq(subject.to_page)
                     end
                 end
 
@@ -313,11 +313,11 @@ describe Arachni::Browser do
                     it 'does not store it' do
                         subject.capture_snapshot
 
-                        subject.page_snapshots.should be_empty
+                        expect(subject.page_snapshots).to be_empty
                     end
 
                     it 'returns an empty array' do
-                        captured.should be_empty
+                        expect(captured).to be_empty
                     end
                 end
             end
@@ -329,8 +329,8 @@ describe Arachni::Browser do
             end
 
             it 'ignores it' do
-                subject.capture_snapshot.should be_any
-                subject.capture_snapshot.should be_empty
+                expect(subject.capture_snapshot).to be_any
+                expect(subject.capture_snapshot).to be_empty
             end
         end
 
@@ -347,7 +347,7 @@ describe Arachni::Browser do
 
                 subject.capture_snapshot
 
-                sinks.size.should == 1
+                expect(sinks.size).to eq(1)
             end
 
             context 'and has already been seen' do
@@ -360,7 +360,7 @@ describe Arachni::Browser do
                     subject.capture_snapshot
                     subject.capture_snapshot
 
-                    sinks.size.should == 2
+                    expect(sinks.size).to eq(2)
                 end
             end
 
@@ -370,7 +370,7 @@ describe Arachni::Browser do
 
                     it 'stores it in #page_snapshots_with_sinks' do
                         subject.capture_snapshot
-                        subject.page_snapshots_with_sinks.should be_any
+                        expect(subject.page_snapshots_with_sinks).to be_any
                     end
                 end
 
@@ -379,7 +379,7 @@ describe Arachni::Browser do
 
                     it 'does not store it in #page_snapshots_with_sinks' do
                         subject.capture_snapshot
-                        subject.page_snapshots_with_sinks.should be_empty
+                        expect(subject.page_snapshots_with_sinks).to be_empty
                     end
                 end
             end
@@ -394,7 +394,7 @@ describe Arachni::Browser do
                 transition = { stuff: :here }
                 captured = subject.capture_snapshot( stuff: :here )
 
-                captured.first.dom.transitions.should include transition
+                expect(captured.first.dom.transitions).to include transition
             end
         end
 
@@ -408,15 +408,16 @@ describe Arachni::Browser do
                 subject.watir.windows.last.use
                 subject.load sink_url, take_snapshot: false
 
-                subject.capture_snapshot.map(&:url).sort.should ==
+                expect(subject.capture_snapshot.map(&:url).sort).to eq(
                     [ajax_url, sink_url].sort
+                )
             end
         end
 
         context 'when an error occurs' do
             it 'ignores it' do
-                subject.watir.stub(:windows) { raise }
-                subject.capture_snapshot( blah: :stuff ).should be_empty
+                allow(subject.watir).to receive(:windows) { raise }
+                expect(subject.capture_snapshot( blah: :stuff )).to be_empty
             end
         end
     end
@@ -425,29 +426,31 @@ describe Arachni::Browser do
         it 'returns pages with data-flow sink data' do
             @browser.load "#{@url}/lots_of_sinks?input=#{@browser.javascript.log_data_flow_sink_stub( function: { name: 'blah' } )}"
             @browser.explore_and_flush
-            @browser.page_snapshots_with_sinks.map(&:dom).map(&:data_flow_sinks).should ==
+            expect(@browser.page_snapshots_with_sinks.map(&:dom).map(&:data_flow_sinks)).to eq(
                 @browser.flush_page_snapshots_with_sinks.map(&:dom).map(&:data_flow_sinks)
+            )
         end
 
         it 'returns pages with execution-flow sink data' do
             @browser.load "#{@url}/lots_of_sinks?input=#{@browser.javascript.log_execution_flow_sink_stub( function: { name: 'blah' } )}"
             @browser.explore_and_flush
-            @browser.page_snapshots_with_sinks.map(&:dom).map(&:execution_flow_sinks).should ==
+            expect(@browser.page_snapshots_with_sinks.map(&:dom).map(&:execution_flow_sinks)).to eq(
                 @browser.flush_page_snapshots_with_sinks.map(&:dom).map(&:execution_flow_sinks)
+            )
         end
 
         it 'empties the data-flow sink page buffer' do
             @browser.load "#{@url}/lots_of_sinks?input=#{@browser.javascript.log_data_flow_sink_stub( function: { name: 'blah' } )}"
             @browser.explore_and_flush
             @browser.flush_page_snapshots_with_sinks.map(&:dom).map(&:data_flow_sinks)
-            @browser.page_snapshots_with_sinks.should be_empty
+            expect(@browser.page_snapshots_with_sinks).to be_empty
         end
 
         it 'empties the execution-flow sink page buffer' do
             @browser.load "#{@url}/lots_of_sinks?input=#{@browser.javascript.log_execution_flow_sink_stub( function: { name: 'blah' } )}"
             @browser.explore_and_flush
             @browser.flush_page_snapshots_with_sinks.map(&:dom).map(&:execution_flow_sinks)
-            @browser.page_snapshots_with_sinks.should be_empty
+            expect(@browser.page_snapshots_with_sinks).to be_empty
         end
     end
 
@@ -462,9 +465,9 @@ describe Arachni::Browser do
 
             @browser.explore_and_flush
 
-            sinks.size.should == 2
-            sinks.should == @browser.page_snapshots_with_sinks.map(&:dom).
-                map(&:execution_flow_sinks)
+            expect(sinks.size).to eq(2)
+            expect(sinks).to eq(@browser.page_snapshots_with_sinks.map(&:dom).
+                map(&:execution_flow_sinks))
         end
 
         it 'assigns blocks to handle each page with data-flow sink data' do
@@ -478,9 +481,9 @@ describe Arachni::Browser do
 
             @browser.explore_and_flush
 
-            sinks.size.should == 2
-            sinks.should == @browser.page_snapshots_with_sinks.map(&:dom).
-                map(&:data_flow_sinks)
+            expect(sinks.size).to eq(2)
+            expect(sinks).to eq(@browser.page_snapshots_with_sinks.map(&:dom).
+                map(&:data_flow_sinks))
         end
     end
 
@@ -496,10 +499,10 @@ describe Arachni::Browser do
             @browser.fire_event @browser.watir.div( id: 'my-div' ), :click
             @browser.fire_event @browser.watir.div( id: 'my-div' ), :mouseover
 
-            calls.should == [
+            expect(calls).to eq([
                 [ "<div id=\"my-div\" onclick=\"addForm();\">", :click ],
                 [ "<div id=\"my-div\" onclick=\"addForm();\">", :mouseover ]
-            ]
+            ])
         end
     end
 
@@ -508,8 +511,8 @@ describe Arachni::Browser do
             pages = []
             @browser.on_new_page { |page| pages << page }
 
-            @browser.load( @url + '/explore' ).trigger_events.
-                page_snapshots.should == pages
+            expect(@browser.load( @url + '/explore' ).trigger_events.
+                page_snapshots).to eq(pages)
         end
 
         it 'is passed each request capture' do
@@ -518,7 +521,7 @@ describe Arachni::Browser do
             @browser.start_capture
 
             # Last page will be the root snapshot so ignore it.
-            @browser.load( @url + '/with-ajax' ).captured_pages.should == pages[0...2]
+            expect(@browser.load( @url + '/with-ajax' ).captured_pages).to eq(pages[0...2])
         end
     end
 
@@ -532,8 +535,8 @@ describe Arachni::Browser do
                 @browser.goto @url
 
                 response = responses.first
-                response.should be_kind_of Arachni::HTTP::Response
-                response.url.should == @url
+                expect(response).to be_kind_of Arachni::HTTP::Response
+                expect(response.url).to eq(@url)
             end
         end
 
@@ -546,8 +549,8 @@ describe Arachni::Browser do
                 @browser.goto @url
 
                 response = responses.first
-                response.should be_kind_of Arachni::HTTP::Response
-                response.url.should == @url
+                expect(response).to be_kind_of Arachni::HTTP::Response
+                expect(response.url).to eq(@url)
             end
         end
 
@@ -559,8 +562,8 @@ describe Arachni::Browser do
                 @browser.goto @url
 
                 response = responses.first
-                response.should be_kind_of Arachni::HTTP::Response
-                response.url.should == @url
+                expect(response).to be_kind_of Arachni::HTTP::Response
+                expect(response.url).to eq(@url)
             end
         end
     end
@@ -572,7 +575,7 @@ describe Arachni::Browser do
 
             pages_should_have_form_with_input pages, 'by-ajax'
 
-            pages.map(&:dom).map(&:transitions).should == [
+            expect(pages.map(&:dom).map(&:transitions)).to eq([
                 [
                     { :page => :load },
                     { "#{@url}deep-dom" => :request },
@@ -655,14 +658,14 @@ describe Arachni::Browser do
 
                     { "#{@url}level6" => :request }
                 ]
-            ].map { |transitions| transitions_from_array( transitions ) }
+            ].map { |transitions| transitions_from_array( transitions ) })
         end
 
         context 'with a depth argument' do
             it 'does not go past the given DOM depth' do
                 pages = @browser.load( @url + '/deep-dom' ).explore_and_flush(2)
 
-                pages.map(&:dom).map(&:transitions).should == [
+                expect(pages.map(&:dom).map(&:transitions)).to eq([
                     [
                         { :page => :load },
                         { "#{@url}deep-dom" => :request },
@@ -697,7 +700,7 @@ describe Arachni::Browser do
                         },
                         { "#{@url}level4" => :request }
                     ]
-                ].map { |transitions| transitions_from_array( transitions ) }
+                ].map { |transitions| transitions_from_array( transitions ) })
             end
         end
     end
@@ -710,9 +713,9 @@ describe Arachni::Browser do
             pages = @browser.page_snapshots_with_sinks
             doms  = pages.map(&:dom)
 
-            doms.size.should == 2
+            expect(doms.size).to eq(2)
 
-            doms[0].transitions.should == transitions_from_array([
+            expect(doms[0].transitions).to eq(transitions_from_array([
                 { page: :load },
                 { "#{@url}lots_of_sinks?input=#{@browser.javascript.log_execution_flow_sink_stub(1)}" => :request },
                 {
@@ -724,64 +727,64 @@ describe Arachni::Browser do
                         }
                     } => :mouseover
                 }
-            ])
+            ]))
 
-            doms[0].execution_flow_sinks.size.should == 2
+            expect(doms[0].execution_flow_sinks.size).to eq(2)
 
             entry = doms[0].execution_flow_sinks[0]
-            entry.data.should == [1]
-            entry.trace.size.should == 3
+            expect(entry.data).to eq([1])
+            expect(entry.trace.size).to eq(3)
 
-            entry.trace[0].function.name.should == 'onClick'
-            entry.trace[0].function.source.should start_with 'function onClick'
-            @browser.source.split("\n")[entry.trace[0].line].should include 'log_execution_flow_sink(1)'
-            entry.trace[0].function.arguments.should == [1, 2]
+            expect(entry.trace[0].function.name).to eq('onClick')
+            expect(entry.trace[0].function.source).to start_with 'function onClick'
+            expect(@browser.source.split("\n")[entry.trace[0].line]).to include 'log_execution_flow_sink(1)'
+            expect(entry.trace[0].function.arguments).to eq([1, 2])
 
-            entry.trace[1].function.name.should == 'onClick2'
-            entry.trace[1].function.source.should start_with 'function onClick2'
-            @browser.source.split("\n")[entry.trace[1].line].should include 'onClick'
-            entry.trace[1].function.arguments.should == %w(blah1 blah2 blah3)
+            expect(entry.trace[1].function.name).to eq('onClick2')
+            expect(entry.trace[1].function.source).to start_with 'function onClick2'
+            expect(@browser.source.split("\n")[entry.trace[1].line]).to include 'onClick'
+            expect(entry.trace[1].function.arguments).to eq(%w(blah1 blah2 blah3))
 
-            entry.trace[2].function.name.should == 'onmouseover'
-            entry.trace[2].function.source.should start_with 'function onmouseover'
+            expect(entry.trace[2].function.name).to eq('onmouseover')
+            expect(entry.trace[2].function.source).to start_with 'function onmouseover'
 
             event = entry.trace[2].function.arguments.first
 
             link = "<a href=\"#\" onmouseover=\"onClick2('blah1', 'blah2', 'blah3');\">Blah</a>"
-            event['target'].should == link
-            event['srcElement'].should == link
-            event['type'].should == 'mouseover'
+            expect(event['target']).to eq(link)
+            expect(event['srcElement']).to eq(link)
+            expect(event['type']).to eq('mouseover')
 
             entry = doms[0].execution_flow_sinks[1]
-            entry.data.should == [1]
-            entry.trace.size.should == 4
+            expect(entry.data).to eq([1])
+            expect(entry.trace.size).to eq(4)
 
-            entry.trace[0].function.name.should == 'onClick3'
-            entry.trace[0].function.source.should start_with 'function onClick3'
-            @browser.source.split("\n")[entry.trace[0].line].should include 'log_execution_flow_sink(1)'
-            entry.trace[0].function.arguments.should be_empty
+            expect(entry.trace[0].function.name).to eq('onClick3')
+            expect(entry.trace[0].function.source).to start_with 'function onClick3'
+            expect(@browser.source.split("\n")[entry.trace[0].line]).to include 'log_execution_flow_sink(1)'
+            expect(entry.trace[0].function.arguments).to be_empty
 
-            entry.trace[1].function.name.should == 'onClick'
-            entry.trace[1].function.source.should start_with 'function onClick'
-            @browser.source.split("\n")[entry.trace[1].line].should include 'onClick3'
-            entry.trace[1].function.arguments.should == [1, 2]
+            expect(entry.trace[1].function.name).to eq('onClick')
+            expect(entry.trace[1].function.source).to start_with 'function onClick'
+            expect(@browser.source.split("\n")[entry.trace[1].line]).to include 'onClick3'
+            expect(entry.trace[1].function.arguments).to eq([1, 2])
 
-            entry.trace[2].function.name.should == 'onClick2'
-            entry.trace[2].function.source.should start_with 'function onClick2'
-            @browser.source.split("\n")[entry.trace[2].line].should include 'onClick'
-            entry.trace[2].function.arguments.should == %w(blah1 blah2 blah3)
+            expect(entry.trace[2].function.name).to eq('onClick2')
+            expect(entry.trace[2].function.source).to start_with 'function onClick2'
+            expect(@browser.source.split("\n")[entry.trace[2].line]).to include 'onClick'
+            expect(entry.trace[2].function.arguments).to eq(%w(blah1 blah2 blah3))
 
-            entry.trace[3].function.name.should == 'onmouseover'
-            entry.trace[3].function.source.should start_with 'function onmouseover'
+            expect(entry.trace[3].function.name).to eq('onmouseover')
+            expect(entry.trace[3].function.source).to start_with 'function onmouseover'
 
             event = entry.trace[3].function.arguments.first
 
             link = "<a href=\"#\" onmouseover=\"onClick2('blah1', 'blah2', 'blah3');\">Blah</a>"
-            event['target'].should == link
-            event['srcElement'].should == link
-            event['type'].should == 'mouseover'
+            expect(event['target']).to eq(link)
+            expect(event['srcElement']).to eq(link)
+            expect(event['type']).to eq('mouseover')
 
-            doms[1].transitions.should == transitions_from_array([
+            expect(doms[1].transitions).to eq(transitions_from_array([
                 { page: :load },
                 { "#{@url}lots_of_sinks?input=#{@browser.javascript.log_execution_flow_sink_stub(1)}" => :request },
                 {
@@ -793,54 +796,54 @@ describe Arachni::Browser do
                         }
                     } => :submit
                 }
-            ])
+            ]))
 
-            doms[1].execution_flow_sinks.size.should == 2
+            expect(doms[1].execution_flow_sinks.size).to eq(2)
 
             entry = doms[1].execution_flow_sinks[0]
-            entry.data.should == [1]
-            entry.trace.size.should == 2
+            expect(entry.data).to eq([1])
+            expect(entry.trace.size).to eq(2)
 
-            entry.trace[0].function.name.should == 'onClick'
-            entry.trace[0].function.source.should start_with 'function onClick'
-            @browser.source.split("\n")[entry.trace[0].line].should include 'log_execution_flow_sink(1)'
-            entry.trace[0].function.arguments.should == %w(some-arg arguments-arg here-arg)
+            expect(entry.trace[0].function.name).to eq('onClick')
+            expect(entry.trace[0].function.source).to start_with 'function onClick'
+            expect(@browser.source.split("\n")[entry.trace[0].line]).to include 'log_execution_flow_sink(1)'
+            expect(entry.trace[0].function.arguments).to eq(%w(some-arg arguments-arg here-arg))
 
-            entry.trace[1].function.name.should == 'onsubmit'
-            entry.trace[1].function.source.should start_with 'function onsubmit'
-            @browser.source.split("\n")[entry.trace[1].line].should include 'onClick'
+            expect(entry.trace[1].function.name).to eq('onsubmit')
+            expect(entry.trace[1].function.source).to start_with 'function onsubmit'
+            expect(@browser.source.split("\n")[entry.trace[1].line]).to include 'onClick'
 
             event = entry.trace[1].function.arguments.first
 
             form = "<form id=\"my_form\" onsubmit=\"onClick('some-arg', 'arguments-arg', 'here-arg'); return false;\">\n        </form>"
-            event['target'].should == form
-            event['srcElement'].should == form
-            event['type'].should == 'submit'
+            expect(event['target']).to eq(form)
+            expect(event['srcElement']).to eq(form)
+            expect(event['type']).to eq('submit')
 
             entry = doms[1].execution_flow_sinks[1]
-            entry.data.should == [1]
-            entry.trace.size.should == 3
+            expect(entry.data).to eq([1])
+            expect(entry.trace.size).to eq(3)
 
-            entry.trace[0].function.name.should == 'onClick3'
-            entry.trace[0].function.source.should start_with 'function onClick3'
-            @browser.source.split("\n")[entry.trace[0].line].should include 'log_execution_flow_sink(1)'
-            entry.trace[0].function.arguments.should be_empty
+            expect(entry.trace[0].function.name).to eq('onClick3')
+            expect(entry.trace[0].function.source).to start_with 'function onClick3'
+            expect(@browser.source.split("\n")[entry.trace[0].line]).to include 'log_execution_flow_sink(1)'
+            expect(entry.trace[0].function.arguments).to be_empty
 
-            entry.trace[1].function.name.should == 'onClick'
-            entry.trace[1].function.source.should start_with 'function onClick'
-            @browser.source.split("\n")[entry.trace[1].line].should include 'onClick3()'
-            entry.trace[1].function.arguments.should == %w(some-arg arguments-arg here-arg)
+            expect(entry.trace[1].function.name).to eq('onClick')
+            expect(entry.trace[1].function.source).to start_with 'function onClick'
+            expect(@browser.source.split("\n")[entry.trace[1].line]).to include 'onClick3()'
+            expect(entry.trace[1].function.arguments).to eq(%w(some-arg arguments-arg here-arg))
 
-            entry.trace[2].function.name.should == 'onsubmit'
-            entry.trace[2].function.source.should start_with 'function onsubmit'
-            @browser.source.split("\n")[entry.trace[2].line].should include 'onClick('
+            expect(entry.trace[2].function.name).to eq('onsubmit')
+            expect(entry.trace[2].function.source).to start_with 'function onsubmit'
+            expect(@browser.source.split("\n")[entry.trace[2].line]).to include 'onClick('
 
             event = entry.trace[2].function.arguments.first
 
             form = "<form id=\"my_form\" onsubmit=\"onClick('some-arg', 'arguments-arg', 'here-arg'); return false;\">\n        </form>"
-            event['target'].should == form
-            event['srcElement'].should == form
-            event['type'].should == 'submit'
+            expect(event['target']).to eq(form)
+            expect(event['srcElement']).to eq(form)
+            expect(event['type']).to eq('submit')
         end
 
         it 'returns data-flow sink data' do
@@ -851,109 +854,109 @@ describe Arachni::Browser do
             pages = @browser.page_snapshots_with_sinks
             doms  = pages.map(&:dom)
 
-            doms.size.should == 2
+            expect(doms.size).to eq(2)
 
-            doms[0].data_flow_sinks.size.should == 2
+            expect(doms[0].data_flow_sinks.size).to eq(2)
 
             entry = doms[0].data_flow_sinks[0]
-            entry.function.should == 'blah'
-            entry.trace.size.should == 3
+            expect(entry.function).to eq('blah')
+            expect(entry.trace.size).to eq(3)
 
-            entry.trace[0].function.name.should == 'onClick'
-            entry.trace[0].function.source.should start_with 'function onClick'
-            @browser.source.split("\n")[entry.trace[0].line].should include 'log_data_flow_sink('
-            entry.trace[0].function.arguments.should == [1, 2]
+            expect(entry.trace[0].function.name).to eq('onClick')
+            expect(entry.trace[0].function.source).to start_with 'function onClick'
+            expect(@browser.source.split("\n")[entry.trace[0].line]).to include 'log_data_flow_sink('
+            expect(entry.trace[0].function.arguments).to eq([1, 2])
 
-            entry.trace[1].function.name.should == 'onClick2'
-            entry.trace[1].function.source.should start_with 'function onClick2'
-            @browser.source.split("\n")[entry.trace[1].line].should include 'onClick'
-            entry.trace[1].function.arguments.should == %w(blah1 blah2 blah3)
+            expect(entry.trace[1].function.name).to eq('onClick2')
+            expect(entry.trace[1].function.source).to start_with 'function onClick2'
+            expect(@browser.source.split("\n")[entry.trace[1].line]).to include 'onClick'
+            expect(entry.trace[1].function.arguments).to eq(%w(blah1 blah2 blah3))
 
-            entry.trace[2].function.name.should == 'onmouseover'
-            entry.trace[2].function.source.should start_with 'function onmouseover'
+            expect(entry.trace[2].function.name).to eq('onmouseover')
+            expect(entry.trace[2].function.source).to start_with 'function onmouseover'
 
             event = entry.trace[2].function.arguments.first
 
             link = "<a href=\"#\" onmouseover=\"onClick2('blah1', 'blah2', 'blah3');\">Blah</a>"
-            event['target'].should == link
-            event['srcElement'].should == link
-            event['type'].should == 'mouseover'
+            expect(event['target']).to eq(link)
+            expect(event['srcElement']).to eq(link)
+            expect(event['type']).to eq('mouseover')
 
             entry = doms[0].data_flow_sinks[1]
-            entry.function.should == 'blah'
-            entry.trace.size.should == 4
+            expect(entry.function).to eq('blah')
+            expect(entry.trace.size).to eq(4)
 
-            entry.trace[0].function.name.should == 'onClick3'
-            entry.trace[0].function.source.should start_with 'function onClick3'
-            @browser.source.split("\n")[entry.trace[0].line].should include 'log_data_flow_sink('
-            entry.trace[0].function.arguments.should be_empty
+            expect(entry.trace[0].function.name).to eq('onClick3')
+            expect(entry.trace[0].function.source).to start_with 'function onClick3'
+            expect(@browser.source.split("\n")[entry.trace[0].line]).to include 'log_data_flow_sink('
+            expect(entry.trace[0].function.arguments).to be_empty
 
-            entry.trace[1].function.name.should == 'onClick'
-            entry.trace[1].function.source.should start_with 'function onClick'
-            @browser.source.split("\n")[entry.trace[1].line].should include 'onClick3'
-            entry.trace[1].function.arguments.should == [1, 2]
+            expect(entry.trace[1].function.name).to eq('onClick')
+            expect(entry.trace[1].function.source).to start_with 'function onClick'
+            expect(@browser.source.split("\n")[entry.trace[1].line]).to include 'onClick3'
+            expect(entry.trace[1].function.arguments).to eq([1, 2])
 
-            entry.trace[2].function.name.should == 'onClick2'
-            entry.trace[2].function.source.should start_with 'function onClick2'
-            @browser.source.split("\n")[entry.trace[2].line].should include 'onClick'
-            entry.trace[2].function.arguments.should == %w(blah1 blah2 blah3)
+            expect(entry.trace[2].function.name).to eq('onClick2')
+            expect(entry.trace[2].function.source).to start_with 'function onClick2'
+            expect(@browser.source.split("\n")[entry.trace[2].line]).to include 'onClick'
+            expect(entry.trace[2].function.arguments).to eq(%w(blah1 blah2 blah3))
 
-            entry.trace[3].function.name.should == 'onmouseover'
-            entry.trace[3].function.source.should start_with 'function onmouseover'
+            expect(entry.trace[3].function.name).to eq('onmouseover')
+            expect(entry.trace[3].function.source).to start_with 'function onmouseover'
 
             event = entry.trace[3].function.arguments.first
 
             link = "<a href=\"#\" onmouseover=\"onClick2('blah1', 'blah2', 'blah3');\">Blah</a>"
-            event['target'].should == link
-            event['srcElement'].should == link
-            event['type'].should == 'mouseover'
+            expect(event['target']).to eq(link)
+            expect(event['srcElement']).to eq(link)
+            expect(event['type']).to eq('mouseover')
 
-            doms[1].data_flow_sinks.size.should == 2
+            expect(doms[1].data_flow_sinks.size).to eq(2)
 
             entry = doms[1].data_flow_sinks[0]
-            entry.function.should == 'blah'
-            entry.trace.size.should == 2
+            expect(entry.function).to eq('blah')
+            expect(entry.trace.size).to eq(2)
 
-            entry.trace[0].function.name.should == 'onClick'
-            entry.trace[0].function.source.should start_with 'function onClick'
-            @browser.source.split("\n")[entry.trace[0].line].should include 'log_data_flow_sink('
-            entry.trace[0].function.arguments.should == %w(some-arg arguments-arg here-arg)
+            expect(entry.trace[0].function.name).to eq('onClick')
+            expect(entry.trace[0].function.source).to start_with 'function onClick'
+            expect(@browser.source.split("\n")[entry.trace[0].line]).to include 'log_data_flow_sink('
+            expect(entry.trace[0].function.arguments).to eq(%w(some-arg arguments-arg here-arg))
 
-            entry.trace[1].function.name.should == 'onsubmit'
-            entry.trace[1].function.source.should start_with 'function onsubmit'
-            @browser.source.split("\n")[entry.trace[1].line].should include 'onClick'
+            expect(entry.trace[1].function.name).to eq('onsubmit')
+            expect(entry.trace[1].function.source).to start_with 'function onsubmit'
+            expect(@browser.source.split("\n")[entry.trace[1].line]).to include 'onClick'
 
             event = entry.trace[1].function.arguments.first
 
             form = "<form id=\"my_form\" onsubmit=\"onClick('some-arg', 'arguments-arg', 'here-arg'); return false;\">\n        </form>"
-            event['target'].should == form
-            event['srcElement'].should == form
-            event['type'].should == 'submit'
+            expect(event['target']).to eq(form)
+            expect(event['srcElement']).to eq(form)
+            expect(event['type']).to eq('submit')
 
             entry = doms[1].data_flow_sinks[1]
-            entry.function.should == 'blah'
-            entry.trace.size.should == 3
+            expect(entry.function).to eq('blah')
+            expect(entry.trace.size).to eq(3)
 
-            entry.trace[0].function.name.should == 'onClick3'
-            entry.trace[0].function.source.should start_with 'function onClick3'
-            @browser.source.split("\n")[entry.trace[0].line].should include 'log_data_flow_sink('
-            entry.trace[0].function.arguments.should be_empty
+            expect(entry.trace[0].function.name).to eq('onClick3')
+            expect(entry.trace[0].function.source).to start_with 'function onClick3'
+            expect(@browser.source.split("\n")[entry.trace[0].line]).to include 'log_data_flow_sink('
+            expect(entry.trace[0].function.arguments).to be_empty
 
-            entry.trace[1].function.name.should == 'onClick'
-            entry.trace[1].function.source.should start_with 'function onClick'
-            @browser.source.split("\n")[entry.trace[1].line].should include 'onClick3()'
-            entry.trace[1].function.arguments.should == %w(some-arg arguments-arg here-arg)
+            expect(entry.trace[1].function.name).to eq('onClick')
+            expect(entry.trace[1].function.source).to start_with 'function onClick'
+            expect(@browser.source.split("\n")[entry.trace[1].line]).to include 'onClick3()'
+            expect(entry.trace[1].function.arguments).to eq(%w(some-arg arguments-arg here-arg))
 
-            entry.trace[2].function.name.should == 'onsubmit'
-            entry.trace[2].function.source.should start_with 'function onsubmit'
-            @browser.source.split("\n")[entry.trace[2].line].should include 'onClick('
+            expect(entry.trace[2].function.name).to eq('onsubmit')
+            expect(entry.trace[2].function.source).to start_with 'function onsubmit'
+            expect(@browser.source.split("\n")[entry.trace[2].line]).to include 'onClick('
 
             event = entry.trace[2].function.arguments.first
 
             form = "<form id=\"my_form\" onsubmit=\"onClick('some-arg', 'arguments-arg', 'here-arg'); return false;\">\n        </form>"
-            event['target'].should == form
-            event['srcElement'].should == form
-            event['type'].should == 'submit'
+            expect(event['target']).to eq(form)
+            expect(event['srcElement']).to eq(form)
+            expect(event['type']).to eq('submit')
         end
 
         describe 'when store_pages: false' do
@@ -963,7 +966,7 @@ describe Arachni::Browser do
 
                 @browser.load "#{@url}/lots_of_sinks?input=#{@browser.javascript.log_execution_flow_sink_stub(1)}"
                 @browser.explore_and_flush
-                @browser.page_snapshots_with_sinks.should be_empty
+                expect(@browser.page_snapshots_with_sinks).to be_empty
             end
         end
     end
@@ -977,10 +980,10 @@ describe Arachni::Browser do
             raw_response     = Arachni::HTTP::Client.get( @url, mode: :sync )
             raw_request      = raw_response.request
 
-            browser_response.url.should == raw_response.url
+            expect(browser_response.url).to eq(raw_response.url)
 
             [:url, :method].each do |attribute|
-                browser_request.send(attribute).should == raw_request.send(attribute)
+                expect(browser_request.send(attribute)).to eq(raw_request.send(attribute))
             end
         end
 
@@ -992,7 +995,7 @@ describe Arachni::Browser do
             it 'returns nil' do
                 Arachni::Options.url = @url
                 @browser.load 'http://google.com/'
-                @browser.response.should be_nil
+                expect(@browser.response).to be_nil
             end
         end
     end
@@ -1004,30 +1007,31 @@ describe Arachni::Browser do
             @browser.load( @url )
             page = @browser.to_page
 
-            page.should be_kind_of Arachni::Page
+            expect(page).to be_kind_of Arachni::Page
 
-            ua.should_not be_empty
-            page.response.body.should_not include( ua )
-            page.body.should include( ua )
+            expect(ua).not_to be_empty
+            expect(page.response.body).not_to include( ua )
+            expect(page.body).to include( ua )
         end
 
         it "assigns the proper #{Arachni::Page::DOM}#digest" do
             @browser.load( @url )
-            @browser.to_page.dom.instance_variable_get(:@digest).should ==
+            expect(@browser.to_page.dom.instance_variable_get(:@digest)).to eq(
                 '<HTML><HEAD><SCRIPT src=http://javascript.browser.arachni/' <<
                     'taint_tracer.js><SCRIPT src=http://javascript.' <<
                     'browser.arachni/dom_monitor.js><SCRIPT><TITLE><BODY><' <<
                     'DIV><SCRIPT type=text/javascript><SCRIPT type=text/javascript>'
+            )
         end
 
         it "assigns the proper #{Arachni::Page::DOM}#transitions" do
             @browser.load( @url )
             page = @browser.to_page
 
-            page.dom.transitions.should == transitions_from_array([
+            expect(page.dom.transitions).to eq(transitions_from_array([
                 { page: :load },
                 { @url => :request }
-            ])
+            ]))
         end
 
         it "assigns the proper #{Arachni::Page::DOM}#skip_states" do
@@ -1036,7 +1040,7 @@ describe Arachni::Browser do
                 page_snapshots
 
             page = pages.last
-            page.dom.skip_states.should be_subset @browser.skip_states
+            expect(page.dom.skip_states).to be_subset @browser.skip_states
         end
 
         it "assigns the proper #{Arachni::Page::DOM} sink data" do
@@ -1048,136 +1052,264 @@ describe Arachni::Browser do
             sink_data = page.dom.execution_flow_sinks
 
             first_entry = sink_data.first
-            sink_data.should == [first_entry]
+            expect(sink_data).to eq([first_entry])
 
-            first_entry.data.should == [1]
-            first_entry.trace.size.should == 2
+            expect(first_entry.data).to eq([1])
+            expect(first_entry.trace.size).to eq(2)
 
-            first_entry.trace[0].function.name.should == 'onClick'
-            first_entry.trace[0].function.source.should start_with 'function onClick'
-            @browser.source.split("\n")[first_entry.trace[0].line].should include 'log_execution_flow_sink(1)'
-            first_entry.trace[0].function.arguments.should == %w(some-arg arguments-arg here-arg)
+            expect(first_entry.trace[0].function.name).to eq('onClick')
+            expect(first_entry.trace[0].function.source).to start_with 'function onClick'
+            expect(@browser.source.split("\n")[first_entry.trace[0].line]).to include 'log_execution_flow_sink(1)'
+            expect(first_entry.trace[0].function.arguments).to eq(%w(some-arg arguments-arg here-arg))
 
-            first_entry.trace[1].function.name.should == 'onsubmit'
-            first_entry.trace[1].function.source.should start_with 'function onsubmit'
-            @browser.source.split("\n")[first_entry.trace[1].line].should include 'onClick('
-            first_entry.trace[1].function.arguments.size.should == 1
+            expect(first_entry.trace[1].function.name).to eq('onsubmit')
+            expect(first_entry.trace[1].function.source).to start_with 'function onsubmit'
+            expect(@browser.source.split("\n")[first_entry.trace[1].line]).to include 'onClick('
+            expect(first_entry.trace[1].function.arguments.size).to eq(1)
 
             event = first_entry.trace[1].function.arguments.first
 
             form = "<form id=\"my_form\" onsubmit=\"onClick('some-arg', 'arguments-arg', 'here-arg'); return false;\">\n        </form>"
-            event['target'].should == form
-            event['srcElement'].should == form
-            event['type'].should == 'submit'
+            expect(event['target']).to eq(form)
+            expect(event['srcElement']).to eq(form)
+            expect(event['type']).to eq('submit')
         end
 
-        context "when the page has #{Arachni::Element::Form::DOM} elements" do
-            context "and #{Arachni::OptionGroups::Audit}#forms is" do
-                context true do
-                    before do
-                        Arachni::Options.audit.elements :forms
-                    end
-
-                    context 'a JavaScript action' do
-                        it 'does not set #skip_dom' do
-                            @browser.load "#{@url}/each_element_with_events/form/action/javascript"
-                            @browser.to_page.forms.first.skip_dom.should be_nil
+        context 'when the page has' do
+            context "#{Arachni::Element::UIForm} elements" do
+                context "and #{Arachni::OptionGroups::Audit}#inputs is" do
+                    context true do
+                        before do
+                            Arachni::Options.audit.elements :ui_forms
                         end
-                    end
 
-                    context 'with DOM events' do
-                        it 'does not set #skip_dom' do
-                            @browser.load "#{@url}/fire_event/form/onsubmit"
-                            @browser.to_page.forms.first.skip_dom.should be_nil
+                        context '<input> button' do
+                            context 'with DOM events' do
+                                it 'parses it' do
+                                    @browser.load "#{@url}/to_page/input/button/with_events"
+
+                                    input = @browser.to_page.ui_forms.first
+
+                                    expect(input.action).to eq @browser.url
+                                    expect(input.source).to eq '<input type="button" id="insert">'
+                                    expect(input.method).to eq :click
+                                end
+                            end
+
+                            context 'without DOM events' do
+                                it 'ignores it' do
+                                    @browser.load "#{@url}/to_page/input/button/without_events"
+                                    expect(@browser.to_page.ui_forms).to be_empty
+                                end
+                            end
                         end
-                    end
 
-                    context 'without DOM events' do
-                        it 'sets #skip_dom to true' do
-                            @browser.load "#{@url}/each_element_with_events/form/action/regular"
-                            @browser.to_page.forms.first.skip_dom.should be_true
+                        context '<button>' do
+                            context 'with DOM events' do
+                                it 'parses it' do
+                                    @browser.load "#{@url}/to_page/button/with_events"
+
+                                    input = @browser.to_page.ui_forms.first
+
+                                    expect(input.action).to eq @browser.url
+                                    expect(input.source).to eq '<button id="insert">'
+                                    expect(input.method).to eq :click
+                                end
+                            end
+
+                            context 'without DOM events' do
+                                it 'ignores it' do
+                                    @browser.load "#{@url}to_page/button/without_events"
+                                    expect(@browser.to_page.ui_forms).to be_empty
+                                end
+                            end
                         end
                     end
-                end
 
-                context false do
-                    before do
-                        Arachni::Options.audit.skip_elements :forms
-                    end
+                    context false do
+                        before do
+                            Arachni::Options.audit.skip_elements :ui_forms
+                        end
 
-                    it 'does not set #skip_dom' do
-                        @browser.load "#{@url}/each_element_with_events/form/action/regular"
-                        @browser.to_page.forms.first.skip_dom.should be_nil
+                        it 'ignores them' do
+                            @browser.load "#{@url}/to_page/button/with_events"
+                            expect(@browser.to_page.ui_forms).to be_empty
+                        end
                     end
                 end
             end
-        end
 
-        context "when the page has #{Arachni::Element::Cookie::DOM} elements" do
-            let(:cookies) { @browser.to_page.cookies }
+            context "#{Arachni::Element::UIInput} elements" do
+                context "and #{Arachni::OptionGroups::Audit}#inputs is" do
+                    context true do
+                        before do
+                            Arachni::Options.audit.elements :ui_inputs
+                        end
 
-            context "and #{Arachni::OptionGroups::Audit}#cookies is" do
-                context true do
-                    before do
-                        Arachni::Options.audit.elements :cookies
+                        context '<input>' do
+                            context 'with DOM events' do
+                                it 'parses it' do
+                                    @browser.load "#{@url}/to_page/input/with_events"
 
-                        @browser.load "#{@url}/#{page}"
-                        @browser.load "#{@url}/#{page}"
-                    end
+                                    input = @browser.to_page.ui_inputs.first
 
-                    context 'with DOM processing of cookie' do
-                        context 'names' do
-                            let(:page) { 'dom-cookies-names' }
+                                    expect(input.action).to eq @browser.url
+                                    expect(input.source).to eq '<input oninput="handleOnInput();" id="my-input" name="my-input" value="1">'
+                                    expect(input.method).to eq :oninput
+                                end
+                            end
 
-                            it 'does not set #skip_dom' do
-                                cookies.find { |c| c.name == 'my-cookie' }.skip_dom.should be_nil
-                                cookies.find { |c| c.name == 'my-cookie2' }.skip_dom.should be_nil
+                            context 'without DOM events' do
+                                it 'ignores it' do
+                                    @browser.load "#{@url}/to_page/input/without_events"
+                                    expect(@browser.to_page.ui_inputs).to be_empty
+                                end
                             end
                         end
 
-                        context 'values' do
-                            let(:page) { 'dom-cookies-values' }
+                        context '<textarea>' do
+                            context 'with DOM events' do
+                                it 'parses it' do
+                                    @browser.load "#{@url}/to_page/textarea/with_events"
 
-                            it 'does not set #skip_dom' do
-                                cookies.find { |c| c.name == 'my-cookie' }.skip_dom.should be_nil
-                                cookies.find { |c| c.name == 'my-cookie2' }.skip_dom.should be_nil
+                                    input = @browser.to_page.ui_inputs.first
+
+                                    expect(input.action).to eq @browser.url
+                                    expect(input.source).to eq '<textarea oninput="handleOnInput();" id="my-input" name="my-input">'
+                                    expect(input.method).to eq :oninput
+                                end
+                            end
+
+                            context 'without DOM events' do
+                                it 'ignores it' do
+                                    @browser.load "#{@url}/to_page/textarea/without_events"
+                                    expect(@browser.to_page.ui_inputs).to be_empty
+                                end
                             end
                         end
                     end
 
-                    context 'without DOM processing of cookie' do
-                        context 'names' do
-                            let(:page) { 'dom-cookies-names' }
+                    context false do
+                        before do
+                            Arachni::Options.audit.skip_elements :ui_inputs
+                        end
+
+                        it 'ignores them' do
+                            @browser.load "#{@url}/to_page/input/with_events"
+                            expect(@browser.to_page.ui_inputs).to be_empty
+                        end
+                    end
+                end
+            end
+
+            context "#{Arachni::Element::Form::DOM} elements" do
+                context "and #{Arachni::OptionGroups::Audit}#forms is" do
+                    context true do
+                        before do
+                            Arachni::Options.audit.elements :forms
+                        end
 
+                        context 'and JavaScript action' do
                             it 'does not set #skip_dom' do
-                                cookies.find { |c| c.name == 'my-cookie3' }.skip_dom.should be_true
+                                @browser.load "#{@url}/each_element_with_events/form/action/javascript"
+                                expect(@browser.to_page.forms.first.skip_dom).to be_nil
                             end
                         end
 
-                        context 'values' do
-                            let(:page) { 'dom-cookies-values' }
-
+                        context 'with DOM events' do
                             it 'does not set #skip_dom' do
-                                cookies.find { |c| c.name == 'my-cookie3' }.skip_dom.should be_true
+                                @browser.load "#{@url}/fire_event/form/onsubmit"
+                                expect(@browser.to_page.forms.first.skip_dom).to be_nil
                             end
                         end
+
+                        context 'without DOM events' do
+                            it 'sets #skip_dom to true' do
+                                @browser.load "#{@url}/each_element_with_events/form/action/regular"
+                                expect(@browser.to_page.forms.first.skip_dom).to be_truthy
+                            end
+                        end
+                    end
+
+                    context false do
+                        before do
+                            Arachni::Options.audit.skip_elements :forms
+                        end
+
+                        it 'does not set #skip_dom' do
+                            @browser.load "#{@url}/each_element_with_events/form/action/regular"
+                            expect(@browser.to_page.forms.first.skip_dom).to be_nil
+                        end
                     end
                 end
+            end
 
-                context false do
-                    before do
-                        Arachni::Options.audit.skip_elements :cookies
+            context "#{Arachni::Element::Cookie::DOM} elements" do
+                let(:cookies) { @browser.to_page.cookies }
 
-                        @browser.load "#{@url}/#{page}"
-                        @browser.load "#{@url}/#{page}"
+                context "and #{Arachni::OptionGroups::Audit}#cookies is" do
+                    context true do
+                        before do
+                            Arachni::Options.audit.elements :cookies
+
+                            @browser.load "#{@url}/#{page}"
+                            @browser.load "#{@url}/#{page}"
+                        end
+
+                        context 'with DOM processing of cookie' do
+                            context 'names' do
+                                let(:page) { 'dom-cookies-names' }
+
+                                it 'does not set #skip_dom' do
+                                    expect(cookies.find { |c| c.name == 'my-cookie' }.skip_dom).to be_nil
+                                    expect(cookies.find { |c| c.name == 'my-cookie2' }.skip_dom).to be_nil
+                                end
+                            end
+
+                            context 'values' do
+                                let(:page) { 'dom-cookies-values' }
+
+                                it 'does not set #skip_dom' do
+                                    expect(cookies.find { |c| c.name == 'my-cookie' }.skip_dom).to be_nil
+                                    expect(cookies.find { |c| c.name == 'my-cookie2' }.skip_dom).to be_nil
+                                end
+                            end
+                        end
+
+                        context 'without DOM processing of cookie' do
+                            context 'names' do
+                                let(:page) { 'dom-cookies-names' }
+
+                                it 'does not set #skip_dom' do
+                                    expect(cookies.find { |c| c.name == 'my-cookie3' }.skip_dom).to be_truthy
+                                end
+                            end
+
+                            context 'values' do
+                                let(:page) { 'dom-cookies-values' }
+
+                                it 'does not set #skip_dom' do
+                                    expect(cookies.find { |c| c.name == 'my-cookie3' }.skip_dom).to be_truthy
+                                end
+                            end
+                        end
                     end
 
-                    let(:page) { 'dom-cookies-names' }
+                    context false do
+                        before do
+                            Arachni::Options.audit.skip_elements :cookies
 
-                    it 'does not set #skip_dom' do
-                        cookies.should be_any
-                        cookies.each do |cookie|
-                            cookie.skip_dom.should be_nil
+                            @browser.load "#{@url}/#{page}"
+                            @browser.load "#{@url}/#{page}"
+                        end
+
+                        let(:page) { 'dom-cookies-names' }
+
+                        it 'does not set #skip_dom' do
+                            expect(cookies).to be_any
+                            cookies.each do |cookie|
+                                expect(cookie.skip_dom).to be_nil
+                            end
                         end
                     end
                 end
@@ -1190,10 +1322,10 @@ describe Arachni::Browser do
                 subject.load 'http://google.com/'
                 page = subject.to_page
 
-                page.code.should == 0
-                page.url.should  == subject.url
-                page.body.should be_empty
-                page.dom.url.should == subject.watir.url
+                expect(page.code).to eq(0)
+                expect(page.url).to  eq(subject.url)
+                expect(page.body).to be_empty
+                expect(page.dom.url).to eq(subject.watir.url)
             end
         end
     end
@@ -1234,9 +1366,9 @@ describe Arachni::Browser do
             it 'returns nil' do
                 element = @browser.watir.div( id: 'my-div' )
 
-                element.stub(:visible?) { false }
+                allow(element).to receive(:visible?) { false }
 
-                @browser.fire_event( element, :click ).should be_nil
+                expect(@browser.fire_event( element, :click )).to be_nil
             end
         end
 
@@ -1248,11 +1380,11 @@ describe Arachni::Browser do
                         attributes: { 'id' => 'blahblah' }
                     )
 
-                    element.stub(:locate){ raise Selenium::WebDriver::Error::WebDriverError }
-                    @browser.fire_event( element, :click ).should be_nil
+                    allow(element).to receive(:locate){ raise Selenium::WebDriver::Error::WebDriverError }
+                    expect(@browser.fire_event( element, :click )).to be_nil
 
-                    element.stub(:locate){ raise Watir::Exception::Error }
-                    @browser.fire_event( element, :click ).should be_nil
+                    allow(element).to receive(:locate){ raise Watir::Exception::Error }
+                    expect(@browser.fire_event( element, :click )).to be_nil
                 end
             end
         end
@@ -1261,9 +1393,9 @@ describe Arachni::Browser do
             it 'returns nil' do
                 element = @browser.watir.div( id: 'my-div' )
 
-                element.stub(:exists?) { false }
+                allow(element).to receive(:exists?) { false }
 
-                @browser.fire_event( element, :click ).should be_nil
+                expect(@browser.fire_event( element, :click )).to be_nil
             end
         end
 
@@ -1272,15 +1404,15 @@ describe Arachni::Browser do
 
             context Selenium::WebDriver::Error::WebDriverError do
                 it 'returns nil' do
-                    element.stub(:fire_event){ raise Selenium::WebDriver::Error::WebDriverError }
-                    @browser.fire_event( element, :click ).should be_nil
+                    allow(element).to receive(:fire_event){ raise Selenium::WebDriver::Error::WebDriverError }
+                    expect(@browser.fire_event( element, :click )).to be_nil
                 end
             end
 
             context Watir::Exception::Error do
                 it 'returns nil' do
-                    element.stub(:fire_event){ raise Watir::Exception::Error }
-                    @browser.fire_event( element, :click ).should be_nil
+                    allow(element).to receive(:fire_event){ raise Watir::Exception::Error }
+                    expect(@browser.fire_event( element, :click )).to be_nil
                 end
             end
         end
@@ -1304,10 +1436,12 @@ describe Arachni::Browser do
                             end
 
                             it 'fills in its inputs with the given values' do
-                                @browser.watir.div( id: 'container-name' ).text.should ==
+                                expect(@browser.watir.div( id: 'container-name' ).text).to eq(
                                     inputs[:name]
-                                @browser.watir.div( id: 'container-email' ).text.should ==
+                                )
+                                expect(@browser.watir.div( id: 'container-email' ).text).to eq(
                                     inputs[:email]
+                                )
                             end
 
                             it 'returns a playable transition' do
@@ -1317,15 +1451,17 @@ describe Arachni::Browser do
 
                                 @browser.load url
 
-                                @browser.watir.div( id: 'container-name' ).text.should be_empty
-                                @browser.watir.div( id: 'container-email' ).text.should be_empty
+                                expect(@browser.watir.div( id: 'container-name' ).text).to be_empty
+                                expect(@browser.watir.div( id: 'container-email' ).text).to be_empty
 
                                 transition.play @browser
 
-                                @browser.watir.div( id: 'container-name' ).text.should ==
+                                expect(@browser.watir.div( id: 'container-name' ).text).to eq(
                                     inputs[:name]
-                                @browser.watir.div( id: 'container-email' ).text.should ==
+                                )
+                                expect(@browser.watir.div( id: 'container-email' ).text).to eq(
                                     inputs[:email]
+                                )
                             end
 
                             context 'when the inputs contains non-UTF8 data' do
@@ -1339,10 +1475,12 @@ describe Arachni::Browser do
                                 end
 
                                 it 'recodes them' do
-                                    @browser.watir.div( id: 'container-name' ).text.should ==
+                                    expect(@browser.watir.div( id: 'container-name' ).text).to eq(
                                         inputs[:name].recode
-                                    @browser.watir.div( id: 'container-email' ).text.should ==
+                                    )
+                                    expect(@browser.watir.div( id: 'container-email' ).text).to eq(
                                         inputs[:email].recode
+                                    )
                                 end
                             end
 
@@ -1351,10 +1489,12 @@ describe Arachni::Browser do
                                     let(:url) { "#{@url}/fire_event/form/select" }
 
                                     it 'selects it' do
-                                        @browser.watir.div( id: 'container-name' ).text.should ==
+                                        expect(@browser.watir.div( id: 'container-name' ).text).to eq(
                                             inputs[:name]
-                                        @browser.watir.div( id: 'container-email' ).text.should ==
+                                        )
+                                        expect(@browser.watir.div( id: 'container-email' ).text).to eq(
                                             inputs[:email]
+                                        )
                                     end
                                 end
                             end
@@ -1365,9 +1505,10 @@ describe Arachni::Browser do
                                 end
 
                                 it 'leaves those empty' do
-                                    @browser.watir.div( id: 'container-name' ).text.should ==
+                                    expect(@browser.watir.div( id: 'container-name' ).text).to eq(
                                         inputs[:name]
-                                    @browser.watir.div( id: 'container-email' ).text.should be_empty
+                                    )
+                                    expect(@browser.watir.div( id: 'container-email' ).text).to be_empty
                                 end
 
                                 it 'returns a playable transition' do
@@ -1376,14 +1517,15 @@ describe Arachni::Browser do
 
                                     @browser.load url
 
-                                    @browser.watir.div( id: 'container-name' ).text.should be_empty
-                                    @browser.watir.div( id: 'container-email' ).text.should be_empty
+                                    expect(@browser.watir.div( id: 'container-name' ).text).to be_empty
+                                    expect(@browser.watir.div( id: 'container-email' ).text).to be_empty
 
                                     transition.play @browser
 
-                                    @browser.watir.div( id: 'container-name' ).text.should ==
+                                    expect(@browser.watir.div( id: 'container-name' ).text).to eq(
                                         inputs[:name]
-                                    @browser.watir.div( id: 'container-email' ).text.should be_empty
+                                    )
+                                    expect(@browser.watir.div( id: 'container-email' ).text).to be_empty
                                 end
                             end
 
@@ -1393,8 +1535,8 @@ describe Arachni::Browser do
                                 end
 
                                 it 'fills in empty values' do
-                                    @browser.watir.div( id: 'container-name' ).text.should be_empty
-                                    @browser.watir.div( id: 'container-email' ).text.should be_empty
+                                    expect(@browser.watir.div( id: 'container-name' ).text).to be_empty
+                                    expect(@browser.watir.div( id: 'container-email' ).text).to be_empty
                                 end
 
                                 it 'returns a playable transition' do
@@ -1403,13 +1545,13 @@ describe Arachni::Browser do
 
                                     @browser.load url
 
-                                    @browser.watir.div( id: 'container-name' ).text.should be_empty
-                                    @browser.watir.div( id: 'container-email' ).text.should be_empty
+                                    expect(@browser.watir.div( id: 'container-name' ).text).to be_empty
+                                    expect(@browser.watir.div( id: 'container-email' ).text).to be_empty
 
                                     transition.play @browser
 
-                                    @browser.watir.div( id: 'container-name' ).text.should be_empty
-                                    @browser.watir.div( id: 'container-email' ).text.should be_empty
+                                    expect(@browser.watir.div( id: 'container-name' ).text).to be_empty
+                                    expect(@browser.watir.div( id: 'container-email' ).text).to be_empty
                                 end
                             end
 
@@ -1417,9 +1559,10 @@ describe Arachni::Browser do
                                 let(:url) { "#{@url}/fire_event/form/disabled_inputs" }
 
                                 it 'is skips those inputs' do
-                                    @browser.watir.div( id: 'container-name' ).text.should ==
+                                    expect(@browser.watir.div( id: 'container-name' ).text).to eq(
                                         inputs[:name]
-                                    @browser.watir.div( id: 'container-email' ).text.should be_empty
+                                    )
+                                    expect(@browser.watir.div( id: 'container-email' ).text).to be_empty
                                 end
                             end
                         end
@@ -1429,10 +1572,12 @@ describe Arachni::Browser do
                                 @browser.load url
                                 @browser.fire_event @browser.watir.form, :submit
 
-                                @browser.watir.div( id: 'container-name' ).text.should ==
+                                expect(@browser.watir.div( id: 'container-name' ).text).to eq(
                                     Arachni::Options.input.value_for_name( 'name' )
-                                @browser.watir.div( id: 'container-email' ).text.should ==
+                                )
+                                expect(@browser.watir.div( id: 'container-email' ).text).to eq(
                                     Arachni::Options.input.value_for_name( 'email' )
+                                )
                             end
 
                             it 'returns a playable transition' do
@@ -1441,15 +1586,17 @@ describe Arachni::Browser do
 
                                 @browser.load url
 
-                                @browser.watir.div( id: 'container-name' ).text.should be_empty
-                                @browser.watir.div( id: 'container-email' ).text.should be_empty
+                                expect(@browser.watir.div( id: 'container-name' ).text).to be_empty
+                                expect(@browser.watir.div( id: 'container-email' ).text).to be_empty
 
                                 transition.play @browser
 
-                                @browser.watir.div( id: 'container-name' ).text.should ==
+                                expect(@browser.watir.div( id: 'container-name' ).text).to eq(
                                     Arachni::Options.input.value_for_name( 'name' )
-                                @browser.watir.div( id: 'container-email' ).text.should ==
+                                )
+                                expect(@browser.watir.div( id: 'container-email' ).text).to eq(
                                     Arachni::Options.input.value_for_name( 'email' )
+                                )
                             end
 
                             context 'and has disabled inputs' do
@@ -1458,9 +1605,10 @@ describe Arachni::Browser do
                                 it 'is skips those inputs' do
                                     @browser.fire_event @browser.watir.form, :submit
 
-                                    @browser.watir.div( id: 'container-name' ).text.should ==
+                                    expect(@browser.watir.div( id: 'container-name' ).text).to eq(
                                         Arachni::Options.input.value_for_name( 'name' )
-                                    @browser.watir.div( id: 'container-email' ).text.should be_empty
+                                    )
+                                    expect(@browser.watir.div( id: 'container-email' ).text).to be_empty
                                 end
                             end
                         end
@@ -1492,7 +1640,7 @@ describe Arachni::Browser do
 
                         @browser = described_class.new.start_capture
                         @browser.load( url )
-                        @browser.flush_pages.size.should == 1
+                        expect(@browser.flush_pages.size).to eq(1)
 
                         transition.play @browser
                         captured_pages = @browser.flush_pages
@@ -1525,8 +1673,9 @@ describe Arachni::Browser do
                                 end
 
                                 it 'fills in its inputs with the given values' do
-                                    @browser.watir.div( id: 'container' ).text.should ==
+                                    expect(@browser.watir.div( id: 'container' ).text).to eq(
                                         calculate_expectation.call( value )
+                                    )
                                 end
 
                                 it 'returns a playable transition' do
@@ -1534,11 +1683,12 @@ describe Arachni::Browser do
                                     transition = @browser.fire_event @browser.watir.input, event, value: value
 
                                     @browser.load url
-                                    @browser.watir.div( id: 'container' ).text.should be_empty
+                                    expect(@browser.watir.div( id: 'container' ).text).to be_empty
 
                                     transition.play @browser
-                                    @browser.watir.div( id: 'container' ).text.should ==
+                                    expect(@browser.watir.div( id: 'container' ).text).to eq(
                                         calculate_expectation.call( value )
+                                    )
                                 end
 
                                 context 'and is empty' do
@@ -1547,7 +1697,7 @@ describe Arachni::Browser do
                                     end
 
                                     it 'fills in empty values' do
-                                        @browser.watir.div( id: 'container' ).text.should be_empty
+                                        expect(@browser.watir.div( id: 'container' ).text).to be_empty
                                     end
 
                                     it 'returns a playable transition' do
@@ -1555,10 +1705,10 @@ describe Arachni::Browser do
                                         transition = @browser.fire_event @browser.watir.input, event, value: value
 
                                         @browser.load url
-                                        @browser.watir.div( id: 'container' ).text.should be_empty
+                                        expect(@browser.watir.div( id: 'container' ).text).to be_empty
 
                                         transition.play @browser
-                                        @browser.watir.div( id: 'container' ).text.should be_empty
+                                        expect(@browser.watir.div( id: 'container' ).text).to be_empty
                                     end
                                 end
                             end
@@ -1567,8 +1717,9 @@ describe Arachni::Browser do
                                 it 'fills in a sample value' do
                                     @browser.fire_event @browser.watir.input, event
 
-                                    @browser.watir.div( id: 'container' ).text.should ==
+                                    expect(@browser.watir.div( id: 'container' ).text).to eq(
                                         calculate_expectation.call( Arachni::Options.input.value_for_name( 'name' ) )
+                                    )
                                 end
 
                                 it 'returns a playable transition' do
@@ -1576,11 +1727,12 @@ describe Arachni::Browser do
                                     transition = @browser.fire_event @browser.watir.input, event
 
                                     @browser.load url
-                                    @browser.watir.div( id: 'container' ).text.should be_empty
+                                    expect(@browser.watir.div( id: 'container' ).text).to be_empty
 
                                     transition.play @browser
-                                    @browser.watir.div( id: 'container' ).text.should ==
+                                    expect(@browser.watir.div( id: 'container' ).text).to eq(
                                         calculate_expectation.call( Arachni::Options.input.value_for_name( 'name' ) )
+                                    )
                                 end
                             end
                         end
@@ -1604,7 +1756,7 @@ describe Arachni::Browser do
 
         let(:url) { @url + '/trigger_events' }
         it 'passes each element and event info to the block' do
-            elements_with_events.should == [
+            expect(elements_with_events).to eq([
                 [
                     described_class::ElementLocator.new(
                         tag_name:   'body',
@@ -1619,7 +1771,7 @@ describe Arachni::Browser do
                     ),
                     [[:onclick, 'addForm();']]
                 ]
-            ]
+            ])
         end
 
         context :a do
@@ -1628,7 +1780,7 @@ describe Arachni::Browser do
                     let(:url) { @url + '/each_element_with_events/a/href/javascript' }
 
                     it 'includes the :click event' do
-                        elements_with_events.should == [
+                        expect(elements_with_events).to eq([
                             [
                                 described_class::ElementLocator.new(
                                     tag_name:   'a',
@@ -1636,7 +1788,7 @@ describe Arachni::Browser do
                                 ),
                                 [[:click, 'javascript:doStuff()']]
                             ]
-                        ]
+                        ])
                     end
                 end
 
@@ -1644,7 +1796,7 @@ describe Arachni::Browser do
                     let(:url) { @url + '/each_element_with_events/a/href/regular' }
 
                     it 'is ignored' do
-                        elements_with_events.should be_empty
+                        expect(elements_with_events).to be_empty
                     end
                 end
 
@@ -1652,7 +1804,7 @@ describe Arachni::Browser do
                     let(:url) { @url + '/each_element_with_events/a/href/out-of-scope' }
 
                     it 'is ignored' do
-                        elements_with_events.should be_empty
+                        expect(elements_with_events).to be_empty
                     end
                 end
             end
@@ -1664,7 +1816,7 @@ describe Arachni::Browser do
                     let(:url) { @url + '/each_element_with_events/form/input/image' }
 
                     it 'includes the :click event' do
-                        elements_with_events.should == [
+                        expect(elements_with_events).to eq([
                             [
                                 described_class::ElementLocator.new(
                                     tag_name:   'input',
@@ -1676,7 +1828,7 @@ describe Arachni::Browser do
                                 ),
                                 [[:click, 'image']]
                             ]
-                        ]
+                        ])
                     end
                 end
             end
@@ -1686,7 +1838,7 @@ describe Arachni::Browser do
                     let(:url) { @url + '/each_element_with_events/form/action/javascript' }
 
                     it 'includes the :submit event' do
-                        elements_with_events.should == [
+                        expect(elements_with_events).to eq([
                             [
                                 described_class::ElementLocator.new(
                                     tag_name:   'form',
@@ -1696,7 +1848,7 @@ describe Arachni::Browser do
                                 ),
                                 [[:submit, 'javascript:doStuff()']]
                             ]
-                        ]
+                        ])
                     end
                 end
 
@@ -1704,7 +1856,7 @@ describe Arachni::Browser do
                     let(:url) { @url + '/each_element_with_events/form/action/regular' }
 
                     it 'is ignored'do
-                        elements_with_events.should be_empty
+                        expect(elements_with_events).to be_empty
                     end
                 end
 
@@ -1712,7 +1864,7 @@ describe Arachni::Browser do
                     let(:url) { @url + '/each_element_with_events/form/action/out-of-scope' }
 
                     it 'is ignored'do
-                        elements_with_events.should be_empty
+                        expect(elements_with_events).to be_empty
                     end
                 end
             end
@@ -1764,7 +1916,7 @@ describe Arachni::Browser do
 
         it 'assigns the proper page transitions' do
             pages = @browser.load( @url + '/explore' ).trigger_events.page_snapshots
-            pages.map(&:dom).map(&:transitions).should == [
+            expect(pages.map(&:dom).map(&:transitions)).to eq([
                 [
                     { :page => :load },
                     { "#{@url}explore" => :request }
@@ -1796,7 +1948,7 @@ describe Arachni::Browser do
                     },
                     { "#{@url}href-ajax" => :request },
                 ]
-            ].map { |transitions| transitions_from_array( transitions ) }
+            ].map { |transitions| transitions_from_array( transitions ) })
         end
 
         it 'follows all javascript links' do
@@ -1825,7 +1977,7 @@ describe Arachni::Browser do
         end
 
         it 'returns self' do
-            @browser.load( @url + '/explore' ).trigger_events.should == @browser
+            expect(@browser.load( @url + '/explore' ).trigger_events).to eq(@browser)
         end
     end
 
@@ -1834,21 +1986,21 @@ describe Arachni::Browser do
             @browser.load @url
 
             ua = Arachni::Options.http.user_agent
-            ua.should_not be_empty
+            expect(ua).not_to be_empty
 
-            @browser.source.should include( ua )
+            expect(@browser.source).to include( ua )
         end
     end
 
     describe '#watir' do
         it 'provides access to the Watir::Browser API' do
-            @browser.watir.should be_kind_of Watir::Browser
+            expect(@browser.watir).to be_kind_of Watir::Browser
         end
     end
 
     describe '#selenium' do
         it 'provides access to the Selenium::WebDriver::Driver API' do
-            @browser.selenium.should be_kind_of Selenium::WebDriver::Driver
+            expect(@browser.selenium).to be_kind_of Selenium::WebDriver::Driver
         end
     end
 
@@ -1857,9 +2009,9 @@ describe Arachni::Browser do
             @browser.goto @url
 
             ua = Arachni::Options.http.user_agent
-            ua.should_not be_empty
+            expect(ua).not_to be_empty
 
-            @browser.source.should include( ua )
+            expect(@browser.source).to include( ua )
         end
 
         it 'returns a playable transition' do
@@ -1870,35 +2022,35 @@ describe Arachni::Browser do
 
             transition.play( @browser )
             ua = Arachni::Options.http.user_agent
-            ua.should_not be_empty
+            expect(ua).not_to be_empty
 
-            @browser.source.should include( ua )
+            expect(@browser.source).to include( ua )
         end
 
         it 'puts the domain in the asset domains list' do
             subject.goto @url
-            described_class.asset_domains.should include Arachni::URI( @url ).domain
+            expect(described_class.asset_domains).to include Arachni::URI( @url ).domain
         end
 
         context 'when requesting the page URL' do
             it 'does not send If-None-Match request headers' do
                 subject.goto "#{@url}/If-None-Match"
-                subject.response.code.should == 200
-                subject.response.request.headers.should_not include 'If-None-Match'
+                expect(subject.response.code).to eq(200)
+                expect(subject.response.request.headers).not_to include 'If-None-Match'
 
                 subject.goto "#{@url}/If-None-Match"
-                subject.response.code.should == 200
-                subject.response.request.headers.should_not include 'If-None-Match'
+                expect(subject.response.code).to eq(200)
+                expect(subject.response.request.headers).not_to include 'If-None-Match'
             end
 
             it 'does not send If-Modified-Since request headers' do
                 subject.goto "#{@url}/If-Modified-Since"
-                subject.response.code.should == 200
-                subject.response.request.headers.should_not include 'If-Modified-Since'
+                expect(subject.response.code).to eq(200)
+                expect(subject.response.request.headers).not_to include 'If-Modified-Since'
 
                 subject.goto "#{@url}/If-Modified-Since"
-                subject.response.code.should == 200
-                subject.response.request.headers.should_not include 'If-Modified-Since'
+                expect(subject.response.code).to eq(200)
+                expect(subject.response.request.headers).not_to include 'If-Modified-Since'
             end
         end
 
@@ -1913,10 +2065,10 @@ describe Arachni::Browser do
                 end
 
                 subject.goto url
-                response.request.headers.should_not include 'If-None-Match'
+                expect(response.request.headers).not_to include 'If-None-Match'
 
                 subject.goto url
-                response.request.headers.should include 'If-None-Match'
+                expect(response.request.headers).to include 'If-None-Match'
             end
 
             it 'sends If-Modified-Since request headers' do
@@ -1929,10 +2081,10 @@ describe Arachni::Browser do
                 end
 
                 subject.goto url
-                response.request.headers.should_not include 'If-Modified-Since'
+                expect(response.request.headers).not_to include 'If-Modified-Since'
 
                 subject.goto url
-                response.request.headers.should include 'If-Modified-Since'
+                expect(response.request.headers).to include 'If-Modified-Since'
             end
         end
 
@@ -1949,7 +2101,7 @@ describe Arachni::Browser do
                     let(:url) { "#{super()}/#{type}" }
 
                     it 'whitelists it' do
-                        described_class.asset_domains.should include "#{type}.stuff"
+                        expect(described_class.asset_domains).to include "#{type}.stuff"
                     end
                 end
             end
@@ -1979,7 +2131,7 @@ describe Arachni::Browser do
                 subject.goto "#{@url}load_delay"
                 waited = Time.now - time
 
-                waited.should >= subject.load_delay / 1000.0
+                expect(waited).to be >= subject.load_delay / 1000.0
             end
         end
 
@@ -1990,7 +2142,7 @@ describe Arachni::Browser do
 
                 subject.goto "#{@url}/ajax_sleep?sleep=#{sleep_time}"
 
-                (Time.now - time).should >= sleep_time
+                expect(Time.now - time).to be >= sleep_time
             end
 
             context "when requests takes more than #{Arachni::OptionGroups::HTTP}#request_timeout" do
@@ -1998,16 +2150,29 @@ describe Arachni::Browser do
                     sleep_time = 5
                     Arachni::Options.http.request_timeout = 1_000
 
-                    Arachni::HTTP::ProxyServer.any_instance.stub(:has_connections?){ true }
+                    allow_any_instance_of(Arachni::HTTP::ProxyServer).to receive(:has_connections?){ true }
 
                     time = Time.now
                     subject.goto "#{@url}/ajax_sleep?sleep=#{sleep_time}"
 
-                    (Time.now - time).should < sleep_time
+                    expect(Time.now - time).to be < sleep_time
                 end
             end
         end
 
+        context "with #{Arachni::OptionGroups::BrowserCluster}#local_storage" do
+            before do
+                Arachni::Options.browser_cluster.local_storage = {
+                    'name' => 'value'
+                }
+            end
+
+            it 'sets the data as local storage' do
+                subject.load @url
+                expect( subject.javascript.run( 'return localStorage.getItem( "name" )' ) ).to eq 'value'
+            end
+        end
+
         context "with #{Arachni::OptionGroups::BrowserCluster}#wait_for_elements" do
             before do
                 Arachni::Options.browser_cluster.wait_for_elements = {
@@ -2019,9 +2184,9 @@ describe Arachni::Browser do
                 it 'waits for the element matching the CSS to appear' do
                     t = Time.now
                     @browser.goto( @url + '/wait_for_elements#stuff/here' )
-                    (Time.now - t).should > 5
+                    expect(Time.now - t).to be > 5
 
-                    @browser.watir.element( css: '#matchThis' ).tag_name.should == 'button'
+                    expect(@browser.watir.element( css: '#matchThis' ).tag_name).to eq('button')
                 end
 
                 it "waits a maximum of #{Arachni::OptionGroups::BrowserCluster}#job_timeout" do
@@ -2029,7 +2194,7 @@ describe Arachni::Browser do
 
                     t = Time.now
                     @browser.goto( @url + '/wait_for_elements#stuff/here' )
-                    (Time.now - t).should < 5
+                    expect(Time.now - t).to be < 5
 
                     expect do
                         @browser.watir.element( css: '#matchThis' ).tag_name
@@ -2041,7 +2206,7 @@ describe Arachni::Browser do
                 it 'does not wait' do
                     t = Time.now
                     @browser.goto( @url + '/wait_for_elements' )
-                    (Time.now - t).should < 5
+                    expect(Time.now - t).to be < 5
 
                     expect do
                         @browser.watir.element( css: '#matchThis' ).tag_name
@@ -2059,7 +2224,7 @@ describe Arachni::Browser do
 
                     @browser.load( "#{@url}form-with-image-button" )
 
-                    image_hit_count.should == 0
+                    expect(image_hit_count).to eq(0)
                 end
             end
 
@@ -2071,7 +2236,7 @@ describe Arachni::Browser do
 
                     @browser.load( "#{@url}form-with-image-button" )
 
-                    image_hit_count.should == 1
+                    expect(image_hit_count).to eq(1)
                 end
             end
         end
@@ -2094,14 +2259,14 @@ describe Arachni::Browser do
         context "with #{Arachni::OptionGroups::Scope}#redundant_path_patterns" do
             it 'respects scope restrictions' do
                 Arachni::Options.scope.redundant_path_patterns = { 'explore' => 0 }
-                @browser.load( @url + '/explore' ).response.code.should == 0
+                expect(@browser.load( @url + '/explore' ).response.code).to eq(0)
             end
         end
 
         context "with #{Arachni::OptionGroups::Scope}#auto_redundant_paths has bee configured" do
             it 'respects scope restrictions' do
                 Arachni::Options.scope.auto_redundant_paths = 0
-                @browser.load( @url + '/explore?test=1&test2=2' ).response.code.should == 0
+                expect(@browser.load( @url + '/explore?test=1&test2=2' ).response.code).to eq(0)
             end
         end
 
@@ -2110,26 +2275,26 @@ describe Arachni::Browser do
                 cookie = { 'myname' => 'myvalue' }
                 @browser.goto @url, cookies: cookie
 
-                @browser.cookies.find { |c| c.name == cookie.keys.first }.inputs.should == cookie
+                expect(@browser.cookies.find { |c| c.name == cookie.keys.first }.inputs).to eq(cookie)
             end
 
             it 'includes them in the transition' do
                 cookie = { 'myname' => 'myvalue' }
                 transition = @browser.goto( @url, cookies: cookie )
 
-                transition.options[:cookies].should == cookie
+                expect(transition.options[:cookies]).to eq(cookie)
             end
 
             context 'when auditing existing cookies' do
                 it 'preserves the HttpOnly attribute' do
                     @browser.goto( @url )
-                    @browser.cookies.size.should == 1
+                    expect(@browser.cookies.size).to eq(1)
 
                     cookies = { @browser.cookies.first.name => 'updated' }
                     @browser.goto( @url, cookies: cookies )
 
                     @browser.cookies.first.value == 'updated'
-                    @browser.cookies.first.should be_http_only
+                    expect(@browser.cookies.first).to be_http_only
                 end
             end
         end
@@ -2139,19 +2304,19 @@ describe Arachni::Browser do
                 it 'captures a snapshot of the loaded page' do
                     @browser.goto @url, take_snapshot: true
                     pages = @browser.page_snapshots
-                    pages.size.should == 1
+                    expect(pages.size).to eq(1)
 
-                    pages.first.dom.transitions.should == transitions_from_array([
+                    expect(pages.first.dom.transitions).to eq(transitions_from_array([
                         { page: :load },
                         { @url => :request }
-                    ])
+                    ]))
                 end
             end
 
             describe false do
                 it 'does not capture a snapshot of the loaded page' do
                     @browser.goto @url, take_snapshot:  false
-                    @browser.page_snapshots.should be_empty
+                    expect(@browser.page_snapshots).to be_empty
                 end
             end
 
@@ -2159,12 +2324,12 @@ describe Arachni::Browser do
                 it 'captures a snapshot of the loaded page' do
                     @browser.goto @url
                     pages = @browser.page_snapshots
-                    pages.size.should == 1
+                    expect(pages.size).to eq(1)
 
-                    pages.first.dom.transitions.should == transitions_from_array([
+                    expect(pages.first.dom.transitions).to eq(transitions_from_array([
                         { page: :load },
                         { @url => :request }
-                    ])
+                    ]))
                 end
             end
         end
@@ -2173,21 +2338,21 @@ describe Arachni::Browser do
             describe true do
                 it 'pushes the page load to the transitions' do
                     t = @browser.goto( @url, update_transitions: true )
-                    @browser.to_page.dom.transitions.should include t
+                    expect(@browser.to_page.dom.transitions).to include t
                 end
             end
 
             describe false do
                 it 'does not push the page load to the transitions' do
                     t = @browser.goto( @url, update_transitions: false )
-                    @browser.to_page.dom.transitions.should be_empty
+                    expect(@browser.to_page.dom.transitions).to be_empty
                 end
             end
 
             describe 'default' do
                 it 'pushes the page load to the transitions' do
                     t = @browser.goto( @url )
-                    @browser.to_page.dom.transitions.should include t
+                    expect(@browser.to_page.dom.transitions).to include t
                 end
             end
         end
@@ -2195,7 +2360,7 @@ describe Arachni::Browser do
 
     describe '#load' do
         it 'returns self' do
-            @browser.load( @url ).should == @browser
+            expect(@browser.load( @url )).to eq(@browser)
         end
 
         describe :cookies do
@@ -2203,7 +2368,7 @@ describe Arachni::Browser do
                 cookie = { 'myname' => 'myvalue' }
                 @browser.load @url, cookies: cookie
 
-                @browser.cookies.find { |c| c.name == cookie.keys.first }.inputs.should == cookie
+                expect(@browser.cookies.find { |c| c.name == cookie.keys.first }.inputs).to eq(cookie)
             end
         end
 
@@ -2212,19 +2377,19 @@ describe Arachni::Browser do
                 it 'captures a snapshot of the loaded page' do
                     @browser.load @url, take_snapshot: true
                     pages = @browser.page_snapshots
-                    pages.size.should == 1
+                    expect(pages.size).to eq(1)
 
-                    pages.first.dom.transitions.should == transitions_from_array([
+                    expect(pages.first.dom.transitions).to eq(transitions_from_array([
                         { page: :load },
                         { @url => :request }
-                    ])
+                    ]))
                 end
             end
 
             describe false do
                 it 'does not capture a snapshot of the loaded page' do
                     @browser.load @url, take_snapshot: false
-                    @browser.page_snapshots.should be_empty
+                    expect(@browser.page_snapshots).to be_empty
                 end
             end
 
@@ -2232,12 +2397,12 @@ describe Arachni::Browser do
                 it 'captures a snapshot of the loaded page' do
                     @browser.load @url
                     pages = @browser.page_snapshots
-                    pages.size.should == 1
+                    expect(pages.size).to eq(1)
 
-                    pages.first.dom.transitions.should == transitions_from_array([
+                    expect(pages.first.dom.transitions).to eq(transitions_from_array([
                         { page: :load },
                         { @url => :request }
-                    ])
+                    ]))
                 end
             end
         end
@@ -2245,41 +2410,41 @@ describe Arachni::Browser do
         context 'when given a' do
             describe String do
                 it 'treats it as a URL' do
-                    hit_count.should == 0
+                    expect(hit_count).to eq(0)
 
                     @browser.load @url
-                    @browser.source.should include( ua )
-                    @browser.preloads.should_not include( @url )
+                    expect(@browser.source).to include( ua )
+                    expect(@browser.preloads).not_to include( @url )
 
-                    hit_count.should == 1
+                    expect(hit_count).to eq(1)
                 end
             end
 
             describe Arachni::HTTP::Response do
                 it 'loads it' do
-                    hit_count.should == 0
+                    expect(hit_count).to eq(0)
 
                     @browser.load Arachni::HTTP::Client.get( @url, mode: :sync )
-                    @browser.source.should include( ua )
-                    @browser.preloads.should_not include( @url )
+                    expect(@browser.source).to include( ua )
+                    expect(@browser.preloads).not_to include( @url )
 
-                    hit_count.should == 1
+                    expect(hit_count).to eq(1)
                 end
             end
 
             describe Arachni::Page do
                 it 'loads it' do
-                    hit_count.should == 0
+                    expect(hit_count).to eq(0)
 
                     @browser.load Arachni::HTTP::Client.get( @url, mode: :sync ).to_page
-                    @browser.source.should include( ua )
-                    @browser.preloads.should_not include( @url )
+                    expect(@browser.source).to include( ua )
+                    expect(@browser.preloads).not_to include( @url )
 
-                    hit_count.should == 1
+                    expect(hit_count).to eq(1)
                 end
 
                 it 'uses its #cookie_jar' do
-                    @browser.cookies.should be_empty
+                    expect(@browser.cookies).to be_empty
 
                     page = Arachni::Page.from_data(
                         url:        @url,
@@ -2294,20 +2459,20 @@ describe Arachni::Browser do
                     )
 
                     @browser.load( page )
-                    @browser.cookies.should == page.cookie_jar
+                    expect(@browser.cookies).to eq(page.cookie_jar)
                 end
 
                 it 'replays its DOM#transitions' do
                     @browser.load "#{@url}play-transitions"
                     page = @browser.explore_and_flush.last
-                    page.body.should include ua
+                    expect(page.body).to include ua
 
                     @browser.load page
-                    @browser.source.should include ua
+                    expect(@browser.source).to include ua
 
                     page.dom.transitions.clear
                     @browser.load page
-                    @browser.source.should_not include ua
+                    expect(@browser.source).not_to include ua
                 end
 
                 it 'loads its DOM#skip_states' do
@@ -2316,7 +2481,7 @@ describe Arachni::Browser do
                         page_snapshots
 
                     page = pages.last
-                    page.dom.skip_states.should be_subset @browser.skip_states
+                    expect(page.dom.skip_states).to be_subset @browser.skip_states
 
                     token = @browser.generate_token
 
@@ -2324,7 +2489,7 @@ describe Arachni::Browser do
                     dpage.dom.skip_states << token
 
                     @browser.load dpage
-                    @browser.skip_states.should include token
+                    expect(@browser.skip_states).to include token
                 end
 
             end
@@ -2342,30 +2507,30 @@ describe Arachni::Browser do
             @browser.preload Arachni::HTTP::Client.get( @url, mode: :sync )
             clear_hit_count
 
-            hit_count.should == 0
+            expect(hit_count).to eq(0)
 
             @browser.load @url
-            @browser.source.should include( ua )
-            @browser.preloads.should_not include( @url )
+            expect(@browser.source).to include( ua )
+            expect(@browser.preloads).not_to include( @url )
 
-            hit_count.should == 0
+            expect(hit_count).to eq(0)
 
             2.times do
                 @browser.load @url
-                @browser.source.should include( ua )
+                expect(@browser.source).to include( ua )
             end
 
-            @browser.preloads.should_not include( @url )
+            expect(@browser.preloads).not_to include( @url )
 
-            hit_count.should == 2
+            expect(hit_count).to eq(2)
         end
 
         it 'returns the URL of the resource' do
             response = Arachni::HTTP::Client.get( @url, mode: :sync )
-            @browser.preload( response ).should == response.url
+            expect(@browser.preload( response )).to eq(response.url)
 
             @browser.load response.url
-            @browser.source.should include( ua )
+            expect(@browser.source).to include( ua )
         end
 
         context 'when given a' do
@@ -2374,13 +2539,13 @@ describe Arachni::Browser do
                     @browser.preload Arachni::HTTP::Client.get( @url, mode: :sync )
                     clear_hit_count
 
-                    hit_count.should == 0
+                    expect(hit_count).to eq(0)
 
                     @browser.load @url
-                    @browser.source.should include( ua )
-                    @browser.preloads.should_not include( @url )
+                    expect(@browser.source).to include( ua )
+                    expect(@browser.preloads).not_to include( @url )
 
-                    hit_count.should == 0
+                    expect(hit_count).to eq(0)
                 end
             end
 
@@ -2389,13 +2554,13 @@ describe Arachni::Browser do
                     @browser.preload Arachni::Page.from_url( @url )
                     clear_hit_count
 
-                    hit_count.should == 0
+                    expect(hit_count).to eq(0)
 
                     @browser.load @url
-                    @browser.source.should include( ua )
-                    @browser.preloads.should_not include( @url )
+                    expect(@browser.source).to include( ua )
+                    expect(@browser.preloads).not_to include( @url )
 
-                    hit_count.should == 0
+                    expect(hit_count).to eq(0)
                 end
             end
 
@@ -2412,31 +2577,31 @@ describe Arachni::Browser do
             @browser.cache Arachni::HTTP::Client.get( @url, mode: :sync )
             clear_hit_count
 
-            hit_count.should == 0
+            expect(hit_count).to eq(0)
 
             @browser.load @url
-            @browser.source.should include( ua )
-            @browser.cache.should include( @url )
+            expect(@browser.source).to include( ua )
+            expect(@browser.cache).to include( @url )
 
-            hit_count.should == 0
+            expect(hit_count).to eq(0)
 
             2.times do
                 @browser.load @url
-                @browser.source.should include( ua )
+                expect(@browser.source).to include( ua )
             end
 
-            @browser.cache.should include( @url )
+            expect(@browser.cache).to include( @url )
 
-            hit_count.should == 0
+            expect(hit_count).to eq(0)
         end
 
         it 'returns the URL of the resource' do
             response = Arachni::HTTP::Client.get( @url, mode: :sync )
-            @browser.cache( response ).should == response.url
+            expect(@browser.cache( response )).to eq(response.url)
 
             @browser.load response.url
-            @browser.source.should include( ua )
-            @browser.cache.should include( response.url )
+            expect(@browser.source).to include( ua )
+            expect(@browser.cache).to include( response.url )
         end
 
         context 'when given a' do
@@ -2445,13 +2610,13 @@ describe Arachni::Browser do
                     @browser.cache Arachni::HTTP::Client.get( @url, mode: :sync )
                     clear_hit_count
 
-                    hit_count.should == 0
+                    expect(hit_count).to eq(0)
 
                     @browser.load @url
-                    @browser.source.should include( ua )
-                    @browser.cache.should include( @url )
+                    expect(@browser.source).to include( ua )
+                    expect(@browser.cache).to include( @url )
 
-                    hit_count.should == 0
+                    expect(hit_count).to eq(0)
                 end
             end
 
@@ -2460,13 +2625,13 @@ describe Arachni::Browser do
                     @browser.cache Arachni::Page.from_url( @url )
                     clear_hit_count
 
-                    hit_count.should == 0
+                    expect(hit_count).to eq(0)
 
                     @browser.load @url
-                    @browser.source.should include( ua )
-                    @browser.cache.should include( @url )
+                    expect(@browser.source).to include( ua )
+                    expect(@browser.cache).to include( @url )
 
-                    hit_count.should == 0
+                    expect(hit_count).to eq(0)
                 end
             end
 
@@ -2486,21 +2651,21 @@ describe Arachni::Browser do
             @browser.load @url + '/with-ajax'
 
             pages = @browser.captured_pages
-            pages.size.should == 2
+            expect(pages.size).to eq(2)
 
             page = pages.first
-            page.forms.find { |form| form.inputs.include? 'ajax-token' }.should be_true
+            expect(page.forms.find { |form| form.inputs.include? 'ajax-token' }).to be_truthy
         end
 
         context 'when an element has already been seen' do
             context 'by the browser' do
                 it 'ignores it' do
                     @browser.load @url + '/with-ajax'
-                    @browser.captured_pages.size.should == 2
+                    expect(@browser.captured_pages.size).to eq(2)
                     @browser.captured_pages.clear
 
                     @browser.load @url + '/with-ajax'
-                    @browser.captured_pages.should be_empty
+                    expect(@browser.captured_pages).to be_empty
                 end
             end
 
@@ -2512,7 +2677,7 @@ describe Arachni::Browser do
 
                     @browser = described_class.new
                     @browser.load @url + '/with-ajax'
-                    @browser.captured_pages.should be_empty
+                    expect(@browser.captured_pages).to be_empty
                 end
             end
         end
@@ -2522,16 +2687,16 @@ describe Arachni::Browser do
                 @browser.load @url + '/with-ajax'
 
                 pages = @browser.captured_pages
-                pages.size.should == 2
+                expect(pages.size).to eq(2)
 
                 page = pages.first
 
                 form = page.forms.find { |form| form.inputs.include? 'ajax-token' }
 
-                form.url.should == @url + 'with-ajax'
-                form.action.should == @url + 'get-ajax'
-                form.inputs.should == { 'ajax-token' => 'my-token' }
-                form.method.should == :get
+                expect(form.url).to eq(@url + 'with-ajax')
+                expect(form.action).to eq(@url + 'get-ajax')
+                expect(form.inputs).to eq({ 'ajax-token' => 'my-token' })
+                expect(form.method).to eq(:get)
             end
         end
 
@@ -2541,15 +2706,15 @@ describe Arachni::Browser do
                     @browser.load @url + '/with-ajax'
 
                     pages = @browser.captured_pages
-                    pages.size.should == 2
+                    expect(pages.size).to eq(2)
 
                     form = find_page_with_form_with_input( pages, 'post-name' ).
                         forms.find { |form| form.inputs.include? 'post-name' }
 
-                    form.url.should == @url + 'with-ajax'
-                    form.action.should == @url + 'post-ajax'
-                    form.inputs.should == { 'post-name' => 'post-value' }
-                    form.method.should == :post
+                    expect(form.url).to eq(@url + 'with-ajax')
+                    expect(form.action).to eq(@url + 'post-ajax')
+                    expect(form.inputs).to eq({ 'post-name' => 'post-value' })
+                    expect(form.method).to eq(:post)
                 end
             end
 
@@ -2558,15 +2723,15 @@ describe Arachni::Browser do
                     @browser.load @url + '/with-ajax-json'
 
                     pages = @browser.captured_pages
-                    pages.size.should == 1
+                    expect(pages.size).to eq(1)
 
                     form = find_page_with_json_with_input( pages, 'post-name' ).
                         jsons.find { |json| json.inputs.include? 'post-name' }
 
-                    form.url.should == @url + 'with-ajax-json'
-                    form.action.should == @url + 'post-ajax'
-                    form.inputs.should == { 'post-name' => 'post-value' }
-                    form.method.should == :post
+                    expect(form.url).to eq(@url + 'with-ajax-json')
+                    expect(form.action).to eq(@url + 'post-ajax')
+                    expect(form.inputs).to eq({ 'post-name' => 'post-value' })
+                    expect(form.method).to eq(:post)
                 end
             end
 
@@ -2575,15 +2740,15 @@ describe Arachni::Browser do
                     @browser.load @url + '/with-ajax-xml'
 
                     pages = @browser.captured_pages
-                    pages.size.should == 1
+                    expect(pages.size).to eq(1)
 
                     form = find_page_with_xml_with_input( pages, 'input > text()' ).
                         xmls.find { |xml| xml.inputs.include? 'input > text()' }
 
-                    form.url.should == @url + 'with-ajax-xml'
-                    form.action.should == @url + 'post-ajax'
-                    form.inputs.should == { 'input > text()' => 'stuff' }
-                    form.method.should == :post
+                    expect(form.url).to eq(@url + 'with-ajax-xml')
+                    expect(form.action).to eq(@url + 'post-ajax')
+                    expect(form.inputs).to eq({ 'input > text()' => 'stuff' })
+                    expect(form.method).to eq(:post)
                 end
             end
         end
@@ -2595,15 +2760,15 @@ describe Arachni::Browser do
             @browser.load @url + '/with-ajax'
 
             pages = @browser.flush_pages
-            pages.size.should == 3
-            @browser.flush_pages.should be_empty
+            expect(pages.size).to eq(3)
+            expect(@browser.flush_pages).to be_empty
         end
     end
 
     describe '#stop_capture' do
         it 'stops the page capture' do
             @browser.stop_capture
-            @browser.capture?.should be_false
+            expect(@browser.capture?).to be_falsey
         end
     end
 
@@ -2611,20 +2776,20 @@ describe Arachni::Browser do
         it 'returns false' do
             @browser.start_capture
             @browser.stop_capture
-            @browser.capture?.should be_false
+            expect(@browser.capture?).to be_falsey
         end
 
         context 'when capturing pages' do
             it 'returns true' do
                 @browser.start_capture
-                @browser.capture?.should be_true
+                expect(@browser.capture?).to be_truthy
             end
         end
         context 'when not capturing pages' do
             it 'returns false' do
                 @browser.start_capture
                 @browser.stop_capture
-                @browser.capture?.should be_false
+                expect(@browser.capture?).to be_falsey
             end
         end
     end
@@ -2632,17 +2797,17 @@ describe Arachni::Browser do
     describe '#cookies' do
         it 'returns the browser cookies' do
             @browser.load @url
-            @browser.cookies.size.should == 1
+            expect(@browser.cookies.size).to eq(1)
             cookie = @browser.cookies.first
 
-            cookie.should be_kind_of Arachni::Cookie
-            cookie.name.should  == 'This name should be updated; and properly escaped'
-            cookie.value.should == 'This value should be updated; and properly escaped'
+            expect(cookie).to be_kind_of Arachni::Cookie
+            expect(cookie.name).to  eq('This name should be updated; and properly escaped')
+            expect(cookie.value).to eq('This value should be updated; and properly escaped')
         end
 
         it 'preserves the HttpOnly attribute' do
             @browser.load @url
-            @browser.cookies.first.should be_http_only
+            expect(@browser.cookies.first).to be_http_only
         end
 
         context 'when parsing v1 cookies' do
@@ -2652,13 +2817,13 @@ describe Arachni::Browser do
                 @browser.load @url
                 @browser.javascript.run( "document.cookie = '#{cookie}';" )
 
-                @browser.cookies.first.value.should == '06142010_0:e275d357943e9a2de0'
+                expect(@browser.cookies.first.value).to eq('06142010_0:e275d357943e9a2de0')
             end
         end
 
         context 'when no page is available' do
             it 'returns an empty Array' do
-                @browser.cookies.should be_empty
+                expect(@browser.cookies).to be_empty
             end
         end
     end
@@ -2677,7 +2842,7 @@ describe Arachni::Browser do
         let(:url) { @url + '/trigger_events' }
 
         it 'returns a DOM digest' do
-            snapshot_id.should == @browser.load( url ).snapshot_id
+            expect(snapshot_id).to eq(@browser.load( url ).snapshot_id)
         end
 
         context :a do
@@ -2686,7 +2851,7 @@ describe Arachni::Browser do
                     let(:url) { @url + '/each_element_with_events/a/href/javascript' }
 
                     it 'takes it into account' do
-                        snapshot_id.should_not == empty_snapshot_id
+                        expect(snapshot_id).not_to eq(empty_snapshot_id)
                     end
                 end
 
@@ -2694,7 +2859,7 @@ describe Arachni::Browser do
                     let(:url) { @url + '/each_element_with_events/a/href/regular' }
 
                     it 'takes it into account' do
-                        snapshot_id.should_not == empty_snapshot_id
+                        expect(snapshot_id).not_to eq(empty_snapshot_id)
                     end
                 end
 
@@ -2702,7 +2867,7 @@ describe Arachni::Browser do
                     let(:url) { @url + '/each_element_with_events/a/href/out-of-scope' }
 
                     it 'is ignored' do
-                        snapshot_id.should == empty_snapshot_id
+                        expect(snapshot_id).to eq(empty_snapshot_id)
                     end
                 end
             end
@@ -2711,7 +2876,7 @@ describe Arachni::Browser do
                 let(:url) { @url + '/each_element_with_events/a/href/empty' }
 
                 it 'takes it into account' do
-                    snapshot_id.should_not == empty_snapshot_id
+                    expect(snapshot_id).not_to eq(empty_snapshot_id)
                 end
             end
         end
@@ -2724,7 +2889,7 @@ describe Arachni::Browser do
                     let(:url) { @url + '/each_element_with_events/form/input/image' }
 
                     it 'takes it into account' do
-                        snapshot_id.should_not == empty_snapshot_id
+                        expect(snapshot_id).not_to eq(empty_snapshot_id)
                     end
                 end
             end
@@ -2734,7 +2899,7 @@ describe Arachni::Browser do
                     let(:url) { @url + '/each_element_with_events/form/action/javascript' }
 
                     it 'takes it into account' do
-                        snapshot_id.should_not == empty_snapshot_id
+                        expect(snapshot_id).not_to eq(empty_snapshot_id)
                     end
                 end
 
@@ -2742,7 +2907,7 @@ describe Arachni::Browser do
                     let(:url) { @url + '/each_element_with_events/form/action/regular' }
 
                     it 'takes it into account' do
-                        snapshot_id.should_not == empty_snapshot_id
+                        expect(snapshot_id).not_to eq(empty_snapshot_id)
                     end
                 end
 
@@ -2750,7 +2915,7 @@ describe Arachni::Browser do
                     let(:url) { @url + '/each_element_with_events/form/action/out-of-scope' }
 
                     it 'is ignored' do
-                        snapshot_id.should == empty_snapshot_id
+                        expect(snapshot_id).to eq(empty_snapshot_id)
                     end
                 end
             end