arachni 1.2.1 → 1.3

data/spec/arachni/page/scope_spec.rb

@@ -12,22 +12,22 @@ describe Arachni::Page::Scope do
 
     describe '#out?' do
         it 'returns false' do
-            subject.out?.should be_false
+            expect(subject.out?).to be_falsey
         end
 
         context "when #{Arachni::HTTP::Response::Scope}#out?" do
             context true do
                 it 'returns true' do
                     # We can't stub #out? because we also override it.
-                    Arachni::HTTP::Response::Scope.any_instance.stub(:exclude?) { true }
-                    subject.out?.should be_true
+                    allow_any_instance_of(Arachni::HTTP::Response::Scope).to receive(:exclude?) { true }
+                    expect(subject.out?).to be_truthy
                 end
             end
 
             context false do
                 it 'returns false' do
-                    Arachni::HTTP::Response::Scope.any_instance.stub(:exclude?) { false }
-                    subject.out?.should be_false
+                    allow_any_instance_of(Arachni::HTTP::Response::Scope).to receive(:exclude?) { false }
+                    expect(subject.out?).to be_falsey
                 end
             end
         end
@@ -35,15 +35,15 @@ describe Arachni::Page::Scope do
         context 'when #dom_depth_limit_reached?' do
             context true do
                 it 'returns true' do
-                    subject.stub(:dom_depth_limit_reached?) { true }
-                    subject.out?.should be_true
+                    allow(subject).to receive(:dom_depth_limit_reached?) { true }
+                    expect(subject.out?).to be_truthy
                 end
             end
 
             context false do
                 it 'returns false' do
-                    subject.stub(:dom_depth_limit_reached?) { false }
-                    subject.out?.should be_false
+                    allow(subject).to receive(:dom_depth_limit_reached?) { false }
+                    expect(subject.out?).to be_falsey
                 end
             end
         end
@@ -54,24 +54,24 @@ describe Arachni::Page::Scope do
             context 'been exceeded' do
                 it 'returns true' do
                     scope.dom_depth_limit = 2
-                    page.dom.stub(:depth) { 3 }
+                    allow(page.dom).to receive(:depth) { 3 }
 
-                    subject.dom_depth_limit_reached?.should be_true
+                    expect(subject.dom_depth_limit_reached?).to be_truthy
                 end
             end
 
             context 'not been exceeded' do
                 it 'returns false' do
                     scope.dom_depth_limit = 2
-                    page.dom.stub(:depth) { 1 }
-                    subject.dom_depth_limit_reached?.should be_false
+                    allow(page.dom).to receive(:depth) { 1 }
+                    expect(subject.dom_depth_limit_reached?).to be_falsey
                 end
             end
 
             context 'not been set' do
                 it 'returns false' do
-                    page.dom.stub(:depth) { 3 }
-                    subject.dom_depth_limit_reached?.should be_false
+                    allow(page.dom).to receive(:depth) { 3 }
+                    expect(subject.dom_depth_limit_reached?).to be_falsey
                 end
             end
         end

data/spec/arachni/page_spec.rb

@@ -48,36 +48,36 @@ describe Arachni::Page do
 
     it "supports #{Arachni::RPC::Serializer}" do
         page_with_nonces.forms = page_with_nonces.forms
-        page_with_nonces.should == Arachni::RPC::Serializer.deep_clone( page_with_nonces )
+        expect(page_with_nonces).to eq(Arachni::RPC::Serializer.deep_clone( page_with_nonces ))
     end
 
     describe '#to_rpc_data' do
         subject { rpc_subject }
 
         it "includes 'metadata'" do
-            data['metadata'].should == subject.metadata
+            expect(data['metadata']).to eq(subject.metadata)
         end
 
         %w(response dom).each do |attribute|
             it "includes '#{attribute}'" do
-                data[attribute].should == subject.send( attribute ).to_rpc_data
+                expect(data[attribute]).to eq(subject.send( attribute ).to_rpc_data)
             end
         end
 
         it "includes 'forms'" do
-            data['forms'].should == subject.forms.map(&:to_rpc_data)
+            expect(data['forms']).to eq(subject.forms.map(&:to_rpc_data))
         end
 
         it "includes 'do_not_audit_elements'" do
-            data['do_not_audit_elements'].should be_true
+            expect(data['do_not_audit_elements']).to be_truthy
         end
 
         it "includes 'element_audit_whitelist'" do
-            data['element_audit_whitelist'].should == subject.element_audit_whitelist.to_a
+            expect(data['element_audit_whitelist']).to eq(subject.element_audit_whitelist.to_a)
         end
 
         it "does not include 'cookie_jar'" do
-            data.should_not include 'cookie_jar'
+            expect(data).not_to include 'cookie_jar'
         end
     end
 
@@ -88,50 +88,50 @@ describe Arachni::Page do
 
         %w(response dom metadata forms).each do |attribute|
             it "restores '#{attribute}'" do
-                restored.send( attribute ).should == subject.send( attribute )
+                expect(restored.send( attribute )).to eq(subject.send( attribute ))
             end
         end
 
         it "restores #{described_class::DOM}#page" do
-            restored.dom.page.should == subject
+            expect(restored.dom.page).to eq(subject)
         end
 
         it "restores 'do_not_audit_elements'" do
-            restored.instance_variable_get(:@do_not_audit_elements).should be_true
+            expect(restored.instance_variable_get(:@do_not_audit_elements)).to be_truthy
         end
 
         it "restores 'element_audit_whitelist'" do
