arachni 1.2.1 → 1.3

data/spec/arachni/browser/javascript/taint_tracer/frame/called_function_spec.rb

@@ -5,12 +5,12 @@ describe Arachni::Browser::Javascript::TaintTracer::Frame::CalledFunction do
     subject { Factory[:called_function] }
 
     %w(source name arguments).each do |m|
-        it { should respond_to m }
-        it { should respond_to "#{m}=" }
+        it { is_expected.to respond_to m }
+        it { is_expected.to respond_to "#{m}=" }
     end
 
     it "supports #{Arachni::RPC::Serializer}" do
-        subject.should == Arachni::RPC::Serializer.deep_clone( subject )
+        expect(subject).to eq(Arachni::RPC::Serializer.deep_clone( subject ))
     end
 
     describe '#to_rpc_data' do
@@ -18,7 +18,7 @@ describe Arachni::Browser::Javascript::TaintTracer::Frame::CalledFunction do
 
         %w(source name arguments).each do |attribute|
             it "includes '#{attribute}'" do
-                data[attribute.to_sym].should == subject.send( attribute )
+                expect(data[attribute.to_sym]).to eq(subject.send( attribute ))
             end
         end
     end
@@ -29,7 +29,7 @@ describe Arachni::Browser::Javascript::TaintTracer::Frame::CalledFunction do
 
         %w(source name arguments).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
     end
@@ -37,14 +37,14 @@ describe Arachni::Browser::Javascript::TaintTracer::Frame::CalledFunction do
     describe '#signature' do
         context 'when #source is available' do
             it 'returns the function signature' do
-                subject.signature.should == 'stuff(blah, blooh)'
+                expect(subject.signature).to eq('stuff(blah, blooh)')
             end
         end
 
         context 'when #source is not available' do
             it 'returns nil' do
                 subject.source = nil
-                subject.signature.should be_nil
+                expect(subject.signature).to be_nil
             end
         end
     end
@@ -52,21 +52,21 @@ describe Arachni::Browser::Javascript::TaintTracer::Frame::CalledFunction do
     describe '#signature_arguments' do
         context 'when #signature is available' do
             it 'returns the function arguments' do
-                subject.signature_arguments.should == %w(blah blooh)
+                expect(subject.signature_arguments).to eq(%w(blah blooh))
             end
         end
 
         context 'when #source is not available' do
             it 'returns nil' do
-                subject.stub(:signature){ nil }
-                subject.signature_arguments.should be_nil
+                allow(subject).to receive(:signature){ nil }
+                expect(subject.signature_arguments).to be_nil
             end
         end
     end
 
     describe '#to_h' do
         it 'converts self to a hash' do
-            subject.to_h.should == Factory[:called_function_data]
+            expect(subject.to_h).to eq(Factory[:called_function_data])
         end
     end
 end

data/spec/arachni/browser/javascript/taint_tracer/frame_spec.rb

@@ -5,12 +5,12 @@ describe Arachni::Browser::Javascript::TaintTracer::Frame do
     subject { Factory[:frame] }
 
     %w(function url line).each do |m|
-        it { should respond_to m }
-        it { should respond_to "#{m}=" }
+        it { is_expected.to respond_to m }
+        it { is_expected.to respond_to "#{m}=" }
     end
 
     it "supports #{Arachni::RPC::Serializer}" do
-        subject.should == Arachni::RPC::Serializer.deep_clone( subject )
+        expect(subject).to eq(Arachni::RPC::Serializer.deep_clone( subject ))
     end
 
     describe '#to_rpc_data' do
@@ -18,7 +18,7 @@ describe Arachni::Browser::Javascript::TaintTracer::Frame do
 
         %w(function url line).each do |attribute|
             it "includes '#{attribute}'" do
-                data[attribute.to_sym].should == subject.send( attribute )
+                expect(data[attribute.to_sym]).to eq(subject.send( attribute ))
             end
         end
     end
@@ -29,18 +29,18 @@ describe Arachni::Browser::Javascript::TaintTracer::Frame do
 
         %w(function url line).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
     end
 
     describe '#to_h' do
         it 'returns a hash containing frame data' do
-            subject.to_h.should == Factory[:frame_data]
+            expect(subject.to_h).to eq(Factory[:frame_data])
         end
 
         it 'is aliased to #to_hash' do
-            subject.to_h.should == subject.to_hash
+            expect(subject.to_h).to eq(subject.to_hash)
         end
     end
 end

data/spec/arachni/browser/javascript/taint_tracer/sink/data_flow_spec.rb

@@ -6,12 +6,12 @@ describe Arachni::Browser::Javascript::TaintTracer::Sink::DataFlow do
     subject { Factory[:data_flow] }
 
     %w(function object tainted_argument_index tainted_value taint).each do |m|
-        it { should respond_to m }
-        it { should respond_to "#{m}=" }
+        it { is_expected.to respond_to m }
+        it { is_expected.to respond_to "#{m}=" }
     end
 
     it "supports #{Arachni::RPC::Serializer}" do
-        subject.should == Arachni::RPC::Serializer.deep_clone( subject )
+        expect(subject).to eq(Arachni::RPC::Serializer.deep_clone( subject ))
     end
 
     describe '#to_rpc_data' do
@@ -19,7 +19,7 @@ describe Arachni::Browser::Javascript::TaintTracer::Sink::DataFlow do
 
         %w(function object tainted_argument_index tainted_value taint).each do |attribute|
             it "includes '#{attribute}'" do
-                data[attribute.to_sym].should == subject.send( attribute )
+                expect(data[attribute.to_sym]).to eq(subject.send( attribute ))
             end
         end
     end
@@ -30,7 +30,7 @@ describe Arachni::Browser::Javascript::TaintTracer::Sink::DataFlow do
 
         %w(function object tainted_argument_index tainted_value taint).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
     end
@@ -38,14 +38,14 @@ describe Arachni::Browser::Javascript::TaintTracer::Sink::DataFlow do
     describe '#tainted_argument_value' do
         context 'when there are #arguments' do
             it 'returns the tainted argument' do
-                subject.tainted_argument_value.should == 'blah-val'
+                expect(subject.tainted_argument_value).to eq('blah-val')
             end
         end
 
         context 'when there are no #arguments' do
             it 'returns nil' do
                 subject.function.arguments = nil
-                subject.tainted_argument_value.should be_nil
+                expect(subject.tainted_argument_value).to be_nil
             end
         end
     end
@@ -53,29 +53,29 @@ describe Arachni::Browser::Javascript::TaintTracer::Sink::DataFlow do
     describe '#tainted_argument_name' do
         context 'when there are #arguments' do
             it 'returns the tainted argument' do
-                subject.tainted_argument_name.should == 'blah'
+                expect(subject.tainted_argument_name).to eq('blah')
             end
         end
 
         context "when there are are no #{Arachni::Browser::Javascript::TaintTracer::Frame::CalledFunction}#signature_arguments" do
             it 'returns nil' do
-                subject.function.stub(:signature_arguments){ nil }
-                subject.tainted_argument_name.should be_nil
+                allow(subject.function).to receive(:signature_arguments){ nil }
+                expect(subject.tainted_argument_name).to be_nil
             end
         end
     end
 
     describe '#to_h' do
         it 'returns a hash containing frame data' do
-            subject.to_h.should == Factory[:data_flow]
+            expect(subject.to_h).to eq(Factory[:data_flow])
         end
 
         it 'converts #function to hash' do
-            subject.to_h[:function].should == Factory[:called_function_data]
+            expect(subject.to_h[:function]).to eq(Factory[:called_function_data])
         end
 
         it 'is aliased to #to_hash' do
-            subject.to_h.should == subject.to_hash
+            expect(subject.to_h).to eq(subject.to_hash)
         end
     end
 end

data/spec/arachni/browser/javascript/taint_tracer/sink/execution_flow_spec.rb

@@ -6,12 +6,12 @@ describe Arachni::Browser::Javascript::TaintTracer::Sink::ExecutionFlow do
     subject { Factory[:execution_flow] }
 
     %w(data).each do |m|
-        it { should respond_to m }
-        it { should respond_to "#{m}=" }
+        it { is_expected.to respond_to m }
+        it { is_expected.to respond_to "#{m}=" }
     end
 
     it "supports #{Arachni::RPC::Serializer}" do
-        subject.should == Arachni::RPC::Serializer.deep_clone( subject )
+        expect(subject).to eq(Arachni::RPC::Serializer.deep_clone( subject ))
     end
 
     describe '#to_rpc_data' do
@@ -19,7 +19,7 @@ describe Arachni::Browser::Javascript::TaintTracer::Sink::ExecutionFlow do
 
         %w(data).each do |attribute|
             it "includes '#{attribute}'" do
