arachni 1.2.1 → 1.3

data/spec/arachni/data/plugins_spec.rb

@@ -23,13 +23,13 @@ describe Arachni::Data::Plugins do
 
             subject.store( plugins.create(:distributable), result )
 
-            subject.statistics[:names].should == [:distributable]
+            expect(subject.statistics[:names]).to eq([:distributable])
         end
     end
 
     describe '#results' do
         it 'returns a Hash' do
-            subject.results.should be_kind_of Hash
+            expect(subject.results).to be_kind_of Hash
         end
     end
 
@@ -39,7 +39,7 @@ describe Arachni::Data::Plugins do
             result = { stuff: 1 }
 
             subject.store( plugins.create(:distributable), result )
-            subject.results[:distributable][:results].should == result
+            expect(subject.results[:distributable][:results]).to eq(result)
         end
     end
 
@@ -51,7 +51,7 @@ describe Arachni::Data::Plugins do
             subject.store( plugins.create(:distributable), 'stuff' => 1 )
 
             subject.merge_results( plugins, results )
-            subject.results[:distributable][:results]['stuff'].should == 3
+            expect(subject.results[:distributable][:results]['stuff']).to eq(3)
         end
 
         context 'when a merge error occurs' do
@@ -61,10 +61,10 @@ describe Arachni::Data::Plugins do
                 results = [ distributable: { results: { 'stuff' => 2 } } ]
                 subject.store( plugins.create(:distributable), 'stuff' => 1 )
 
-                plugins[:distributable].stub(:merge) { raise }
+                allow(plugins[:distributable]).to receive(:merge) { raise }
 
                 subject.merge_results( plugins, results )
-                subject.results[:distributable][:results]['stuff'].should == 1
+                expect(subject.results[:distributable][:results]['stuff']).to eq(1)
             end
         end
     end
@@ -75,10 +75,10 @@ describe Arachni::Data::Plugins do
             subject.dump( dump_directory )
 
             results_file = "#{dump_directory}/results/distributable"
-            File.exists?( results_file ).should be_true
-            subject.results.should == {
+            expect(File.exists?( results_file )).to be_truthy
+            expect(subject.results).to eq({
                 distributable: Marshal.load( IO.read( results_file ) )
-            }
+            })
         end
     end
 
@@ -87,14 +87,14 @@ describe Arachni::Data::Plugins do
             subject.store( plugins.create(:distributable), stuff: 1 )
             subject.dump( dump_directory )
 
-            subject.results.should == described_class.load( dump_directory ).results
+            expect(subject.results).to eq(described_class.load( dump_directory ).results)
         end
     end
 
     describe '#clear' do
         %w(results).each do |method|
             it "clears ##{method}" do
-                subject.send(method).should receive(:clear)
+                expect(subject.send(method)).to receive(:clear)
                 subject.clear
             end
         end

data/spec/arachni/data/session_spec.rb

@@ -18,13 +18,13 @@ describe Arachni::Data::Session do
 
     describe '#statistics' do
         it 'returns an empty Hash' do
-            subject.statistics.should == {}
+            expect(subject.statistics).to eq({})
         end
     end
 
     describe '#configuration' do
         it 'returns an empty Hash' do
-            subject.configuration.should == {}
+            expect(subject.configuration).to eq({})
         end
     end
 
@@ -34,8 +34,8 @@ describe Arachni::Data::Session do
             subject.dump( dump_directory )
 
             results_file = "#{dump_directory}/configuration"
-            File.exists?( results_file ).should be_true
-            subject.configuration.should == { stuff: [1] }
+            expect(File.exists?( results_file )).to be_truthy
+            expect(subject.configuration).to eq({ stuff: [1] })
         end
     end
 
@@ -44,14 +44,14 @@ describe Arachni::Data::Session do
             subject.configuration[:stuff] = [1]
             subject.dump( dump_directory )
 
-            subject.configuration.should == described_class.load( dump_directory ).configuration
+            expect(subject.configuration).to eq(described_class.load( dump_directory ).configuration)
         end
     end
 
     describe '#clear' do
         %w(configuration).each do |method|
             it "clears ##{method}" do
-                subject.send(method).should receive(:clear)
+                expect(subject.send(method)).to receive(:clear)
                 subject.clear
             end
         end

data/spec/arachni/data_spec.rb