-            restored.element_audit_whitelist.should == subject.element_audit_whitelist
+            expect(restored.element_audit_whitelist).to eq(subject.element_audit_whitelist)
         end
 
         it 'restores Arachni::Element::Form#node of #forms' do
             form = subject.forms.last
-            form.node.should be_kind_of Nokogiri::XML::Element
-            form.node.should be_true
+            expect(form.node).to be_kind_of Nokogiri::XML::Element
+            expect(form.node).to be_truthy
 
-            restored.forms.last.node.to_s.should == form.node.to_s
+            expect(restored.forms.last.node.to_s).to eq(form.node.to_s)
         end
 
         it 'restores Arachni::Element::Link#node of #links' do
             link = subject.links.last
-            link.node.should be_kind_of Nokogiri::XML::Element
-            link.node.should be_true
+            expect(link.node).to be_kind_of Nokogiri::XML::Element
+            expect(link.node).to be_truthy
 
-            restored.links.last.node.to_s.should == link.node.to_s
+            expect(restored.links.last.node.to_s).to eq(link.node.to_s)
         end
 
         context Arachni::Page::DOM do
             [:url, :skip_states, :transitions, :data_flow_sinks, :execution_flow_sinks].each do |m|
                 it "restores ##{m}" do
                     # Make sure we're not comparing nils.
-                    subject.dom.send( m ).should be_true
+                    expect(subject.dom.send( m )).to be_truthy
 
                     # Make sure we're not comparing empty stuff.
                     if (enumerable = restored.dom.send( m )).is_a? Enumerable
-                        enumerable.should be_any
+                        expect(enumerable).to be_any
                     end
 
-                    restored.dom.send( m ).should == subject.dom.send( m )
+                    expect(restored.dom.send( m )).to eq(subject.dom.send( m ))
                 end
             end
         end
@@ -145,18 +145,18 @@ describe Arachni::Page do
                     page   = described_class.new( response: response )
                     parser = Arachni::Parser.new( response )
 
-                    page.url.should == parser.url
-                    page.method.should == parser.response.request.method
-                    page.response.should == parser.response
-                    page.body.should == parser.response.body
-                    page.query_vars.should == parser.link_vars
-                    page.paths.should == parser.paths
-                    page.links.should == parser.links
-                    page.forms.should == parser.forms
-                    page.cookies.should == parser.cookies_to_be_audited
-                    page.headers.should == parser.headers
-                    page.cookie_jar.should == parser.cookie_jar
-                    page.text?.should == parser.text?
+                    expect(page.url).to eq(parser.url)
+                    expect(page.method).to eq(parser.response.request.method)
+                    expect(page.response).to eq(parser.response)
+                    expect(page.body).to eq(parser.response.body)
+                    expect(page.query_vars).to eq(parser.link_vars)
+                    expect(page.paths).to eq(parser.paths)
+                    expect(page.links).to eq(parser.links)
+                    expect(page.forms).to eq(parser.forms)
+                    expect(page.cookies).to eq(parser.cookies_to_be_audited)
+                    expect(page.headers).to eq(parser.headers)
+                    expect(page.cookie_jar).to eq(parser.cookie_jar)
+                    expect(page.text?).to eq(parser.text?)
                 end
             end
 
@@ -165,18 +165,18 @@ describe Arachni::Page do
                     parser = Arachni::Parser.new( response )
                     page   = described_class.new( parser: parser )
 
-                    page.url.should == parser.url
-                    page.method.should == parser.response.request.method
-                    page.response.should == parser.response
-                    page.body.should == parser.response.body
-                    page.query_vars.should == parser.link_vars
-                    page.paths.should == parser.paths
-                    page.links.should == parser.links
-                    page.forms.should == parser.forms
-                    page.cookies.should == parser.cookies_to_be_audited
-                    page.headers.should == parser.headers
-                    page.cookie_jar.should == parser.cookie_jar
-                    page.text?.should == parser.text?
+                    expect(page.url).to eq(parser.url)
+                    expect(page.method).to eq(parser.response.request.method)
+                    expect(page.response).to eq(parser.response)
+                    expect(page.body).to eq(parser.response.body)
+                    expect(page.query_vars).to eq(parser.link_vars)
+                    expect(page.paths).to eq(parser.paths)
+                    expect(page.links).to eq(parser.links)
+                    expect(page.forms).to eq(parser.forms)
+                    expect(page.cookies).to eq(parser.cookies_to_be_audited)
+                    expect(page.headers).to eq(parser.headers)
+                    expect(page.cookie_jar).to eq(parser.cookie_jar)
+                    expect(page.text?).to eq(parser.text?)
                 end
             end
 
@@ -192,8 +192,8 @@ describe Arachni::Page do
                         }
                     ).dom
 
-                    dom.url.should == 'http://test/#/stuff'
-                    dom.transitions.should == [ page: :load ]
+                    expect(dom.url).to eq('http://test/#/stuff')
+                    expect(dom.transitions).to eq([ page: :load ])
                 end
             end
         end
@@ -214,16 +214,16 @@ describe Arachni::Page do
     describe '#element_audit_whitelist' do
         describe 'by default' do
             it 'returns an empty Set' do