-                data[attribute.to_sym].should == subject.send( attribute )
+                expect(data[attribute.to_sym]).to eq(subject.send( attribute ))
             end
         end
     end
@@ -30,18 +30,18 @@ describe Arachni::Browser::Javascript::TaintTracer::Sink::ExecutionFlow do
 
         %w(data).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
     end
 
     describe '#to_h' do
         it 'returns a hash containing frame data' do
-            subject.to_h.should == Factory[:execution_flow]
+            expect(subject.to_h).to eq(Factory[:execution_flow])
         end
 
         it 'is aliased to #to_hash' do
-            subject.to_h.should == subject.to_hash
+            expect(subject.to_h).to eq(subject.to_hash)
         end
     end
 end

data/spec/arachni/browser/javascript/taint_tracer_spec.rb

@@ -30,32 +30,32 @@ describe Arachni::Browser::Javascript::TaintTracer do
 
     describe '#initialized' do
         it 'returns true' do
-            subject.initialized.should be_true
+            expect(subject.initialized).to be_truthy
         end
     end
 
     describe '#class' do
         it "returns #{described_class}" do
-            subject.class.should == described_class
+            expect(subject.class).to eq(described_class)
         end
     end
 
     it 'is aliased to _token_taint_tracer' do
         load "debug?input=_#{@javascript.token}_taint_tracer.log_execution_flow_sink()"
         @browser.watir.form.submit
-        subject.execution_flow_sinks.should be_any
+        expect(subject.execution_flow_sinks).to be_any
     end
 
     it 'is aliased to _tokentainttracer' do
         load "debug?input=_#{@javascript.token}tainttracer.log_execution_flow_sink()"
         @browser.watir.form.submit
-        subject.execution_flow_sinks.should be_any
+        expect(subject.execution_flow_sinks).to be_any
     end
 
     describe '#taints=' do
         it 'sets the taints to be traced' do
             subject.taints = [taint]
-            subject.taints.should == [taint]
+            expect(subject.taints).to eq([taint])
         end
 
         context 'when multiple taints are set' do
@@ -68,92 +68,100 @@ describe Arachni::Browser::Javascript::TaintTracer do
                 load "/data_trace/multiple-taints?taint1=#{taint1}&taint2=#{taint2}"
 
                 sink = subject.data_flow_sinks[taint1]
-                sink.size.should == 2
+                expect(sink.size).to eq(2)
 
                 entry = sink[0]
-                entry.object.should == 'DOMWindow'
-                entry.function.name.should == 'process'
-                entry.function.source.should start_with 'function process'
-                entry.function.arguments.should == [
+                expect(entry.object).to eq('DOMWindow')
+                expect(entry.function.name).to eq('process')
+                expect(entry.function.source).to start_with 'function process'
+                expect(entry.function.arguments).to eq([
                     {
                         'my_data11' => 'blah11',
                         'input11'   => taint1
                     }
-                ]
-                entry.tainted_value.should == taint1
-                entry.taint.should == taint1
-                @browser.source.split("\n")[entry.trace[0].line-1].should include 'process('
+                ])
+                expect(entry.tainted_value).to eq(taint1)
+                expect(entry.taint).to eq(taint1)
+                expect(@browser.source.split("\n")[entry.trace[0].line-1]).to include 'process('
 
                 entry = sink[1]
-                entry.object.should == 'DOMWindow'
-                entry.function.name.should == 'process'
-                entry.function.source.should start_with 'function process'
-                entry.function.arguments.should == [
+                expect(entry.object).to eq('DOMWindow')
+                expect(entry.function.name).to eq('process')
+                expect(entry.function.source).to start_with 'function process'
+                expect(entry.function.arguments).to eq([
                     {
                         'my_data12' => 'blah12',
                         'input12'   => taint1
                     }
-                ]
-                entry.tainted_value.should == taint1
-                entry.taint.should == taint1
-                @browser.source.split("\n")[entry.trace[0].line-1].should include 'process('
+                ])
+                expect(entry.tainted_value).to eq(taint1)
+                expect(entry.taint).to eq(taint1)
+                expect(@browser.source.split("\n")[entry.trace[0].line-1]).to include 'process('
 
                 sink = subject.data_flow_sinks[taint2]
-                sink.size.should == 2
+                expect(sink.size).to eq(2)
 
                 entry = sink[0]
-                entry.object.should == 'DOMWindow'
-                entry.function.name.should == 'process'
-                entry.function.source.should start_with 'function process'
-                entry.function.arguments.should == [
+                expect(entry.object).to eq('DOMWindow')
+                expect(entry.function.name).to eq('process')
+                expect(entry.function.source).to start_with 'function process'
+                expect(entry.function.arguments).to eq([
                     {
                         'my_data21' => 'blah21',
                         'input21'   => taint2
                     }
-                ]
-                entry.tainted_value.should == taint2
-                entry.taint.should == taint2
-                @browser.source.split("\n")[entry.trace[0].line].should include 'process('
+                ])
+                expect(entry.tainted_value).to eq(taint2)
+                expect(entry.taint).to eq(taint2)
+                expect(@browser.source.split("\n")[entry.trace[0].line]).to include 'process('
 
                 entry = sink[1]
-                entry.object.should == 'DOMWindow'
-                entry.function.name.should == 'process'
-                entry.function.source.should start_with 'function process'
-                entry.function.arguments.should == [
+                expect(entry.object).to eq('DOMWindow')
+                expect(entry.function.name).to eq('process')
+                expect(entry.function.source).to start_with 'function process'
+                expect(entry.function.arguments).to eq([
                     {
                         'my_data22' => 'blah22',
                         'input22'   => taint2
                     }
-                ]
-                entry.tainted_value.should == taint2
-                entry.taint.should == taint2
-                @browser.source.split("\n")[entry.trace[0].line].should include 'process('
+                ])
+                expect(entry.tainted_value).to eq(taint2)
+                expect(entry.taint).to eq(taint2)
+                expect(@browser.source.split("\n")[entry.trace[0].line]).to include 'process('
             end
         end
 
         context 'when tainted data pass through' do
             before { @javascript.taint = taint }
 
+            it 'traces the taint up to a depth of 5' do
+                load_with_taint 'data_trace/taint_depth/4'
+                expect(subject.data_flow_sinks).to be_any
+
+                load_with_taint 'data_trace/taint_depth/5'
+                expect(subject.data_flow_sinks).to be_empty
+            end
+
             context 'user-defined global functions' do
                 it 'logs it' do
                     load_with_taint 'data_trace/user-defined-global-functions'
 
                     sink = subject.data_flow_sinks[taint]
-                    sink.size.should == 1
+                    expect(sink.size).to eq(1)
 
                     entry = sink[0]
-                    entry.object.should == 'DOMWindow'
-                    entry.function.name.should == 'process'
-                    entry.function.source.should start_with 'function process'
-                    entry.function.arguments.should == [
+                    expect(entry.object).to eq('DOMWindow')
+                    expect(entry.function.name).to eq('process')
+                    expect(entry.function.source).to start_with 'function process'
+                    expect(entry.function.arguments).to eq([
                         {
                             'my_data' => 'blah',
                             'input'   => taint
                         }
-                    ]
-                    entry.tainted_value.should == taint
-                    entry.taint.should == taint
-                    @browser.source.split("\n")[entry.trace[0].line-1].should include 'process('
+                    ])
+                    expect(entry.tainted_value).to eq(taint)
+                    expect(entry.taint).to eq(taint)
+                    expect(@browser.source.split("\n")[entry.trace[0].line-1]).to include 'process('
                 end
             end
 
@@ -164,16 +172,16 @@ describe Arachni::Browser::Javascript::TaintTracer do
                             load_with_taint "data_trace/window.#{function}"
 
                             sink = subject.data_flow_sinks[taint]
-                            sink.size.should == 1
+                            expect(sink.size).to eq(1)
 
                             entry = sink[0]
-                            entry.object.should == 'DOMWindow'
-                            entry.function.name.should == function
-                            entry.function.source.should start_with "function #{function}"
-                            entry.function.arguments.should == [ taint ]
-                            entry.tainted_value.should == taint
-                            entry.taint.should == taint
-                            @browser.source.split("\n")[entry.trace[0].line].should include "#{function}("
+                            expect(entry.object).to eq('DOMWindow')
+                            expect(entry.function.name).to eq(function)
+                            expect(entry.function.source).to start_with "function #{function}"
+                            expect(entry.function.arguments).to eq([ taint ])
+                            expect(entry.tainted_value).to eq(taint)
+                            expect(entry.taint).to eq(taint)
+                            expect(@browser.source.split("\n")[entry.trace[0].line]).to include "#{function}("
                         end
                     end
                 end