@@ -15,32 +15,32 @@ describe Arachni::Data do
 
     describe '#framework' do
         it "returns an instance of #{described_class::Framework}" do
-            subject.framework.should be_kind_of described_class::Framework
+            expect(subject.framework).to be_kind_of described_class::Framework
         end
     end
 
     describe '#session' do
         it "returns an instance of #{described_class::Session}" do
-            subject.session.should be_kind_of described_class::Session
+            expect(subject.session).to be_kind_of described_class::Session
         end
     end
 
     describe '#issues' do
         it "returns an instance of #{described_class::Issues}" do
-            subject.issues.should be_kind_of described_class::Issues
+            expect(subject.issues).to be_kind_of described_class::Issues
         end
     end
 
     describe '#plugins' do
         it "returns an instance of #{described_class::Plugins}" do
-            subject.plugins.should be_kind_of described_class::Plugins
+            expect(subject.plugins).to be_kind_of described_class::Plugins
         end
     end
 
     describe '#statistics' do
         %w(framework issues plugins).each do |name|
             it "includes :#{name} statistics" do
-                subject.statistics[name.to_sym].should == subject.send(name).statistics
+                expect(subject.statistics[name.to_sym]).to eq(subject.send(name).statistics)
             end
         end
     end
@@ -54,8 +54,8 @@ describe Arachni::Data do
 
                 new_instance = subject.load( dump_directory ).send(name)
 
-                new_instance.should be_kind_of subject.send(name).class
-                new_instance.object_id.should_not == previous_instance.object_id
+                expect(new_instance).to be_kind_of subject.send(name).class
+                expect(new_instance.object_id).not_to eq(previous_instance.object_id)
             end
         end
     end
@@ -63,7 +63,7 @@ describe Arachni::Data do
     describe '#clear' do
         %w(framework issues plugins session).each do |method|
             it "clears ##{method}" do
-                subject.send(method).should receive(:clear)
+                expect(subject.send(method)).to receive(:clear)
                 subject.clear
             end
         end

data/spec/arachni/element/body_spec.rb

@@ -37,21 +37,21 @@ describe Arachni::Element::Body do
                 it 'logs an issue' do
                     auditable.match_and_log( valid_pattern )
 
-                    logged_issue = Arachni::Data.issues.flatten.first
-                    logged_issue.should be_true
+                    logged_issue = Arachni::Data.issues.first
+                    expect(logged_issue).to be_truthy
 
-                    logged_issue.vector.url.should == Arachni::Utilities.normalize_url( @url )
-                    logged_issue.vector.class.should == Arachni::Element::Body
-                    logged_issue.signature.should == valid_pattern.source
-                    logged_issue.proof.should == 'Match'
-                    logged_issue.trusted.should be_true
+                    expect(logged_issue.vector.url).to eq(Arachni::Utilities.normalize_url( @url ))
+                    expect(logged_issue.vector.class).to eq(Arachni::Element::Body)
+                    expect(logged_issue.signature).to eq(valid_pattern.source)
+                    expect(logged_issue.proof).to eq('Match')
+                    expect(logged_issue.trusted).to be_truthy
                 end
             end
 
             context 'and it does not matche the given pattern' do
                 it 'does not log an issue' do
                     auditable.match_and_log( invalid_pattern )
-                    Arachni::Data.issues.should be_empty
+                    expect(Arachni::Data.issues).to be_empty
                 end
             end
         end
@@ -60,8 +60,8 @@ describe Arachni::Element::Body do
     describe '#dup' do
         it 'duplicates self' do
             body = auditable.dup
-            body.should == auditable
-            body.object_id.should_not == auditable
+            expect(body).to eq(auditable)
+            expect(body.object_id).not_to eq(auditable)
         end
     end
 

data/spec/arachni/element/capabilities/analyzable/differential_spec.rb

@@ -22,10 +22,10 @@ describe Arachni::Element::Capabilities::Analyzable::Differential do
         context 'when #differential_analysis_options is' do
             context 'nil' do
                 it 'skips it' do
-                    subject.differential_analysis_options.should be_nil
+                    expect(subject.differential_analysis_options).to be_nil
                     dupped = subject.dup
-                    dupped.should == dupped
-                    dupped.differential_analysis_options.should be_nil
+                    expect(dupped).to eq(dupped)
+                    expect(dupped.differential_analysis_options).to be_nil
                 end
             end
 