-                subject.element_audit_whitelist.should be_empty
-                subject.element_audit_whitelist.should be_kind_of Set
+                expect(subject.element_audit_whitelist).to be_empty
+                expect(subject.element_audit_whitelist).to be_kind_of Set
             end
         end
     end
 
     describe '#performer' do
         it "returns the #{Arachni::HTTP::Request}#performer" do
-            page.request.stub(:performer){ :stuff }
-            subject.performer.should == :stuff
+            allow(page.request).to receive(:performer){ :stuff }
+            expect(subject.performer).to eq(:stuff)
         end
     end
 
@@ -232,14 +232,14 @@ describe Arachni::Page do
             context Arachni::Element::Capabilities::Auditable do
                 it 'updates the #element_audit_whitelist' do
                     subject.update_element_audit_whitelist subject.elements.first
-                    subject.element_audit_whitelist.should include subject.elements.first.coverage_hash
+                    expect(subject.element_audit_whitelist).to include subject.elements.first.coverage_hash
                 end
             end
 
             context Integer do
                 it 'updates the #element_audit_whitelist' do
                     subject.update_element_audit_whitelist subject.elements.first.coverage_hash
-                    subject.element_audit_whitelist.should include subject.elements.first.coverage_hash
+                    expect(subject.element_audit_whitelist).to include subject.elements.first.coverage_hash
                 end
             end
 
@@ -247,16 +247,16 @@ describe Arachni::Page do
                 context Arachni::Element::Capabilities::Auditable do
                     it 'updates the #element_audit_whitelist' do
                         subject.update_element_audit_whitelist [subject.elements[0],subject.elements[1]]
-                        subject.element_audit_whitelist.should include subject.elements[0].coverage_hash
-                        subject.element_audit_whitelist.should include subject.elements[1].coverage_hash
+                        expect(subject.element_audit_whitelist).to include subject.elements[0].coverage_hash
+                        expect(subject.element_audit_whitelist).to include subject.elements[1].coverage_hash
                     end
                 end
 
                 context Integer do
                     it 'updates the #element_audit_whitelist' do
                         subject.update_element_audit_whitelist [subject.elements[0].coverage_hash, subject.elements[1].coverage_hash]
-                        subject.element_audit_whitelist.should include subject.elements[0].coverage_hash
-                        subject.element_audit_whitelist.should include subject.elements[1].coverage_hash
+                        expect(subject.element_audit_whitelist).to include subject.elements[0].coverage_hash
+                        expect(subject.element_audit_whitelist).to include subject.elements[1].coverage_hash
                     end
                 end
             end
@@ -266,19 +266,19 @@ describe Arachni::Page do
     describe '#do_not_audit_elements' do
         it 'forces #audit_element? to always return false' do
             subject.do_not_audit_elements
-            subject.element_audit_whitelist.should be_empty
-            subject.audit_element?( subject.elements.first ).should be_false
+            expect(subject.element_audit_whitelist).to be_empty
+            expect(subject.audit_element?( subject.elements.first )).to be_falsey
 
             subject.update_element_audit_whitelist subject.elements.first
-            subject.audit_element?( subject.elements.first ).should be_false
+            expect(subject.audit_element?( subject.elements.first )).to be_falsey
         end
     end
 
     describe '#audit_element?' do
         context 'when there is no #element_audit_whitelist' do
             it 'returns true' do
-                subject.element_audit_whitelist.should be_empty
-                subject.audit_element?( subject.elements.first ).should be_true
+                expect(subject.element_audit_whitelist).to be_empty
+                expect(subject.audit_element?( subject.elements.first )).to be_truthy
             end
         end
 
@@ -288,14 +288,14 @@ describe Arachni::Page do
                     context Integer do
                         it 'returns true' do
                             subject.update_element_audit_whitelist subject.elements.first
-                            subject.audit_element?( subject.elements.first.coverage_hash ).should be_true
+                            expect(subject.audit_element?( subject.elements.first.coverage_hash )).to be_truthy
                         end
                     end
 
                     context Arachni::Element::Capabilities::Auditable do
                         it 'returns true' do
                             subject.update_element_audit_whitelist subject.elements.first
-                            subject.audit_element?( subject.elements.first ).should be_true
+                            expect(subject.audit_element?( subject.elements.first )).to be_truthy
                         end
                     end
                 end
@@ -305,14 +305,14 @@ describe Arachni::Page do
                     context Integer do
                         it 'returns false' do
                             subject.update_element_audit_whitelist subject.elements.first
-                            subject.audit_element?( subject.elements.last.coverage_hash ).should be_false
+                            expect(subject.audit_element?( subject.elements.last.coverage_hash )).to be_falsey
                         end
                     end
 
                     context Arachni::Element::Capabilities::Auditable do
                         it 'returns false' do
                             subject.update_element_audit_whitelist subject.elements.first
-                            subject.audit_element?( subject.elements.last ).should be_false
+                            expect(subject.audit_element?( subject.elements.last )).to be_falsey
                         end
                     end
                 end
@@ -322,27 +322,27 @@ describe Arachni::Page do
 
     describe '#response' do
         it 'returns the HTTP response for that page' do
-            page.response.should == response
+            expect(page.response).to eq(response)
         end
     end
 
     describe '#request' do
         it 'returns the HTTP request for that page' do
-            page.request.should == response.request
+            expect(page.request).to eq(response.request)
         end
     end
 
     describe '#body=' do
         it 'sets the #body' do
             subject.body = 'stuff'
-            subject.body.should == 'stuff'
+            expect(subject.body).to eq('stuff')
         end
         it 'sets the applicable #parser body' do
             subject.body = 'stuff'