@@ -185,20 +193,20 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/XMLHttpRequest.open'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 1
+                        expect(sink.size).to eq(1)
 
                         entry = sink[0]
-                        entry.object.should == 'XMLHttpRequestPrototype'
-                        entry.function.name.should == 'open'
-                        entry.function.arguments.should == [
+                        expect(entry.object).to eq('XMLHttpRequestPrototype')
+                        expect(entry.function.name).to eq('open')
+                        expect(entry.function.arguments).to eq([
                             'GET', "/?taint=#{taint}", true
-                        ]
-                        entry.tainted_value.should == "/?taint=#{taint}"
-                        entry.taint.should == taint
+                        ])
+                        expect(entry.tainted_value).to eq("/?taint=#{taint}")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'open('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'open('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
 
@@ -207,18 +215,18 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/XMLHttpRequest.send'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 1
+                        expect(sink.size).to eq(1)
 
                         entry = sink[0]
-                        entry.object.should == 'XMLHttpRequestPrototype'
-                        entry.function.name.should == 'send'
-                        entry.function.arguments.should == [ "taint=#{taint}" ]
-                        entry.tainted_value.should == "taint=#{taint}"
-                        entry.taint.should == taint
+                        expect(entry.object).to eq('XMLHttpRequestPrototype')
+                        expect(entry.function.name).to eq('send')
+                        expect(entry.function.arguments).to eq([ "taint=#{taint}" ])
+                        expect(entry.tainted_value).to eq("taint=#{taint}")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'send('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'send('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
 
@@ -227,18 +235,18 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/XMLHttpRequest.setRequestHeader'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 1
+                        expect(sink.size).to eq(1)
 
                         entry = sink[0]
-                        entry.object.should == 'XMLHttpRequestPrototype'
-                        entry.function.name.should == 'setRequestHeader'
-                        entry.function.arguments.should == [ 'X-My-Header', "stuff-#{taint}" ]
-                        entry.tainted_value.should == "stuff-#{taint}"
-                        entry.taint.should == taint
+                        expect(entry.object).to eq('XMLHttpRequestPrototype')
+                        expect(entry.function.name).to eq('setRequestHeader')
+                        expect(entry.function.arguments).to eq([ 'X-My-Header', "stuff-#{taint}" ])
+                        expect(entry.tainted_value).to eq("stuff-#{taint}")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'setRequestHeader('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'setRequestHeader('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
             end
@@ -249,18 +257,18 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/AngularJS.element'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 2
+                        expect(sink.size).to eq(2)
 
                         entry = sink[1]
-                        entry.object.should == 'angular'
-                        entry.function.name.should == 'JQLite'
-                        entry.function.arguments.should == ["<div>Stuff #{taint}</div>"]
-                        entry.tainted_value.should == "<div>Stuff #{taint}</div>"
-                        entry.taint.should == taint
+                        expect(entry.object).to eq('angular')
+                        expect(entry.function.name).to eq('JQLite')
+                        expect(entry.function.arguments).to eq(["<div>Stuff #{taint}</div>"])
+                        expect(entry.tainted_value).to eq("<div>Stuff #{taint}</div>")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'angular.element('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'angular.element('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
 
@@ -270,25 +278,25 @@ describe Arachni::Browser::Javascript::TaintTracer do
                             load_with_taint 'data_trace/AngularJS/$http.delete'
 
                             sink = subject.data_flow_sinks[taint]
-                            sink.size.should == 4
+                            expect(sink.size).to eq(4)
 
                             entry = sink[1]
-                            entry.object.should == 'angular.$http'
-                            entry.function.name.should == 'delete'
-                            entry.function.arguments.should == [ "/#{taint}" ]
-                            entry.tainted_value.should == "/#{taint}"
-                            entry.taint.should == taint
-                            entry.trace[0].url.should == @browser.url
+                            expect(entry.object).to eq('angular.$http')
+                            expect(entry.function.name).to eq('delete')
+                            expect(entry.function.arguments).to eq([ "/#{taint}" ])
+                            expect(entry.tainted_value).to eq("/#{taint}")
+                            expect(entry.taint).to eq(taint)
+                            expect(entry.trace[0].url).to eq(@browser.url)
 
                             entry = sink[3]
-                            entry.object.should == 'XMLHttpRequestPrototype'
-                            entry.function.name.should == 'open'
-                            entry.function.arguments.should == [
+                            expect(entry.object).to eq('XMLHttpRequestPrototype')
+                            expect(entry.function.name).to eq('open')
+                            expect(entry.function.arguments).to eq([
                                 'DELETE', "/#{taint}", true
-                            ]
-                            entry.tainted_value.should == "/#{taint}"
-                            entry.taint.should == taint
-                            entry.trace[0].url.should == "#{@url}angular.js"
+                            ])
+                            expect(entry.tainted_value).to eq("/#{taint}")
+                            expect(entry.taint).to eq(taint)
+                            expect(entry.trace[0].url).to eq("#{@url}angular.js")
                         end
                     end
 
@@ -297,25 +305,25 @@ describe Arachni::Browser::Javascript::TaintTracer do
                             load_with_taint 'data_trace/AngularJS/$http.head'
 
                             sink = subject.data_flow_sinks[taint]
-                            sink.size.should == 4
+                            expect(sink.size).to eq(4)
 
                             entry = sink[1]
-                            entry.object.should == 'angular.$http'
-                            entry.function.name.should == 'head'
-                            entry.function.arguments.should == [ "/#{taint}" ]
-                            entry.tainted_value.should == "/#{taint}"
-                            entry.taint.should == taint
-                            entry.trace[0].url.should == @browser.url
+                            expect(entry.object).to eq('angular.$http')
+                            expect(entry.function.name).to eq('head')
+                            expect(entry.function.arguments).to eq([ "/#{taint}" ])
+                            expect(entry.tainted_value).to eq("/#{taint}")
+                            expect(entry.taint).to eq(taint)
+                            expect(entry.trace[0].url).to eq(@browser.url)
 
                             entry = sink[3]
-                            entry.object.should == 'XMLHttpRequestPrototype'
-                            entry.function.name.should == 'open'
-                            entry.function.arguments.should == [
+                            expect(entry.object).to eq('XMLHttpRequestPrototype')
+                            expect(entry.function.name).to eq('open')
+                            expect(entry.function.arguments).to eq([
                                 'HEAD', "/#{taint}", true
-                            ]
-                            entry.tainted_value.should == "/#{taint}"
-                            entry.taint.should == taint
-                            entry.trace[0].url.should == "#{@url}angular.js"
+                            ])
+                            expect(entry.tainted_value).to eq("/#{taint}")
+                            expect(entry.taint).to eq(taint)
+                            expect(entry.trace[0].url).to eq("#{@url}angular.js")
                         end
                     end
 
@@ -324,25 +332,25 @@ describe Arachni::Browser::Javascript::TaintTracer do
                             load_with_taint 'data_trace/AngularJS/$http.jsonp'
 
                             sink = subject.data_flow_sinks[taint]
-                            sink.size.should == 3
+                            expect(sink.size).to eq(3)
 
                             entry = sink[1]
-                            entry.object.should == 'angular.$http'
-                            entry.function.name.should == 'jsonp'
-                            entry.function.arguments.should == [ "/jsonp-#{taint}" ]
-                            entry.tainted_value.should == "/jsonp-#{taint}"
-                            entry.taint.should == taint
-                            entry.trace[0].url.should == @browser.url
+                            expect(entry.object).to eq('angular.$http')
+                            expect(entry.function.name).to eq('jsonp')
+                            expect(entry.function.arguments).to eq([ "/jsonp-#{taint}" ])
+                            expect(entry.tainted_value).to eq("/jsonp-#{taint}")
+                            expect(entry.taint).to eq(taint)
+                            expect(entry.trace[0].url).to eq(@browser.url)
 
                             entry = sink[2]
-                            entry.object.should == 'ElementPrototype'
-                            entry.function.name.should == 'setAttribute'
-                            entry.function.arguments.should == [
+                            expect(entry.object).to eq('ElementPrototype')
+                            expect(entry.function.name).to eq('setAttribute')
+                            expect(entry.function.arguments).to eq([
                                 'href', "/jsonp-#{taint}"
-                            ]
-                            entry.tainted_value.should == "/jsonp-#{taint}"
-                            entry.taint.should == taint
-                            entry.trace[0].url.should == "#{@url}angular.js"
+                            ])
+                            expect(entry.tainted_value).to eq("/jsonp-#{taint}")
+                            expect(entry.taint).to eq(taint)
+                            expect(entry.trace[0].url).to eq("#{@url}angular.js")
                         end
                     end
 
@@ -351,25 +359,25 @@ describe Arachni::Browser::Javascript::TaintTracer do
                             load_with_taint 'data_trace/AngularJS/$http.put'
 
                             sink = subject.data_flow_sinks[taint]