@@ -36,9 +36,9 @@ describe Arachni::Element::Capabilities::Analyzable::Differential do
                     subject.differential_analysis_options = h
 
                     dupped = subject.dup
-                    dupped.should == dupped
-                    dupped.differential_analysis_options.should == h
-                    dupped.differential_analysis_options.object_id.should_not == h.object_id
+                    expect(dupped).to eq(dupped)
+                    expect(dupped.differential_analysis_options).to eq(h)
+                    expect(dupped.differential_analysis_options.object_id).not_to eq(h.object_id)
                 end
             end
         end
@@ -46,7 +46,7 @@ describe Arachni::Element::Capabilities::Analyzable::Differential do
 
     describe '#to_rpc_data' do
         it "does not include 'differential_analysis_options'" do
-            subject.to_rpc_data.should_not include 'differential_analysis_options'
+            expect(subject.to_rpc_data).not_to include 'differential_analysis_options'
         end
     end
 
@@ -64,7 +64,26 @@ describe Arachni::Element::Capabilities::Analyzable::Differential do
             let(:url) { 'http://stuff.com/' }
 
             it 'returns false' do
-                subject.differential_analysis( @opts ).should be_false
+                expect(subject.differential_analysis( @opts )).to be_falsey
+            end
+        end
+
+        context 'when the inputs are missing default values' do
+            it 'skips them' do
+                subject.inputs = {
+                    'with-value'    => 'value',
+                    'without-value' => ''
+                }
+
+                submitted = []
+
+                allow_any_instance_of(subject.class).to receive(:submit) do |instance|
+                    submitted << instance.affected_input_name
+                end
+
+                subject.differential_analysis( @opts )
+
+                expect(submitted.uniq).to eq ['with-value']
             end
         end
 
@@ -75,16 +94,16 @@ describe Arachni::Element::Capabilities::Analyzable::Differential do
                 subject.differential_analysis( @opts )
                 auditor.http.run
 
-                results = Arachni::Data.issues.flatten
-                results.should be_any
-                results.first.vector.affected_input_name.should == 'input'
+                results = Arachni::Data.issues
+                expect(results).to be_any
+                expect(results.first.vector.affected_input_name).to eq('input')
             end
 
             it 'adds remarks' do
                 subject.differential_analysis( @opts )
                 auditor.http.run
 
-                Arachni::Data.issues.first.variations.first.remarks[:differential_analysis].size.should == 3
+                expect(Arachni::Data.issues.first.remarks[:differential_analysis].size).to eq(3)
             end
         end
 
@@ -95,7 +114,7 @@ describe Arachni::Element::Capabilities::Analyzable::Differential do
                 subject.differential_analysis( @opts )
                 auditor.http.run
 
-                issues.should be_empty
+                expect(issues).to be_empty
             end
         end
 
@@ -106,14 +125,14 @@ describe Arachni::Element::Capabilities::Analyzable::Differential do
                 subject.differential_analysis( @opts.merge( submit: { timeout: 1_000 } ) )
                 auditor.http.run
 
-                issues.should be_empty
+                expect(issues).to be_empty
 
                 Arachni::Element::Capabilities::Auditable.reset
 
                 subject.differential_analysis( @opts.merge( timeout: 3_000 ) )
                 auditor.http.run
 
-                issues.should be_any
+                expect(issues).to be_any
             end
         end
 
@@ -124,7 +143,7 @@ describe Arachni::Element::Capabilities::Analyzable::Differential do
                 subject.differential_analysis( @opts )
                 auditor.http.run
 
-                issues.should be_empty
+                expect(issues).to be_empty
             end
         end
 
@@ -135,7 +154,7 @@ describe Arachni::Element::Capabilities::Analyzable::Differential do
                 subject.differential_analysis( @opts )
                 auditor.http.run
 
-                issues.should be_empty
+                expect(issues).to be_empty
             end
         end
 
@@ -146,7 +165,7 @@ describe Arachni::Element::Capabilities::Analyzable::Differential do
                 subject.differential_analysis( @opts )
                 auditor.http.run
 
-                issues.should be_empty
+                expect(issues).to be_empty
             end
         end
 
@@ -157,7 +176,7 @@ describe Arachni::Element::Capabilities::Analyzable::Differential do
                 subject.differential_analysis( @opts )
                 auditor.http.run
 
-                issues.should be_empty
+                expect(issues).to be_empty
             end
         end
 