-            subject.parser.body.should == 'stuff'
+            expect(subject.parser.body).to eq('stuff')
         end
         it 'calls #clear_cache' do
-            subject.should receive(:clear_cache)
+            expect(subject).to receive(:clear_cache)
             subject.body = 'stuff'
         end
         it 'resets the #has_script? flag' do
@@ -351,24 +351,24 @@ describe Arachni::Page do
                 headers: { 'content-type' => 'text/html' }
             )
 
-            page.has_script?.should be_false
+            expect(page.has_script?).to be_falsey
             page.body = '<script></script>'
-            page.has_script?.should be_true
+            expect(page.has_script?).to be_truthy
         end
     end
 
     describe '#parser' do
         it 'is lazy-loaded' do
-            subject.cache[:parser].should be_nil
-            subject.parser.should be_kind_of Arachni::Parser
-            subject.cache[:parser].should == subject.parser
+            expect(subject.cache[:parser]).to be_nil
+            expect(subject.parser).to be_kind_of Arachni::Parser
+            expect(subject.cache[:parser]).to eq(subject.parser)
         end
 
         it 'is cached' do
             s = subject.dup
 
             s.parser
-            Arachni::Parser.should_not receive(:new)
+            expect(Arachni::Parser).not_to receive(:new)
             s.parser
         end
 
@@ -377,11 +377,11 @@ describe Arachni::Page do
                 response: response.tap { |r| r.body = 'blah'},
                 body:     'stuff'
             )
-            page.body.should == 'stuff'
-            page.parser.body.should == page.body
+            expect(page.body).to eq('stuff')
+            expect(page.parser.body).to eq(page.body)
 
             page.body = 'stuff2'
-            page.parser.body.should == page.body
+            expect(page.parser.body).to eq(page.body)
         end
     end
 
@@ -391,18 +391,18 @@ describe Arachni::Page do
 
         describe "##{element}" do
             it 'sets the correct #page association' do
-                subject.send(element).each { |e| e.page.should == subject }
+                subject.send(element).each { |e| expect(e.page).to eq(subject) }
             end
 
             it 'is lazy-loaded' do
-                subject.cache[element].should be_nil
-                subject.send(element).should be_any
-                subject.cache[element].should == subject.send(element)
+                expect(subject.cache[element]).to be_nil
+                expect(subject.send(element)).to be_any
+                expect(subject.cache[element]).to eq(subject.send(element))
             end
 
             it 'delegates to Parser' do
                 s = subject.dup
-                s.parser.should receive(parser_method).and_return([])
+                expect(s.parser).to receive(parser_method).and_return([])
                 s.send(element)
             end
 
@@ -410,12 +410,12 @@ describe Arachni::Page do
                 s = subject.dup
 
                 s.send(element)
-                s.parser.should_not receive(parser_method)
+                expect(s.parser).not_to receive(parser_method)
                 s.send(element)
             end
 
             it 'is frozen' do
-                subject.send(element).should be_frozen
+                expect(subject.send(element)).to be_frozen
             end
         end
 
@@ -425,33 +425,33 @@ describe Arachni::Page do
             let(:list) { [element_klass.new( url: subject.url, inputs: { test: 1 } )] }
 
             it "sets the page ##{element}" do
-                subject.send(element).should be_any
+                expect(subject.send(element)).to be_any
                 subject.send("#{element}=", [])
-                subject.send(element).should be_empty
+                expect(subject.send(element)).to be_empty
                 subject.send("#{element}=", list)
-                subject.send(element).should == list
+                expect(subject.send(element)).to eq(list)
             end
 
             it 'caches it' do
-                subject.cache[element].should be_nil
+                expect(subject.cache[element]).to be_nil
                 subject.send("#{element}=", list)
-                subject.cache[element].should == list
+                expect(subject.cache[element]).to eq(list)
             end
 
             it "sets the #page association on the #{element_klass} elements" do
                 subject.send( "#{element}=", list )
-                subject.send(element).first.page.should == subject
+                expect(subject.send(element).first.page).to eq(subject)
             end
 
             it 'freezes the list' do
-                subject.send(element).should be_frozen
+                expect(subject.send(element)).to be_frozen
             end
         end
     end
 
     describe '#platforms' do
         it 'returns platforms for the given page' do
-            page.platforms.should be_kind_of Arachni::Platform::Manager
+            expect(page.platforms).to be_kind_of Arachni::Platform::Manager
         end
     end
 
@@ -459,39 +459,39 @@ describe Arachni::Page do
         context 'when the page has' do
             context '<script>' do
                 it 'returns true' do
-                    create_page(
+                    expect(create_page(
                         body:    '<Script>var i = '';</script>',
                         headers: { 'content-type' => 'text/html' }
-                    ).has_script?.should be_true
+                    ).has_script?).to be_truthy
                 end
             end
             context 'elements with event attributes' do
                 it 'returns true' do
-                    create_page(
+                    expect(create_page(
                         body:    '<a onMouseOver="doStuff();">Stuff</a>',
                         headers: { 'content-type' => 'text/html' }
-                    ).has_script?.should be_true
+                    ).has_script?).to be_truthy
                 end
             end
             context 'anchors with javacript: in href' do
                 it 'returns true' do