-                            sink.size.should == 3
+                            expect(sink.size).to eq(3)
 
                             entry = sink[1]
-                            entry.object.should == 'angular.$http'
-                            entry.function.name.should == 'put'
-                            entry.function.arguments.should == [
+                            expect(entry.object).to eq('angular.$http')
+                            expect(entry.function.name).to eq('put')
+                            expect(entry.function.arguments).to eq([
                                 '/', "Stuff #{taint}"
-                            ]
-                            entry.tainted_value.should == "Stuff #{taint}"
-                            entry.taint.should == taint
-                            entry.trace[0].url.should == @browser.url
+                            ])
+                            expect(entry.tainted_value).to eq("Stuff #{taint}")
+                            expect(entry.taint).to eq(taint)
+                            expect(entry.trace[0].url).to eq(@browser.url)
 
                             entry = sink[2]
-                            entry.object.should == 'XMLHttpRequestPrototype'
-                            entry.function.name.should == 'send'
-                            entry.function.arguments.should == [ "Stuff #{taint}" ]
-                            entry.tainted_value.should == "Stuff #{taint}"
-                            entry.taint.should == taint
-                            entry.trace[0].url.should == "#{@url}angular.js"
+                            expect(entry.object).to eq('XMLHttpRequestPrototype')
+                            expect(entry.function.name).to eq('send')
+                            expect(entry.function.arguments).to eq([ "Stuff #{taint}" ])
+                            expect(entry.tainted_value).to eq("Stuff #{taint}")
+                            expect(entry.taint).to eq(taint)
+                            expect(entry.trace[0].url).to eq("#{@url}angular.js")
                         end
                     end
 
@@ -378,25 +386,25 @@ describe Arachni::Browser::Javascript::TaintTracer do
                             load_with_taint 'data_trace/AngularJS/$http.get'
 
                             sink = subject.data_flow_sinks[taint]
-                            sink.size.should == 4
+                            expect(sink.size).to eq(4)
 
                             entry = sink[1]
-                            entry.object.should == 'angular.$http'
-                            entry.function.name.should == 'get'
-                            entry.function.arguments.should == [ "/#{taint}" ]
-                            entry.tainted_value.should == "/#{taint}"
-                            entry.taint.should == taint
-                            entry.trace[0].url.should == @browser.url
+                            expect(entry.object).to eq('angular.$http')
+                            expect(entry.function.name).to eq('get')
+                            expect(entry.function.arguments).to eq([ "/#{taint}" ])
+                            expect(entry.tainted_value).to eq("/#{taint}")
+                            expect(entry.taint).to eq(taint)
+                            expect(entry.trace[0].url).to eq(@browser.url)
 
                             entry = sink[3]
-                            entry.object.should == 'XMLHttpRequestPrototype'
-                            entry.function.name.should == 'open'
-                            entry.function.arguments.should == [
+                            expect(entry.object).to eq('XMLHttpRequestPrototype')
+                            expect(entry.function.name).to eq('open')
+                            expect(entry.function.arguments).to eq([
                                 'GET', "/#{taint}", true
-                            ]
-                            entry.tainted_value.should == "/#{taint}"
-                            entry.taint.should == taint
-                            entry.trace[0].url.should == "#{@url}angular.js"
+                            ])
+                            expect(entry.tainted_value).to eq("/#{taint}")
+                            expect(entry.taint).to eq(taint)
+                            expect(entry.trace[0].url).to eq("#{@url}angular.js")
                         end
                     end
 
@@ -405,12 +413,12 @@ describe Arachni::Browser::Javascript::TaintTracer do
                             load_with_taint 'data_trace/AngularJS/$http.post'
 
                             sink = subject.data_flow_sinks[taint]
-                            sink.size.should == 4
+                            expect(sink.size).to eq(4)
 
                             entry = sink[1]