@@ -168,10 +187,9 @@ describe Arachni::Element::Capabilities::Analyzable::Differential do
                 subject.differential_analysis( @opts )
                 auditor.http.run
 
-                issues.should be_empty
+                expect(issues).to be_empty
             end
         end
-
     end
 
 end

data/spec/arachni/element/capabilities/analyzable/{taint_spec.rb → signature_spec.rb}

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-describe Arachni::Element::Capabilities::Analyzable::Taint do
+describe Arachni::Element::Capabilities::Analyzable::Signature do
 
     before :all do
-        Arachni::Options.url = @url = web_server_url_for( :taint )
+        Arachni::Options.url = @url = web_server_url_for( :signature )
         Arachni::Options.audit.elements :links
 
         @auditor = Auditor.new( Arachni::Page.from_url( @url ), Arachni::Framework.new )
@@ -17,7 +17,7 @@ describe Arachni::Element::Capabilities::Analyzable::Taint do
         @negative.auditor.page = Arachni::Page.from_url( @url )
     end
 
-    describe '#taint_analysis' do
+    describe '#signature_analysis' do
 
         before do
             @seed = 'my_seed'
@@ -30,15 +30,15 @@ describe Arachni::Element::Capabilities::Analyzable::Taint do
                     url: 'http://stuff.com/',
                     inputs: { 'input' => '' }
                 )
-                auditable.taint_analysis( @seed ).should be_false
+                expect(auditable.signature_analysis( @seed )).to be_falsey
             end
         end
 
         context 'when called with no opts' do
             it 'uses the defaults' do
-                @positive.taint_analysis( @seed )
+                @positive.signature_analysis( @seed )
                 @auditor.http.run
-                issues.size.should == 1
+                expect(issues.size).to eq(1)
             end
         end
 
@@ -49,20 +49,20 @@ describe Arachni::Element::Capabilities::Analyzable::Taint do
                     php:     @seed,
                 }
 
-                @positive.taint_analysis( payloads, substring: @seed )
+                @positive.signature_analysis( payloads, substring: @seed )
                 @auditor.http.run
-                issues.size.should == 1
+                expect(issues.size).to eq(1)
                 issue = issues.first
-                issue.platform_name.should == :php
-                issue.platform_type.should == :languages
+                expect(issue.platform_name).to eq(:php)
+                expect(issue.platform_type).to eq(:languages)
             end
         end
 
         context 'when called against non-vulnerable input' do
             it 'does not log an issue' do
-                @negative.taint_analysis( @seed )
+                @negative.signature_analysis( @seed )
                 @auditor.http.run
-                issues.should be_empty
+                expect(issues).to be_empty
             end
         end
 
@@ -70,25 +70,25 @@ describe Arachni::Element::Capabilities::Analyzable::Taint do
             describe :regexp do
                 context String do
                     it 'tries to match the provided pattern' do