-                    create_page(
+                    expect(create_page(
                         body:    '<a href="JavaScript:doStuff();">Stuff</a>',
                         headers: { 'content-type' => 'text/html' }
-                    ).has_script?.should be_true
+                    ).has_script?).to be_truthy
                 end
             end
             context 'forms with javacript: in action' do
                 it 'returns true' do
-                    create_page(
+                    expect(create_page(
                         body:    '<form action="javascript:doStuff();"></form>',
                         headers: { 'content-type' => 'text/html' }
-                    ).has_script?.should be_true
+                    ).has_script?).to be_truthy
                 end
             end
             context 'no client-side code' do
                 it 'returns false' do
-                    create_page( body: 'stuff' ).has_script?.should be_false
+                    expect(create_page( body: 'stuff' ).has_script?).to be_falsey
                 end
             end
         end
@@ -500,19 +500,19 @@ describe Arachni::Page do
     describe '#has_elements?' do
         context 'when the page has any of the given elements' do
             it 'returns true' do
-                create_page(
+                expect(create_page(
                     body:    '<fOrM></form>',
                     headers: { 'content-type' => 'text/html' }
-                ).has_elements?( 'form', 'script' ).should be_true
+                ).has_elements?( 'form', 'script' )).to be_truthy
             end
         end
 
         context 'when the page has none of the given elements' do
             it 'returns false' do
-                create_page(
+                expect(create_page(
                     body:    '<fOrM></form>',
                     headers: { 'content-type' => 'text/html' }
-                ).has_elements?( 'a', 'script' ).should be_false
+                ).has_elements?( 'a', 'script' )).to be_falsey
             end
         end
     end
@@ -520,13 +520,13 @@ describe Arachni::Page do
     describe '#text?' do
         context 'when the HTTP response is text/html' do
             it 'returns true' do
-                Arachni::Parser.new( Factory[:html_response] ).page.text?.should be_true
+                expect(Arachni::Parser.new( Factory[:html_response] ).page.text?).to be_truthy
             end
         end
 
         context 'when the response is not text based' do
             it 'returns false' do
-                Arachni::Parser.new( Factory[:binary_response] ).page.text?.should be_false
+                expect(Arachni::Parser.new( Factory[:binary_response] ).page.text?).to be_falsey
             end
         end
     end
@@ -542,19 +542,19 @@ describe Arachni::Page do
 
                 c = p.dup
                 c.links |= [Arachni::Element::Link.new( url: 'http://test.com', inputs: { 'test' => 'stuff2' } )]
-                c.should_not == p
+                expect(c).not_to eq(p)
 
                 c = p.dup
                 c.forms |= [Arachni::Element::Form.new( url: 'http://test.com', inputs: { 'test' => 'stuff2' } )]
-                c.should_not == p
+                expect(c).not_to eq(p)
 
                 c = p.dup
                 c.cookies |= [Arachni::Element::Cookie.new( url: 'http://test.com', inputs: { 'test' => 'stuff2' } )]
-                c.should_not == p
+                expect(c).not_to eq(p)
 
                 c = p.dup
                 c.dom.push_transition described_class::DOM::Transition.new( "<a href='#' id='stuff'>", :onhover )
-                c.should_not == p
+                expect(c).not_to eq(p)
             end
         end
         context 'when the pages are identical' do
@@ -565,7 +565,7 @@ describe Arachni::Page do
                 p.cookies |= [Arachni::Element::Cookie.new( url: 'http://test.com', inputs: { 'test' => 'stuff' } )]
 
                 c = p.dup
-                c.should == p
+                expect(c).to eq(p)
 
                 p.links |= [Arachni::Element::Link.new( url: 'http://test.com', inputs: { 'test' => 'stuff2' } )]
                 p.forms |= [Arachni::Element::Form.new( url: 'http://test.com', inputs: { 'test' => 'stuff2' } )]
@@ -577,7 +577,7 @@ describe Arachni::Page do
                 c.cookies |= [Arachni::Element::Cookie.new( url: 'http://test.com', inputs: { 'test' => 'stuff2' } )]
                 c.dom.push_transition described_class::DOM::Transition.new( "<a href='#' id='stuff'>", :onhover )
 
-                c.should == p
+                expect(c).to eq(p)
             end
         end
     end
@@ -592,15 +592,15 @@ describe Arachni::Page do
 
                 c = p.dup
                 c.links |= [Arachni::Element::Link.new( url: 'http://test.com', inputs: { 'test' => 'stuff2' } )]
-                c.should_not eql p
+                expect(c).not_to eql p
 
                 c = p.dup
                 c.forms |= [Arachni::Element::Form.new( url: 'http://test.com', inputs: { 'test' => 'stuff2' } )]
-                c.should_not eql p
+                expect(c).not_to eql p
 
                 c = p.dup
                 c.cookies |= [Arachni::Element::Cookie.new( url: 'http://test.com', inputs: { 'test' => 'stuff2' } )]
-                c.should_not eql p
+                expect(c).not_to eql p
             end
         end
         context 'when the pages are identical' do
@@ -611,7 +611,7 @@ describe Arachni::Page do
                 p.cookies |= [Arachni::Element::Cookie.new( url: 'http://test.com', inputs: { 'test' => 'stuff' } )]
 
                 c = p.dup
-                c.should eql p
+                expect(c).to eql p
 
                 c = p.dup
                 p.links |= [Arachni::Element::Link.new( url: 'http://test.com', inputs: { 'test' => 'stuff2' } )]