-                            entry.object.should == 'angular.$http'
-                            entry.function.name.should == 'post'
-                            entry.function.arguments.should == [
+                            expect(entry.object).to eq('angular.$http')
+                            expect(entry.function.name).to eq('post')
+                            expect(entry.function.arguments).to eq([
                                 '/', '',
                                 {
                                     'params' => {
@@ -420,20 +428,20 @@ describe Arachni::Browser::Javascript::TaintTracer do
                                     'url'    => '/',
                                     'data'   => ''
                                 }
-                            ]
-                            entry.tainted_value.should == "Stuff #{taint}"
-                            entry.taint.should == taint
-                            entry.trace[0].url.should == @browser.url
+                            ])
+                            expect(entry.tainted_value).to eq("Stuff #{taint}")
+                            expect(entry.taint).to eq(taint)
+                            expect(entry.trace[0].url).to eq(@browser.url)
 
                             entry = sink[3]
-                            entry.object.should == 'XMLHttpRequestPrototype'
-                            entry.function.name.should == 'open'
-                            entry.function.arguments.should == [
+                            expect(entry.object).to eq('XMLHttpRequestPrototype')
+                            expect(entry.function.name).to eq('open')
+                            expect(entry.function.arguments).to eq([
                                 'POST', "/?stuff=Stuff+#{taint}", true
-                            ]
-                            entry.tainted_value.should == "/?stuff=Stuff+#{taint}"
-                            entry.taint.should == taint
-                            entry.trace[0].url.should == "#{@url}angular.js"
+                            ])
+                            expect(entry.tainted_value).to eq("/?stuff=Stuff+#{taint}")
+                            expect(entry.taint).to eq(taint)
+                            expect(entry.trace[0].url).to eq("#{@url}angular.js")
                         end
                     end
                 end
@@ -444,28 +452,28 @@ describe Arachni::Browser::Javascript::TaintTracer do
                             load_with_taint 'data_trace/AngularJS/ngRoute/'
 
                             sink = subject.data_flow_sinks[taint]
-                            sink.size.should == 8
+                            expect(sink.size).to eq(8)
 
                             # ngRoute module first schedules an HTTP request to grab
                             # the template from the given 'templateUrl'...
                             entry = sink[6]
-                            entry.object.should == 'XMLHttpRequestPrototype'
-                            entry.function.name.should == 'open'
-                            entry.function.arguments.should == [
+                            expect(entry.object).to eq('XMLHttpRequestPrototype')
+                            expect(entry.function.name).to eq('open')
+                            expect(entry.function.arguments).to eq([
                                 'GET', "template.html?taint=#{taint}", true
-                            ]
-                            entry.tainted_value.should == "template.html?taint=#{taint}"
-                            entry.taint.should == taint
-                            entry.trace[0].url.should == "#{@url}angular.js"
+                            ])
+                            expect(entry.tainted_value).to eq("template.html?taint=#{taint}")
+                            expect(entry.taint).to eq(taint)
+                            expect(entry.trace[0].url).to eq("#{@url}angular.js")
 
                             #... and then updates the app with the (tainted) template content.
                             entry = sink[7]
-                            entry.object.should == 'angular.element'
-                            entry.function.name.should == 'html'
-                            entry.function.arguments.should == ["Blah blah blah #{taint}\n"]
-                            entry.tainted_value.should == "Blah blah blah #{taint}\n"
-                            entry.taint.should == taint
-                            entry.trace[0].url.should == "#{@url}angular-route.js"
+                            expect(entry.object).to eq('angular.element')
+                            expect(entry.function.name).to eq('html')
+                            expect(entry.function.arguments).to eq(["Blah blah blah #{taint}\n"])
+                            expect(entry.tainted_value).to eq("Blah blah blah #{taint}\n")
+                            expect(entry.taint).to eq(taint)
+                            expect(entry.trace[0].url).to eq("#{@url}angular-route.js")
                         end
                     end
                 end
@@ -476,18 +484,18 @@ describe Arachni::Browser::Javascript::TaintTracer do
                             load_with_taint 'data_trace/AngularJS/jqLite.html'
 
                             sink = subject.data_flow_sinks[taint]
-                            sink.size.should == 2
+                            expect(sink.size).to eq(2)
 
                             entry = sink[1]
-                            entry.object.should == 'angular.element'
-                            entry.function.name.should == 'html'
-                            entry.function.arguments.should == ["Stuff #{taint}"]
-                            entry.tainted_value.should == "Stuff #{taint}"
-                            entry.taint.should == taint
+                            expect(entry.object).to eq('angular.element')
+                            expect(entry.function.name).to eq('html')
+                            expect(entry.function.arguments).to eq(["Stuff #{taint}"])
+                            expect(entry.tainted_value).to eq("Stuff #{taint}")
+                            expect(entry.taint).to eq(taint)
 
                             trace = entry.trace[0]
-                            @browser.source.split("\n")[trace.line-1].should include 'html('
-                            trace.url.should == @browser.url
+                            expect(@browser.source.split("\n")[trace.line-1]).to include 'html('
+                            expect(trace.url).to eq(@browser.url)
                         end
                     end
 
@@ -496,18 +504,18 @@ describe Arachni::Browser::Javascript::TaintTracer do
                             load_with_taint 'data_trace/AngularJS/jqLite.text'
 
                             sink = subject.data_flow_sinks[taint]
-                            sink.size.should == 2
+                            expect(sink.size).to eq(2)
 
                             entry = sink[1]
-                            entry.object.should == 'angular.element'
-                            entry.function.name.should == 'text'
-                            entry.function.arguments.should == ["Stuff #{taint}"]
-                            entry.tainted_value.should == "Stuff #{taint}"
-                            entry.taint.should == taint
+                            expect(entry.object).to eq('angular.element')
+                            expect(entry.function.name).to eq('text')
+                            expect(entry.function.arguments).to eq(["Stuff #{taint}"])
+                            expect(entry.tainted_value).to eq("Stuff #{taint}")
+                            expect(entry.taint).to eq(taint)
 
                             trace = entry.trace[0]
-                            @browser.source.split("\n")[trace.line-1].should include 'text('
-                            trace.url.should == @browser.url
+                            expect(@browser.source.split("\n")[trace.line-1]).to include 'text('
+                            expect(trace.url).to eq(@browser.url)
                         end
                     end
 
@@ -516,18 +524,18 @@ describe Arachni::Browser::Javascript::TaintTracer do
                             load_with_taint 'data_trace/AngularJS/jqLite.append'
 
                             sink = subject.data_flow_sinks[taint]
-                            sink.size.should == 2
+                            expect(sink.size).to eq(2)
 
                             entry = sink[1]
-                            entry.object.should == 'angular.element'
-                            entry.function.name.should == 'append'
-                            entry.function.arguments.should == ["Stuff #{taint}"]
-                            entry.tainted_value.should == "Stuff #{taint}"
-                            entry.taint.should == taint
+                            expect(entry.object).to eq('angular.element')
+                            expect(entry.function.name).to eq('append')
+                            expect(entry.function.arguments).to eq(["Stuff #{taint}"])
+                            expect(entry.tainted_value).to eq("Stuff #{taint}")
+                            expect(entry.taint).to eq(taint)
 
                             trace = entry.trace[0]
-                            @browser.source.split("\n")[trace.line].should include 'append('
-                            trace.url.should == @browser.url
+                            expect(@browser.source.split("\n")[trace.line]).to include 'append('
+                            expect(trace.url).to eq(@browser.url)
                         end
                     end
 
@@ -536,18 +544,18 @@ describe Arachni::Browser::Javascript::TaintTracer do
                             load_with_taint 'data_trace/AngularJS/jqLite.prepend'
 
                             sink = subject.data_flow_sinks[taint]
-                            sink.size.should == 2
+                            expect(sink.size).to eq(2)
 
                             entry = sink[1]
-                            entry.object.should == 'angular.element'
-                            entry.function.name.should == 'prepend'
-                            entry.function.arguments.should == ["Stuff #{taint}"]
-                            entry.tainted_value.should == "Stuff #{taint}"
-                            entry.taint.should == taint
+                            expect(entry.object).to eq('angular.element')
+                            expect(entry.function.name).to eq('prepend')
+                            expect(entry.function.arguments).to eq(["Stuff #{taint}"])
+                            expect(entry.tainted_value).to eq("Stuff #{taint}")
+                            expect(entry.taint).to eq(taint)
 
                             trace = entry.trace[0]
-                            @browser.source.split("\n")[trace.line].should include 'prepend('
-                            trace.url.should == @browser.url
+                            expect(@browser.source.split("\n")[trace.line]).to include 'prepend('
+                            expect(trace.url).to eq(@browser.url)
                         end
                     end
 
@@ -556,18 +564,18 @@ describe Arachni::Browser::Javascript::TaintTracer do
                             load_with_taint 'data_trace/AngularJS/jqLite.prop'
 
                             sink = subject.data_flow_sinks[taint]
-                            sink.size.should == 2
+                            expect(sink.size).to eq(2)
 
                             entry = sink[1]
-                            entry.object.should == 'angular.element'
-                            entry.function.name.should == 'prop'
-                            entry.function.arguments.should == [ 'stuff', "Stuff #{taint}"]
-                            entry.tainted_value.should == "Stuff #{taint}"
-                            entry.taint.should == taint
+                            expect(entry.object).to eq('angular.element')
+                            expect(entry.function.name).to eq('prop')
+                            expect(entry.function.arguments).to eq([ 'stuff', "Stuff #{taint}"])
+                            expect(entry.tainted_value).to eq("Stuff #{taint}")
+                            expect(entry.taint).to eq(taint)
 
                             trace = entry.trace[0]
-                            @browser.source.split("\n")[trace.line].should include 'prop('
-                            trace.url.should == @browser.url
+                            expect(@browser.source.split("\n")[trace.line]).to include 'prop('
+                            expect(trace.url).to eq(@browser.url)
                         end
                     end
 
@@ -576,18 +584,18 @@ describe Arachni::Browser::Javascript::TaintTracer do
                             load_with_taint 'data_trace/AngularJS/jqLite.replaceWith'
 
                             sink = subject.data_flow_sinks[taint]
-                            sink.size.should == 2
+                            expect(sink.size).to eq(2)
 
                             entry = sink[1]
-                            entry.object.should == 'angular.element'
-                            entry.function.name.should == 'replaceWith'
-                            entry.function.arguments.should == [ "Stuff #{taint}"]
-                            entry.tainted_value.should == "Stuff #{taint}"
-                            entry.taint.should == taint
+                            expect(entry.object).to eq('angular.element')
+                            expect(entry.function.name).to eq('replaceWith')
+                            expect(entry.function.arguments).to eq([ "Stuff #{taint}"])
+                            expect(entry.tainted_value).to eq("Stuff #{taint}")
+                            expect(entry.taint).to eq(taint)
 
                             trace = entry.trace[0]
-                            @browser.source.split("\n")[trace.line-1].should include 'replaceWith('
-                            trace.url.should == @browser.url
+                            expect(@browser.source.split("\n")[trace.line-1]).to include 'replaceWith('
+                            expect(trace.url).to eq(@browser.url)
                         end
                     end
 
@@ -596,18 +604,18 @@ describe Arachni::Browser::Javascript::TaintTracer do
                             load_with_taint 'data_trace/AngularJS/jqLite.val'
 
                             sink = subject.data_flow_sinks[taint]
-                            sink.size.should == 2
+                            expect(sink.size).to eq(2)
 
                             entry = sink[1]
-                            entry.object.should == 'angular.element'
-                            entry.function.name.should == 'val'
-                            entry.function.arguments.should == [ "Stuff #{taint}"]
-                            entry.tainted_value.should == "Stuff #{taint}"
-                            entry.taint.should == taint
+                            expect(entry.object).to eq('angular.element')
+                            expect(entry.function.name).to eq('val')
+                            expect(entry.function.arguments).to eq([ "Stuff #{taint}"])
+                            expect(entry.tainted_value).to eq("Stuff #{taint}")
+                            expect(entry.taint).to eq(taint)
 
                             trace = entry.trace[0]
-                            @browser.source.split("\n")[trace.line].should include 'val('
-                            trace.url.should == @browser.url
+                            expect(@browser.source.split("\n")[trace.line]).to include 'val('
+                            expect(trace.url).to eq(@browser.url)
                         end
                     end
                 end
@@ -619,18 +627,18 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/jQuery.cookie'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 2
+                        expect(sink.size).to eq(2)
 
                         entry = sink[0]
-                        entry.object.should == 'jQuery'
-                        entry.function.name.should == 'cookie'
-                        entry.function.arguments.should == ['cname', "mystuff #{taint}"]
-                        entry.tainted_value.should == "mystuff #{taint}"
-                        entry.taint.should == taint
+                        expect(entry.object).to eq('jQuery')
+                        expect(entry.function.name).to eq('cookie')
+                        expect(entry.function.arguments).to eq(['cname', "mystuff #{taint}"])
+                        expect(entry.tainted_value).to eq("mystuff #{taint}")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'cookie('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'cookie('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
 
@@ -639,25 +647,25 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/jQuery.ajax'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 3
+                        expect(sink.size).to eq(3)
 
                         entry = sink[0]
-                        entry.object.should == 'jQuery'
-                        entry.function.name.should == 'ajax'
-                        entry.function.arguments.should == [
+                        expect(entry.object).to eq('jQuery')
+                        expect(entry.function.name).to eq('ajax')
+                        expect(entry.function.arguments).to eq([
                             {
                                 'url'  => '/',
                                 'data' => {
                                     'stuff' => "mystuff #{taint}"
                                 }
                             }
-                        ]
-                        entry.tainted_value.should == "mystuff #{taint}"
-                        entry.taint.should == taint
+                        ])
+                        expect(entry.tainted_value).to eq("mystuff #{taint}")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'ajax('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'ajax('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
 
@@ -666,21 +674,21 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/jQuery.get'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 4
+                        expect(sink.size).to eq(4)
 
                         entry = sink[0]
-                        entry.object.should == 'jQuery'
-                        entry.function.name.should == 'get'
-                        entry.function.arguments.should == [
+                        expect(entry.object).to eq('jQuery')
+                        expect(entry.function.name).to eq('get')
+                        expect(entry.function.arguments).to eq([
                             '/',
                             { 'stuff' => "mystuff #{taint}" }
-                        ]
-                        entry.tainted_value.should == "mystuff #{taint}"
-                        entry.taint.should == taint
+                        ])
+                        expect(entry.tainted_value).to eq("mystuff #{taint}")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'get('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'get('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
 
@@ -689,18 +697,18 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/jQuery.post'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 3
+                        expect(sink.size).to eq(3)
 
                         entry = sink[0]
-                        entry.object.should == 'jQuery'
-                        entry.function.name.should == 'post'
-                        entry.function.arguments.should == [ "/#{taint}" ]
-                        entry.tainted_value.should == "/#{taint}"
-                        entry.taint.should == taint
+                        expect(entry.object).to eq('jQuery')
+                        expect(entry.function.name).to eq('post')
+                        expect(entry.function.arguments).to eq([ "/#{taint}" ])
+                        expect(entry.tainted_value).to eq("/#{taint}")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'post('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'post('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
 
@@ -709,18 +717,18 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/jQuery.load'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 3
+                        expect(sink.size).to eq(3)
 
                         entry = sink[0]
-                        entry.object.should == 'jQuery'
-                        entry.function.name.should == 'load'
-                        entry.function.arguments.should == [ "/#{taint}" ]
-                        entry.tainted_value.should == "/#{taint}"
-                        entry.taint.should == taint
+                        expect(entry.object).to eq('jQuery')
+                        expect(entry.function.name).to eq('load')
+                        expect(entry.function.arguments).to eq([ "/#{taint}" ])
+                        expect(entry.tainted_value).to eq("/#{taint}")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'load('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'load('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
 
@@ -729,18 +737,18 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/jQuery.html'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 1
+                        expect(sink.size).to eq(1)
 
                         entry = sink[0]
-                        entry.object.should == 'jQuery'
-                        entry.function.name.should == 'html'
-                        entry.function.arguments.should == ["Stuff #{taint}"]
-                        entry.tainted_value.should == "Stuff #{taint}"
-                        entry.taint.should == taint
+                        expect(entry.object).to eq('jQuery')
+                        expect(entry.function.name).to eq('html')
+                        expect(entry.function.arguments).to eq(["Stuff #{taint}"])
+                        expect(entry.tainted_value).to eq("Stuff #{taint}")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line-1].should include 'html('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line-1]).to include 'html('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
 