-                        @positive.taint_analysis( @seed,
+                        @positive.signature_analysis( @seed,
                                                   regexp: @seed,
                                                   format: [ Arachni::Check::Auditor::Format::STRAIGHT ]
                         )
                         @auditor.http.run
-                        issues.size.should == 1
-                        issues.first.vector.seed.should == @seed
+                        expect(issues.size).to eq(1)
+                        expect(issues.first.vector.seed).to eq(@seed)
                     end
                 end
 
                 context Array do
                     it 'tries to match the provided patterns' do
-                        @positive.taint_analysis( @seed,
+                        @positive.signature_analysis( @seed,
                                                   regexp: [@seed],
                                                   format: [ Arachni::Check::Auditor::Format::STRAIGHT ]
                         )
                         @auditor.http.run
-                        issues.size.should == 1
-                        issues.first.vector.seed.should == @seed
+                        expect(issues.size).to eq(1)
+                        expect(issues.first.vector.seed).to eq(@seed)
                     end
                 end
 
@@ -99,7 +99,7 @@ describe Arachni::Element::Capabilities::Analyzable::Taint do
                             php:     /#{@seed} p.*/,
                         }
 
-                        @positive.taint_analysis(
+                        @positive.signature_analysis(
                             "#{@seed} windows",
                             regexp: regexps.dup,
                             format: [ Arachni::Check::Auditor::Format::STRAIGHT ]
@@ -107,9 +107,9 @@ describe Arachni::Element::Capabilities::Analyzable::Taint do
 
                         @auditor.http.run
 
-                        issues.size.should == 1
-                        issues[0].platform_name.should == :windows
-                        issues[0].signature.should == regexps[:windows].source
+                        expect(issues.size).to eq(1)
+                        expect(issues[0].platform_name).to eq(:windows)
+                        expect(issues[0].signature).to eq(regexps[:windows].source)
                     end
 
                     context 'when the payloads are per platform' do
@@ -134,7 +134,7 @@ describe Arachni::Element::Capabilities::Analyzable::Taint do
                                 asp:     /#{@seed}/
                             }
 
-                            @positive.taint_analysis(
+                            @positive.signature_analysis(
                                 payloads.dup,
                                 regexp: regexps.dup,
                                 format: [ Arachni::Check::Auditor::Format::STRAIGHT ]
@@ -142,13 +142,13 @@ describe Arachni::Element::Capabilities::Analyzable::Taint do
 
                             @auditor.http.run
 
-                            issues.size.should == 3
+                            expect(issues.size).to eq(3)
                             payloads.keys.each do |platform|
                                 issue = issues.find{ |i| i.platform_name == platform }
 
-                                issue.vector.seed.should == payloads[platform]
-                                issue.platform_name.should == platform
-                                issue.signature.should == regexps[platform].source
+                                expect(issue.vector.seed).to eq(payloads[platform])
+                                expect(issue.platform_name).to eq(platform)
+                                expect(issue.signature).to eq(regexps[platform].source)
                             end
                         end
 
@@ -165,7 +165,7 @@ describe Arachni::Element::Capabilities::Analyzable::Taint do
                                     asp: /#{@seed}/
                                 }
 
-                                @positive.taint_analysis(
+                                @positive.signature_analysis(
                                     payloads.dup,
                                     regexp: regexps.dup,
                                     format: [ Arachni::Check::Auditor::Format::STRAIGHT ]
@@ -173,11 +173,11 @@ describe Arachni::Element::Capabilities::Analyzable::Taint do
 
                                 @auditor.http.run
 
-                                issues.size.should == 1
+                                expect(issues.size).to eq(1)
                                 issue = issues.first
 
-                                issue.platform_name.should == :asp
-                                issue.signature.should == regexps[:asp].source
+                                expect(issue.platform_name).to eq(:asp)
+                                expect(issue.signature).to eq(regexps[:asp].source)
                             end
                         end
                     end
@@ -185,12 +185,12 @@ describe Arachni::Element::Capabilities::Analyzable::Taint do
 
                 context 'when the page matches the regexp even before we audit it' do
                     it 'does not log an issue' do
-                        @positive.taint_analysis( 'Inject here',
+                        @positive.signature_analysis( 'Inject here',
                             regexp: 'Inject he[er]',
                             format: [ Arachni::Check::Auditor::Format::STRAIGHT ]
                         )
                         @auditor.http.run
-                        issues.should be_empty
+                        expect(issues).to be_empty
                     end
                 end
             end
@@ -198,27 +198,27 @@ describe Arachni::Element::Capabilities::Analyzable::Taint do
             describe :substring do
                 context String do
                     it 'tries to match the provided pattern' do
-                        @positive.taint_analysis( @seed,
+                        @positive.signature_analysis( @seed,
                                                   substring: @seed,
                                                   format: [ Arachni::Check::Auditor::Format::STRAIGHT ]
                         )
                         @auditor.http.run
-                        issues.size.should == 1
-                        issues.first.vector.seed.should == @seed
-                        issues.first.should be_trusted
+                        expect(issues.size).to eq(1)
+                        expect(issues.first.vector.seed).to eq(@seed)
+                        expect(issues.first).to be_trusted
                     end
                 end
 
                 context Array do
                     it 'tries to match the provided patterns' do
-                        @positive.taint_analysis( @seed,
+                        @positive.signature_analysis( @seed,
                                                   substring: [@seed],
                                                   format: [ Arachni::Check::Auditor::Format::STRAIGHT ]
                         )
                         @auditor.http.run
-                        issues.size.should == 1
-                        issues.first.vector.seed.should == @seed
-                        issues.first.should be_trusted
+                        expect(issues.size).to eq(1)
+                        expect(issues.first.vector.seed).to eq(@seed)
+                        expect(issues.first).to be_trusted
                     end
                 end
 
@@ -229,7 +229,7 @@ describe Arachni::Element::Capabilities::Analyzable::Taint do
                             php:     "#{@seed} p",
                         }
 
-                        @positive.taint_analysis(
+                        @positive.signature_analysis(
                             "#{@seed} windows",
                             substring: substrings.dup,
                             format: [ Arachni::Check::Auditor::Format::STRAIGHT ]
@@ -237,10 +237,10 @@ describe Arachni::Element::Capabilities::Analyzable::Taint do
 
                         @auditor.http.run
 
-                        issues.size.should == 1
-                        issues[0].platform_name.should == :windows
-                        issues[0].signature.should == substrings[:windows].to_s
-                        issues[0].should be_trusted
+                        expect(issues.size).to eq(1)
+                        expect(issues[0].platform_name).to eq(:windows)
+                        expect(issues[0].signature).to eq(substrings[:windows].to_s)
+                        expect(issues[0]).to be_trusted
                     end
 
                     context 'when the payloads are per platform' do
@@ -265,7 +265,7 @@ describe Arachni::Element::Capabilities::Analyzable::Taint do
                                 asp:     @seed
                             }
 
-                            @positive.taint_analysis(
+                            @positive.signature_analysis(
                                 payloads.dup,
                                 substring: substrings.dup,
                                 format: [ Arachni::Check::Auditor::Format::STRAIGHT ]
@@ -273,14 +273,14 @@ describe Arachni::Element::Capabilities::Analyzable::Taint do
 
                             @auditor.http.run
 
-                            issues.size.should == 3
+                            expect(issues.size).to eq(3)
                             payloads.keys.each do |platform|
                                 issue = issues.find{ |i| i.platform_name == platform }
 
-                                issue.vector.seed.should == payloads[platform]
-                                issue.platform_name.should == platform
-                                issue.signature.should == substrings[platform].to_s
-                                issue.should be_trusted
+                                expect(issue.vector.seed).to eq(payloads[platform])
+                                expect(issue.platform_name).to eq(platform)
+                                expect(issue.signature).to eq(substrings[platform].to_s)
+                                expect(issue).to be_trusted
                             end
                         end
                     end
@@ -288,12 +288,12 @@ describe Arachni::Element::Capabilities::Analyzable::Taint do
 
                 context 'when the page includes the substring even before we audit it' do
                     it 'does not log any issues' do
-                        @positive.taint_analysis( 'Inject here',
+                        @positive.signature_analysis( 'Inject here',
                             regexp: 'Inject here',
                             format: [ Arachni::Check::Auditor::Format::STRAIGHT ]
                         )
                         @auditor.http.run
-                        issues.should be_empty
+                        expect(issues).to be_empty
                     end
                 end
 
@@ -310,7 +310,7 @@ describe Arachni::Element::Capabilities::Analyzable::Taint do
                             asp: @seed
                         }
 
-                        @positive.taint_analysis(
+                        @positive.signature_analysis(
                             payloads.dup,
                             substring: substrings.dup,
                             format: [ Arachni::Check::Auditor::Format::STRAIGHT ]
@@ -318,37 +318,37 @@ describe Arachni::Element::Capabilities::Analyzable::Taint do
 
                         @auditor.http.run
 
-                        issues.size.should == 1
+                        expect(issues.size).to eq(1)
                         issue = issues.first
 
-                        issue.platform_name.should == :asp
-                        issue.signature.should == substrings[:asp].to_s
-                        issue.should be_trusted
+                        expect(issue.platform_name).to eq(:asp)
+                        expect(issue.signature).to eq(substrings[:asp].to_s)
+                        expect(issue).to be_trusted
                     end
                 end
             end
 
             describe :ignore do
                 it 'ignores matches whose response also matches the ignore patterns' do
-                    @positive.taint_analysis( @seed,
+                    @positive.signature_analysis( @seed,
                         substring: @seed,
                         format: [ Arachni::Check::Auditor::Format::STRAIGHT ],
                         ignore: @seed
                     )
                     @auditor.http.run
-                    issues.should be_empty
+                    expect(issues).to be_empty
                 end
             end
 
             describe :longest_word_optimization do
                 it 'optimizes the pattern matching process by first matching against the largest word in the regexp' do
-                    @positive.taint_analysis(
+                    @positive.signature_analysis(
                         @seed,
                         regexp: @seed,
                         longest_word_optimization: true
                     )
                     @auditor.http.run
-                    issues.should be_any
+                    expect(issues).to be_any
                 end
             end
         end