@@ -621,7 +621,7 @@ describe Arachni::Page do
                 c.links |= [Arachni::Element::Link.new( url: 'http://test.com', inputs: { 'test' => 'stuff2' } )]
                 c.forms |= [Arachni::Element::Form.new( url: 'http://test.com', inputs: { 'test' => 'stuff2' } )]
                 c.cookies |= [Arachni::Element::Cookie.new( url: 'http://test.com', inputs: { 'test' => 'stuff2' } )]
-                c.should eql p
+                expect(c).to eql p
             end
         end
     end
@@ -630,21 +630,21 @@ describe Arachni::Page do
         context 'when the page has a title' do
             it 'returns the page title' do
                 title = 'Stuff here'
-                create_page( body: "<title>#{title}</title>" ).title.should == title
-                create_page( body: '<title></title>' ).title.should == ''
+                expect(create_page( body: "<title>#{title}</title>" ).title).to eq(title)
+                expect(create_page( body: '<title></title>' ).title).to eq('')
             end
         end
         context 'when the page does not have a title' do
             it 'returns nil' do
-                create_page.title.should be_nil
-                create_page( body: '' ).title.should be_nil
+                expect(create_page.title).to be_nil
+                expect(create_page( body: '' ).title).to be_nil
             end
         end
     end
 
     describe '#elements' do
         it 'returns all page elements' do
-            page.elements.should == (page.links | page.forms | page.cookies | page.headers)
+            expect(page.elements).to eq(page.links | page.forms | page.cookies | page.headers)
         end
     end
 
@@ -654,30 +654,30 @@ describe Arachni::Page do
 
             elements = page.elements
             element = elements.pop
-            element.scope.stub(:in?) { false }
+            allow(element.scope).to receive(:in?) { false }
 
-            page.elements_within_scope.should == (elements - [element])
+            expect(page.elements_within_scope).to eq(elements - [element])
         end
     end
 
     describe '#clear_cache' do
         it 'returns self' do
-            subject.clear_cache.should == subject
+            expect(subject.clear_cache).to eq(subject)
         end
 
         it 'clears the #cache' do
             cachable = [:query_vars, :links, :forms, :cookies, :headers, :paths,
                         :document, :parser]
 
-            subject.cache.keys.should be_empty
+            expect(subject.cache.keys).to be_empty
 
             cachable.each do |attribute|
                 subject.send attribute
             end
 
-            subject.cache.keys.sort.should == cachable.sort
+            expect(subject.cache.keys.sort).to eq(cachable.sort)
             subject.clear_cache
-            subject.cache.keys.should be_empty
+            expect(subject.cache.keys).to be_empty
         end
 
         [:links, :forms, :cookies, :headers].each do |type|
@@ -685,21 +685,21 @@ describe Arachni::Page do
                 it 'does not empty their cache' do
                     subject.send("#{type}=", subject.send(type))
                     subject.clear_cache
-                    subject.cache.keys.should == [type]
-                    subject.cache[type].should == subject.send(type)
+                    expect(subject.cache.keys).to eq([type])
+                    expect(subject.cache[type]).to eq(subject.send(type))
                 end
             end
         end
 
         context 'when #forms have nonces' do
             it 'preserves them' do
-                page_with_nonces.forms.map { |f| f.nonce_name }.sort.
-                    should == %w(nonce nonce2).sort
+                expect(page_with_nonces.forms.map { |f| f.nonce_name }.sort).
+                    to eq(%w(nonce nonce2).sort)
 
                 page_with_nonces.clear_cache
 
-                page_with_nonces.forms.map { |f| f.nonce_name }.sort.
-                    should == %w(nonce nonce2).sort
+                expect(page_with_nonces.forms.map { |f| f.nonce_name }.sort).
+                    to eq(%w(nonce nonce2).sort)
             end
         end
     end
@@ -708,38 +708,38 @@ describe Arachni::Page do
         it 'clears the #cache' do
             s = subject.dup
             s.prepare_for_report
-            s.cache.should be_empty
+            expect(s.cache).to be_empty
         end
 
         it 'removes #dom#digest' do
             subject.dom.digest = 'stuff'
             subject.prepare_for_report
-            subject.dom.digest.should be_nil
+            expect(subject.dom.digest).to be_nil
         end
 
         it 'removes #dom#skip_states' do
-            subject.dom.skip_states.should be_true
+            expect(subject.dom.skip_states).to be_truthy
             subject.prepare_for_report
-            subject.dom.digest.should be_nil
+            expect(subject.dom.digest).to be_nil
         end
 
         it 'returns self' do
-            subject.prepare_for_report.should == subject
+            expect(subject.prepare_for_report).to eq(subject)
         end
 
         context 'if the body is not #text?' do
             let(:page) { Factory[:binary_response].to_page }
 
             it 'clears it' do
-                page.body.should_not be_empty
+                expect(page.body).not_to be_empty
                 page.prepare_for_report
-                page.body.should be_empty
+                expect(page.body).to be_empty
             end
 
             it 'clears the #response#body' do
-                page.response.body.should_not be_empty
+                expect(page.response.body).not_to be_empty
                 page.prepare_for_report
-                page.response.body.should be_empty
+                expect(page.response.body).to be_empty
             end
         end
     end
@@ -754,8 +754,8 @@ describe Arachni::Page do
 
             subject.update_metadata
 