@@ -749,18 +757,18 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/jQuery.text'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 2
+                        expect(sink.size).to eq(2)
 
                         entry = sink[0]
-                        entry.object.should == 'jQuery'
-                        entry.function.name.should == 'text'
-                        entry.function.arguments.should == ["Stuff #{taint}"]
-                        entry.tainted_value.should == "Stuff #{taint}"
-                        entry.taint.should == taint
+                        expect(entry.object).to eq('jQuery')
+                        expect(entry.function.name).to eq('text')
+                        expect(entry.function.arguments).to eq(["Stuff #{taint}"])
+                        expect(entry.tainted_value).to eq("Stuff #{taint}")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line-1].should include 'text('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line-1]).to include 'text('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
 
@@ -769,18 +777,18 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/jQuery.append'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 2
+                        expect(sink.size).to eq(2)
 
                         entry = sink[0]
-                        entry.object.should == 'jQuery'
-                        entry.function.name.should == 'append'
-                        entry.function.arguments.should == ["Stuff #{taint}"]
-                        entry.tainted_value.should == "Stuff #{taint}"
-                        entry.taint.should == taint
+                        expect(entry.object).to eq('jQuery')
+                        expect(entry.function.name).to eq('append')
+                        expect(entry.function.arguments).to eq(["Stuff #{taint}"])
+                        expect(entry.tainted_value).to eq("Stuff #{taint}")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'append('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'append('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
 
@@ -789,18 +797,18 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/jQuery.prepend'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 2
+                        expect(sink.size).to eq(2)
 
                         entry = sink[0]
-                        entry.object.should == 'jQuery'
-                        entry.function.name.should == 'prepend'
-                        entry.function.arguments.should == ["Stuff #{taint}"]
-                        entry.tainted_value.should == "Stuff #{taint}"
-                        entry.taint.should == taint
+                        expect(entry.object).to eq('jQuery')
+                        expect(entry.function.name).to eq('prepend')
+                        expect(entry.function.arguments).to eq(["Stuff #{taint}"])
+                        expect(entry.tainted_value).to eq("Stuff #{taint}")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'prepend('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'prepend('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
 
@@ -809,18 +817,18 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/jQuery.before'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 2
+                        expect(sink.size).to eq(2)
 
                         entry = sink[0]
-                        entry.object.should == 'jQuery'
-                        entry.function.name.should == 'before'
-                        entry.function.arguments.should == ["Stuff #{taint}"]
-                        entry.tainted_value.should == "Stuff #{taint}"
-                        entry.taint.should == taint
+                        expect(entry.object).to eq('jQuery')
+                        expect(entry.function.name).to eq('before')
+                        expect(entry.function.arguments).to eq(["Stuff #{taint}"])
+                        expect(entry.tainted_value).to eq("Stuff #{taint}")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'before('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'before('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
 
@@ -829,18 +837,18 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/jQuery.prop'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 1
+                        expect(sink.size).to eq(1)
 
                         entry = sink[0]
-                        entry.object.should == 'jQuery'
-                        entry.function.name.should == 'prop'
-                        entry.function.arguments.should == [ 'stuff', "Stuff #{taint}"]
-                        entry.tainted_value.should == "Stuff #{taint}"
-                        entry.taint.should == taint
+                        expect(entry.object).to eq('jQuery')
+                        expect(entry.function.name).to eq('prop')
+                        expect(entry.function.arguments).to eq([ 'stuff', "Stuff #{taint}"])
+                        expect(entry.tainted_value).to eq("Stuff #{taint}")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'prop('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'prop('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
 
@@ -849,18 +857,18 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/jQuery.replaceWith'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 2
+                        expect(sink.size).to eq(2)
 
                         entry = sink[0]
-                        entry.object.should == 'jQuery'
-                        entry.function.name.should == 'replaceWith'
-                        entry.function.arguments.should == [ "Stuff #{taint}"]
-                        entry.tainted_value.should == "Stuff #{taint}"
-                        entry.taint.should == taint
+                        expect(entry.object).to eq('jQuery')
+                        expect(entry.function.name).to eq('replaceWith')
+                        expect(entry.function.arguments).to eq([ "Stuff #{taint}"])
+                        expect(entry.tainted_value).to eq("Stuff #{taint}")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line-1].should include 'replaceWith('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line-1]).to include 'replaceWith('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
 
@@ -869,18 +877,18 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/jQuery.val'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 1
+                        expect(sink.size).to eq(1)
 
                         entry = sink[0]
-                        entry.object.should == 'jQuery'
-                        entry.function.name.should == 'val'
-                        entry.function.arguments.should == [ "Stuff #{taint}"]
-                        entry.tainted_value.should == "Stuff #{taint}"
-                        entry.taint.should == taint
+                        expect(entry.object).to eq('jQuery')
+                        expect(entry.function.name).to eq('val')
+                        expect(entry.function.arguments).to eq([ "Stuff #{taint}"])
+                        expect(entry.tainted_value).to eq("Stuff #{taint}")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'val('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'val('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
             end
@@ -891,21 +899,21 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/String.replace'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 1
+                        expect(sink.size).to eq(1)
 
                         entry = sink[0]
-                        entry.object.should == 'String'
-                        entry.function.name.should == 'replace'
-                        entry.function.source.should start_with 'function replace'
-                        entry.function.arguments.should == [
+                        expect(entry.object).to eq('String')
+                        expect(entry.function.name).to eq('replace')
+                        expect(entry.function.source).to start_with 'function replace'
+                        expect(entry.function.arguments).to eq([
                             'my', taint
-                        ]
-                        entry.tainted_value.should == taint
-                        entry.taint.should == taint
+                        ])
+                        expect(entry.tainted_value).to eq(taint)
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'replace('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'replace('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
 
@@ -914,19 +922,19 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/String.concat'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 1
+                        expect(sink.size).to eq(1)
 
                         entry = sink[0]
-                        entry.object.should == 'String'
-                        entry.function.name.should == 'concat'
-                        entry.function.source.should start_with 'function concat'
-                        entry.function.arguments.should == [ "stuff #{taint}" ]
-                        entry.tainted_value.should == "stuff #{taint}"
-                        entry.taint.should == taint
+                        expect(entry.object).to eq('String')
+                        expect(entry.function.name).to eq('concat')
+                        expect(entry.function.source).to start_with 'function concat'
+                        expect(entry.function.arguments).to eq([ "stuff #{taint}" ])
+                        expect(entry.tainted_value).to eq("stuff #{taint}")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'concat('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'concat('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
 
@@ -935,19 +943,19 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/String.indexOf'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 1
+                        expect(sink.size).to eq(1)
 
                         entry = sink[0]
-                        entry.object.should == 'String'
-                        entry.function.name.should == 'indexOf'
-                        entry.function.source.should start_with 'function indexOf'
-                        entry.function.arguments.should == [ "stuff #{taint}" ]
-                        entry.tainted_value.should == "stuff #{taint}"
-                        entry.taint.should == taint
+                        expect(entry.object).to eq('String')
+                        expect(entry.function.name).to eq('indexOf')
+                        expect(entry.function.source).to start_with 'function indexOf'
+                        expect(entry.function.arguments).to eq([ "stuff #{taint}" ])
+                        expect(entry.tainted_value).to eq("stuff #{taint}")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'indexOf('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'indexOf('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
 
@@ -956,19 +964,19 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/String.lastIndexOf'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 1
+                        expect(sink.size).to eq(1)
 
                         entry = sink[0]
-                        entry.object.should == 'String'
-                        entry.function.name.should == 'lastIndexOf'
-                        entry.function.source.should start_with 'function lastIndexOf'
-                        entry.function.arguments.should == [ "stuff #{taint}" ]
-                        entry.tainted_value.should == "stuff #{taint}"
-                        entry.taint.should == taint
+                        expect(entry.object).to eq('String')
+                        expect(entry.function.name).to eq('lastIndexOf')
+                        expect(entry.function.source).to start_with 'function lastIndexOf'
+                        expect(entry.function.arguments).to eq([ "stuff #{taint}" ])
+                        expect(entry.tainted_value).to eq("stuff #{taint}")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'lastIndexOf('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'lastIndexOf('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
             end
@@ -979,21 +987,21 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/HTMLElement.insertAdjacentHTML'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 1
+                        expect(sink.size).to eq(1)
 
                         entry = sink[0]
-                        entry.object.should == 'HTMLElementPrototype'
-                        entry.function.name.should == 'insertAdjacentHTML'
-                        entry.function.source.should start_with 'function insertAdjacentHTML'
-                        entry.function.arguments.should == [
+                        expect(entry.object).to eq('HTMLElementPrototype')
+                        expect(entry.function.name).to eq('insertAdjacentHTML')
+                        expect(entry.function.source).to start_with 'function insertAdjacentHTML'
+                        expect(entry.function.arguments).to eq([
                             'AfterBegin', "stuff #{taint} more stuff"
-                        ]
-                        entry.tainted_value.should == "stuff #{taint} more stuff"
-                        entry.taint.should == taint
+                        ])
+                        expect(entry.tainted_value).to eq("stuff #{taint} more stuff")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'insertAdjacentHTML('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'insertAdjacentHTML('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
             end
@@ -1004,21 +1012,21 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/Element.setAttribute'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 1
+                        expect(sink.size).to eq(1)
 
                         entry = sink[0]
-                        entry.object.should == 'ElementPrototype'
-                        entry.function.name.should == 'setAttribute'
-                        entry.function.source.should start_with 'function setAttribute'
-                        entry.function.arguments.should == [
+                        expect(entry.object).to eq('ElementPrototype')
+                        expect(entry.function.name).to eq('setAttribute')
+                        expect(entry.function.source).to start_with 'function setAttribute'
+                        expect(entry.function.arguments).to eq([
                             'my-attribute', "stuff #{taint} more stuff"
-                        ]
-                        entry.tainted_value.should == "stuff #{taint} more stuff"
-                        entry.taint.should == taint
+                        ])
+                        expect(entry.tainted_value).to eq("stuff #{taint} more stuff")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'setAttribute('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'setAttribute('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
             end
@@ -1029,19 +1037,19 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/Document.createTextNode'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 1
+                        expect(sink.size).to eq(1)
 
                         entry = sink[0]
-                        entry.object.should == 'DocumentPrototype'
-                        entry.function.name.should == 'createTextNode'
-                        entry.function.source.should start_with 'function createTextNode'
-                        entry.function.arguments.should == [ "node #{taint}" ]
-                        entry.tainted_value.should == "node #{taint}"
-                        entry.taint.should == taint
+                        expect(entry.object).to eq('DocumentPrototype')
+                        expect(entry.function.name).to eq('createTextNode')
+                        expect(entry.function.source).to start_with 'function createTextNode'
+                        expect(entry.function.arguments).to eq([ "node #{taint}" ])
+                        expect(entry.tainted_value).to eq("node #{taint}")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'document.createTextNode('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'document.createTextNode('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
             end
@@ -1052,19 +1060,19 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/CharacterData.insertData'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 1
+                        expect(sink.size).to eq(1)
 
                         entry = sink[0]
-                        entry.object.should == 'CharacterDataPrototype'
-                        entry.function.name.should == 'insertData'
-                        entry.function.source.should start_with 'function insertData'
-                        entry.function.arguments.should == [ "Stuff #{taint}" ]
-                        entry.tainted_value.should == "Stuff #{taint}"
-                        entry.taint.should == taint
+                        expect(entry.object).to eq('CharacterDataPrototype')
+                        expect(entry.function.name).to eq('insertData')
+                        expect(entry.function.source).to start_with 'function insertData'
+                        expect(entry.function.arguments).to eq([ "Stuff #{taint}" ])
+                        expect(entry.tainted_value).to eq("Stuff #{taint}")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'insertData('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'insertData('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
 
@@ -1073,19 +1081,19 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/CharacterData.appendData'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 1
+                        expect(sink.size).to eq(1)
 
                         entry = sink[0]
-                        entry.object.should == 'CharacterDataPrototype'
-                        entry.function.name.should == 'appendData'
-                        entry.function.source.should start_with 'function appendData'
-                        entry.function.arguments.should == [ "Stuff #{taint}" ]
-                        entry.tainted_value.should == "Stuff #{taint}"
-                        entry.taint.should == taint
+                        expect(entry.object).to eq('CharacterDataPrototype')
+                        expect(entry.function.name).to eq('appendData')
+                        expect(entry.function.source).to start_with 'function appendData'
+                        expect(entry.function.arguments).to eq([ "Stuff #{taint}" ])
+                        expect(entry.tainted_value).to eq("Stuff #{taint}")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'appendData('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'appendData('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
 
@@ -1094,19 +1102,19 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/CharacterData.replaceData'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 1
+                        expect(sink.size).to eq(1)
 
                         entry = sink[0]
-                        entry.object.should == 'CharacterDataPrototype'
-                        entry.function.name.should == 'replaceData'
-                        entry.function.source.should start_with 'function replaceData'
-                        entry.function.arguments.should == [ 0, 0, "Stuff #{taint}" ]
-                        entry.tainted_value.should == "Stuff #{taint}"
-                        entry.taint.should == taint
+                        expect(entry.object).to eq('CharacterDataPrototype')
+                        expect(entry.function.name).to eq('replaceData')
+                        expect(entry.function.source).to start_with 'function replaceData'
+                        expect(entry.function.arguments).to eq([ 0, 0, "Stuff #{taint}" ])
+                        expect(entry.tainted_value).to eq("Stuff #{taint}")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'replaceData('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'replaceData('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
             end
@@ -1117,19 +1125,19 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/Text.replaceWholeText'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 1
+                        expect(sink.size).to eq(1)
 
                         entry = sink[0]
-                        entry.object.should == 'TextPrototype'
-                        entry.function.name.should == 'replaceWholeText'
-                        entry.function.source.should start_with 'function replaceWholeText'
-                        entry.function.arguments.should == [ "Stuff #{taint}" ]
-                        entry.tainted_value.should == "Stuff #{taint}"
-                        entry.taint.should == taint
+                        expect(entry.object).to eq('TextPrototype')
+                        expect(entry.function.name).to eq('replaceWholeText')
+                        expect(entry.function.source).to start_with 'function replaceWholeText'
+                        expect(entry.function.arguments).to eq([ "Stuff #{taint}" ])
+                        expect(entry.tainted_value).to eq("Stuff #{taint}")
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'replaceWholeText('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'replaceWholeText('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
             end