-            subject.metadata['form']['nonce_name'][form.coverage_hash].should == form.inputs.keys.first
-            subject.metadata['form']['skip_dom'][form.coverage_hash].should == true
+            expect(subject.metadata['form']['nonce_name'][form.coverage_hash]).to eq(form.inputs.keys.first)
+            expect(subject.metadata['form']['skip_dom'][form.coverage_hash]).to eq(true)
         end
     end
 
@@ -776,8 +776,8 @@ describe Arachni::Page do
 
             subject.reload_metadata
 
-            form.nonce_name.should == form.inputs.keys.first
-            form.skip_dom.should == true
+            expect(form.nonce_name).to eq(form.inputs.keys.first)
+            expect(form.skip_dom).to eq(true)
         end
     end
 
@@ -796,7 +796,7 @@ describe Arachni::Page do
 
             subject.import_metadata( dpage )
 
-            subject.metadata.should == dpage.metadata
+            expect(subject.metadata).to eq(dpage.metadata)
         end
 
         context 'when a type is given' do
@@ -814,24 +814,24 @@ describe Arachni::Page do
 
                 subject.import_metadata( dpage, :skip_dom )
 
-                subject.metadata['form']['nonce_name'].should be_nil
-                subject.metadata['form']['skip_dom'][form.coverage_hash].should == true
+                expect(subject.metadata['form']['nonce_name']).to be_nil
+                expect(subject.metadata['form']['skip_dom'][form.coverage_hash]).to eq(true)
             end
         end
     end
 
     describe '#to_h' do
         it 'converts the page to a hash' do
-            subject.to_h.should be_kind_of Hash
+            expect(subject.to_h).to be_kind_of Hash
 
             subject.to_h.each do |k, v|
-                v.should == subject.send(k)
+                expect(v).to eq(subject.send(k))
             end
         end
 
         [:document, :do_not_audit_elements, :has_custom_elements, :parser].each do |k|
             it "does not include ':#{k}'" do
-                subject.to_h.should_not include k
+                expect(subject.to_h).not_to include k
             end
         end
     end
@@ -840,7 +840,7 @@ describe Arachni::Page do
         describe "##{method}" do
             it 'returns a copy of the page' do
                 dupped = subject.send(method)
-                dupped.should == subject
+                expect(dupped).to eq(subject)
             end
 
             [:response, :metadata, :body, :links, :forms, :cookies, :headers, :cookie_jar, :paths].each do |m|
@@ -848,49 +848,49 @@ describe Arachni::Page do
                     dupped = subject.send(method)
 
                     # Make sure we're not comparing nils.
-                    subject.send( m ).should be_true
+                    expect(subject.send( m )).to be_truthy
 
                     # Make sure we're not comparing empty stuff.
                     if (enumerable = dupped.send( m )).is_a? Enumerable
-                        enumerable.should be_any
+                        expect(enumerable).to be_any
                     end
 
-                    dupped.send( m ).should == subject.send( m )
+                    expect(dupped.send( m )).to eq(subject.send( m ))
                 end
             end
 
             it 'preserves #element_audit_whitelist' do
                 subject.update_element_audit_whitelist subject.elements.first
                 dupped = subject.send(method)
-                dupped.element_audit_whitelist.should include subject.elements.first.coverage_hash
+                expect(dupped.element_audit_whitelist).to include subject.elements.first.coverage_hash
             end
 
             it 'preserves Arachni::Element::Form#node of #forms' do
                 form = subject.forms.last
-                form.node.should be_kind_of Nokogiri::XML::Element
-                form.node.should be_true
+                expect(form.node).to be_kind_of Nokogiri::XML::Element
+                expect(form.node).to be_truthy
 
-                subject.send(method).forms.last.node.to_s.should == form.node.to_s
+                expect(subject.send(method).forms.last.node.to_s).to eq(form.node.to_s)
             end
 
             it 'preserves Arachni::Element::Link#node of #links' do
                 link = subject.links.last
-                link.node.should be_kind_of Nokogiri::XML::Element
-                link.node.should be_true
+                expect(link.node).to be_kind_of Nokogiri::XML::Element
+                expect(link.node).to be_truthy
 
-                subject.send(method).links.last.node.to_s.should == link.node.to_s
+                expect(subject.send(method).links.last.node.to_s).to eq(link.node.to_s)
             end
 
             it 'preserves #page associations for #elements' do
                 dup = subject.send(method)
-                dup.elements.should be_any
-                dup.elements.each { |e| e.page.should == subject }
+                expect(dup.elements).to be_any
+                dup.elements.each { |e| expect(e.page).to eq(subject) }
             end
 
             context 'when #forms have nonces' do
                 it 'preserves them' do
-                    page_with_nonces.forms.map { |f| f.nonce_name }.sort.should == %w(nonce nonce2).sort
-                    page_with_nonces.send(method).forms.map { |f| f.nonce_name }.sort.should == %w(nonce nonce2).sort
+                    expect(page_with_nonces.forms.map { |f| f.nonce_name }.sort).to eq(%w(nonce nonce2).sort)
+                    expect(page_with_nonces.send(method).forms.map { |f| f.nonce_name }.sort).to eq(%w(nonce nonce2).sort)
                 end
             end
 
@@ -900,14 +900,14 @@ describe Arachni::Page do
                         dupped = subject.send(method)
 
                         # Make sure we're not comparing nils.
-                        subject.dom.send( m ).should be_true
+                        expect(subject.dom.send( m )).to be_truthy
 
                         # Make sure we're not comparing empty stuff.
                         if (enumerable = dupped.dom.send( m )).is_a? Enumerable