@@ -1140,22 +1148,23 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/HTMLDocument.write'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 1
+                        expect(sink.size).to eq(1)
 
                         entry = sink[0]
-                        entry.object.should == 'HTMLDocumentPrototype'
-                        entry.function.name.should == 'write'
-                        entry.function.source.should start_with 'function write'
-                        entry.function.arguments.should == [
+                        expect(entry.object).to eq('HTMLDocumentPrototype')
+                        expect(entry.function.name).to eq('write')
+                        expect(entry.function.source).to start_with 'function write'
+                        expect(entry.function.arguments).to eq([
                             "Stuff here blah #{taint} more stuff nlahblah..."
-                        ]
-                        entry.tainted_value.should ==
+                        ])
+                        expect(entry.tainted_value).to eq(
                             "Stuff here blah #{taint} more stuff nlahblah..."
-                        entry.taint.should == taint
+                        )
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'document.write('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'document.write('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
 
@@ -1164,22 +1173,23 @@ describe Arachni::Browser::Javascript::TaintTracer do
                         load_with_taint 'data_trace/HTMLDocument.writeln'
 
                         sink = subject.data_flow_sinks[taint]
-                        sink.size.should == 1
+                        expect(sink.size).to eq(1)
 
                         entry = sink[0]
-                        entry.object.should == 'HTMLDocumentPrototype'
-                        entry.function.name.should == 'writeln'
-                        entry.function.source.should start_with 'function writeln'
-                        entry.function.arguments.should == [
+                        expect(entry.object).to eq('HTMLDocumentPrototype')
+                        expect(entry.function.name).to eq('writeln')
+                        expect(entry.function.source).to start_with 'function writeln'
+                        expect(entry.function.arguments).to eq([
                             "Stuff here blah #{taint} more stuff nlahblah..."
-                        ]
-                        entry.tainted_value.should ==
+                        ])
+                        expect(entry.tainted_value).to eq(
                             "Stuff here blah #{taint} more stuff nlahblah..."
-                        entry.taint.should == taint
+                        )
+                        expect(entry.taint).to eq(taint)
 
                         trace = entry.trace[0]
-                        @browser.source.split("\n")[trace.line].should include 'document.writeln('
-                        trace.url.should == @browser.url
+                        expect(@browser.source.split("\n")[trace.line]).to include 'document.writeln('
+                        expect(trace.url).to eq(@browser.url)
                     end
                 end
             end
@@ -1189,7 +1199,7 @@ describe Arachni::Browser::Javascript::TaintTracer do
     describe '#taints' do
         context 'by default' do
             it 'returns []' do
-                subject.taints.should == []
+                expect(subject.taints).to eq([])
             end
         end
     end
@@ -1197,14 +1207,14 @@ describe Arachni::Browser::Javascript::TaintTracer do
     describe '#enable_debugging=' do
         it 'sets the debugging flag' do
             subject.enable_debugging = false
-            subject.enable_debugging.should == false
+            expect(subject.enable_debugging).to eq(false)
         end
     end
 
     describe '#enable_debugging' do
         context 'by default' do
             it 'returns true' do
-                subject.enable_debugging.should == true
+                expect(subject.enable_debugging).to eq(true)
             end
         end
     end
@@ -1213,12 +1223,12 @@ describe Arachni::Browser::Javascript::TaintTracer do
         it 'returns sink data' do
             load "debug?input=#{subject.stub.function(:log_execution_flow_sink)}"
             @browser.watir.form.submit
-            subject.execution_flow_sinks.should be_any
+            expect(subject.execution_flow_sinks).to be_any
         end
 
         context 'by default' do
             it 'returns []' do
-                subject.execution_flow_sinks.should == []
+                expect(subject.execution_flow_sinks).to eq([])
             end
         end
     end
@@ -1227,12 +1237,12 @@ describe Arachni::Browser::Javascript::TaintTracer do
         it 'returns sink data' do
             load "debug?input=#{subject.stub.function(:log_data_flow_sink, 'taint', { function: 'blah' })}"
             @browser.watir.form.submit
-            subject.data_flow_sinks['taint'].should be_any
+            expect(subject.data_flow_sinks['taint']).to be_any
         end
 
         context 'by default' do
             it 'returns {}' do
-                subject.data_flow_sinks.should == {}
+                expect(subject.data_flow_sinks).to eq({})
             end
         end
     end
@@ -1244,34 +1254,34 @@ describe Arachni::Browser::Javascript::TaintTracer do
             sink_data = subject.flush_data_flow_sinks['taint']
 
             first_entry = sink_data.first
-            sink_data.should == [first_entry]
+            expect(sink_data).to eq([first_entry])
 
-            first_entry.function.name.should == 'blah'
-            first_entry.trace.size.should == 2
+            expect(first_entry.function.name).to eq('blah')
+            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_data_flow_sink'
-            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_data_flow_sink'
+            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 'onsubmit'
-            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 'onsubmit'
+            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
 
         it 'empties the sink' do
             load "debug?input=#{subject.stub.function(:log_data_flow_sink, { function: { name: 'blah' } })}"
             @browser.watir.form.submit
             subject.flush_data_flow_sinks
-            subject.data_flow_sinks.should be_empty
+            expect(subject.data_flow_sinks).to be_empty
         end
     end
 
@@ -1282,34 +1292,34 @@ describe Arachni::Browser::Javascript::TaintTracer do
             sink_data = subject.flush_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 'onsubmit'
-            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 'onsubmit'
+            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
 
         it 'empties the sink' do
             load "debug?input=#{subject.stub.function(:log_data_flow_sink)}"
             @browser.watir.form.submit
             subject.flush_execution_flow_sinks
-            subject.execution_flow_sinks.should be_empty
+            expect(subject.execution_flow_sinks).to be_empty
         end
     end
 
@@ -1320,27 +1330,27 @@ describe Arachni::Browser::Javascript::TaintTracer do
             sink_data = subject.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 'onsubmit'
-            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 'onsubmit'
+            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
 
         it 'is limited to 50' do
@@ -1351,10 +1361,10 @@ describe Arachni::Browser::Javascript::TaintTracer do
             end
 
             sinks = subject.execution_flow_sinks
-            sinks.size.should == 50
+            expect(sinks.size).to eq(50)
 
             50.times do |i|
-                sinks[i].data.should == [50 + i]
+                expect(sinks[i].data).to eq([50 + i])
             end
         end
     end
@@ -1366,27 +1376,27 @@ describe Arachni::Browser::Javascript::TaintTracer do
             sink_data = subject.data_flow_sinks['taint']
 
             first_entry = sink_data.first
-            sink_data.should == [first_entry]
+            expect(sink_data).to eq([first_entry])
 
-            first_entry.function.name.should == 'blah'
-            first_entry.trace.size.should == 2
+            expect(first_entry.function.name).to eq('blah')
+            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_data_flow_sink'
-            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_data_flow_sink'
+            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 'onsubmit'
-            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 'onsubmit'
+            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
 
         it 'is limited to 50 per taint' do
@@ -1407,10 +1417,10 @@ describe Arachni::Browser::Javascript::TaintTracer do
             end
 
             sinks = subject.data_flow_sinks['taint']
-            sinks.size.should == 50
+            expect(sinks.size).to eq(50)
 
             50.times do |i|
-                sinks[i].function.name.should == "f_#{i+50}"
+                expect(sinks[i].function.name).to eq("f_#{i+50}")
             end
         end
 
@@ -1420,12 +1430,12 @@ describe Arachni::Browser::Javascript::TaintTracer do
         it 'returns debugging information' do
             load "debug?input=#{subject.stub.function(:debug, 1)}"
             @browser.watir.form.submit
-            subject.debugging_data.should be_any
+            expect(subject.debugging_data).to be_any
         end
 
         context 'by default' do
             it 'returns []' do
-                subject.debugging_data.should == []
+                expect(subject.debugging_data).to eq([])
             end
         end
     end
@@ -1441,27 +1451,27 @@ describe Arachni::Browser::Javascript::TaintTracer do
                 debugging_data = subject.debugging_data
 
                 first_entry = debugging_data.first
-                debugging_data.should == [first_entry]
+                expect(debugging_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 'debug(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 'debug(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
         end
 
@@ -1472,7 +1482,7 @@ describe Arachni::Browser::Javascript::TaintTracer do
                 subject.enable_debugging = false
 
                 @browser.watir.form.submit
-                subject.debugging_data.should be_empty
+                expect(subject.debugging_data).to be_empty
             end
         end
     end