-                            enumerable.should be_any
+                            expect(enumerable).to be_any
                         end
 
-                        dupped.dom.send( m ).should == subject.dom.send( m )
+                        expect(dupped.dom.send( m )).to eq(subject.dom.send( m ))
                     end
                 end
             end
@@ -917,13 +917,13 @@ describe Arachni::Page do
 
     describe '.from_url' do
         it 'returns a page from the given url' do
-            described_class.from_url( url + 'with_nonce' ).should be_kind_of described_class
+            expect(described_class.from_url( url + 'with_nonce' )).to be_kind_of described_class
         end
 
         context 'when #forms have nonces' do
             it 'preserves them' do
-                described_class.from_url( url + 'with_nonce' ).forms.
-                    map { |f| f.nonce_name }.sort.should == %w(nonce nonce2).sort
+                expect(described_class.from_url( url + 'with_nonce' ).forms.
+                    map { |f| f.nonce_name }.sort).to eq(%w(nonce nonce2).sort)
             end
         end
     end
@@ -958,25 +958,25 @@ describe Arachni::Page do
             }
 
             page = Arachni::Page.from_data( data )
-            page.code.should == data[:response][:code]
-            page.url.should == data[:url]
-            page.body.should == data[:body]
-            page.paths.should == data[:paths]
+            expect(page.code).to eq(data[:response][:code])
+            expect(page.url).to eq(data[:url])
+            expect(page.body).to eq(data[:body])
+            expect(page.paths).to eq(data[:paths])
 
-            page.links.should == data[:links]
-            page.forms.should == data[:forms]
-            page.cookies.should == data[:cookies]
-            page.headers.should == data[:headers]
+            expect(page.links).to eq(data[:links])
+            expect(page.forms).to eq(data[:forms])
+            expect(page.cookies).to eq(data[:cookies])
+            expect(page.headers).to eq(data[:headers])
 
-            page.cookie_jar.should == data[:cookie_jar]
+            expect(page.cookie_jar).to eq(data[:cookie_jar])
 
-            page.response.code.should == data[:response][:code]
-            page.response.url.should == data[:url]
-            page.response.body.should == data[:body]
-            page.response.request.url.should == data[:url]
+            expect(page.response.code).to eq(data[:response][:code])
+            expect(page.response.url).to eq(data[:url])
+            expect(page.response.body).to eq(data[:body])
+            expect(page.response.request.url).to eq(data[:url])
 
-            page.dom.url.should == data[:dom][:url]
-            page.dom.transitions.should == data[:dom][:transitions]
+            expect(page.dom.url).to eq(data[:dom][:url])
+            expect(page.dom.transitions).to eq(data[:dom][:transitions])
         end
 
         context 'when no HTTP data is given' do
@@ -987,21 +987,21 @@ describe Arachni::Page do
                 }
 
                 page = Arachni::Page.from_data( data )
-                page.url.should == data[:url]
-                page.body.should == data[:body]
-                page.code.should == 200
+                expect(page.url).to eq(data[:url])
+                expect(page.body).to eq(data[:body])
+                expect(page.code).to eq(200)
 
-                page.links.should == []
-                page.forms.should == []
-                page.cookies.should == []
-                page.headers.should == []
+                expect(page.links).to eq([])
+                expect(page.forms).to eq([])
+                expect(page.cookies).to eq([])
+                expect(page.headers).to eq([])
 
-                page.cookie_jar.should == []
+                expect(page.cookie_jar).to eq([])
 
-                page.response.code.should == 200
-                page.response.url.should == data[:url]
-                page.response.body.should == data[:body]
-                page.response.request.url.should == data[:url]
+                expect(page.response.code).to eq(200)
+                expect(page.response.url).to eq(data[:url])
+                expect(page.response.body).to eq(data[:body])
+                expect(page.response.request.url).to eq(data[:url])
             end
         end
     end
@@ -1009,21 +1009,21 @@ describe Arachni::Page do
     describe '.from_response' do
         it 'creates a page from an HTTP response' do
             page = Arachni::Page.from_response( response )
-            page.class.should == Arachni::Page
+            expect(page.class).to eq(Arachni::Page)
             parser = Arachni::Parser.new( response )
 
-            page.url.should == parser.url
-            page.method.should == parser.response.request.method
-            page.response.should == parser.response
-            page.body.should == parser.response.body
-            page.query_vars.should == parser.link_vars
-            page.paths.should == parser.paths
-            page.links.should == parser.links
-            page.forms.should == parser.forms
-            page.cookies.should == parser.cookies_to_be_audited
-            page.headers.should == parser.headers
-            page.cookie_jar.should == parser.cookie_jar
-            page.text?.should == parser.text?
+            expect(page.url).to eq(parser.url)
+            expect(page.method).to eq(parser.response.request.method)
+            expect(page.response).to eq(parser.response)
+            expect(page.body).to eq(parser.response.body)
+            expect(page.query_vars).to eq(parser.link_vars)
+            expect(page.paths).to eq(parser.paths)
+            expect(page.links).to eq(parser.links)
+            expect(page.forms).to eq(parser.forms)
+            expect(page.cookies).to eq(parser.cookies_to_be_audited)
+            expect(page.headers).to eq(parser.headers)
+            expect(page.cookie_jar).to eq(parser.cookie_jar)
+            expect(page.text?).to eq(parser.text?)
 
         end
     end