arachni 1.2.1 → 1.3

data/spec/arachni/plugin/base_spec.rb

@@ -20,13 +20,13 @@ describe Arachni::Plugin::Base do
 
     describe '.distributable?' do
         it 'returns false' do
-            described_class.should_not be_distributable
+            expect(described_class).not_to be_distributable
         end
 
         context 'when the distributable flag has been set' do
             it 'returns true' do
                 described_class.distributable
-                described_class.should be_distributable
+                expect(described_class).to be_distributable
             end
         end
     end
@@ -34,31 +34,31 @@ describe Arachni::Plugin::Base do
     describe '.is_distributable' do
         it 'sets the distributable? flag' do
             described_class.is_distributable
-            described_class.should be_distributable
+            expect(described_class).to be_distributable
         end
     end
 
     describe '#info' do
         it 'returns .info' do
-            subject.info.should == described_class.info
+            expect(subject.info).to eq(described_class.info)
         end
     end
 
     describe '#session' do
         it "returns #{Arachni::Framework}#session" do
-            subject.session.should == framework.session
+            expect(subject.session).to eq(framework.session)
         end
     end
 
     describe '#http' do
         it "returns #{Arachni::Framework}#http" do
-            subject.http.should == framework.http
+            expect(subject.http).to eq(framework.http)
         end
     end
 
     describe '#framework_pause' do
         it 'pauses the framework' do
-            framework.should receive(:pause)
+            expect(framework).to receive(:pause)
             subject.framework_pause
         end
     end
@@ -69,14 +69,14 @@ describe Arachni::Plugin::Base do
 
             subject.framework_pause
 
-            framework.should receive(:resume)
+            expect(framework).to receive(:resume)
             subject.framework_resume
         end
     end
 
     describe '#wait_while_framework_running' do
         it 'blocks while the framework runs' do
-            framework.should be_running
+            expect(framework).to be_running
 
             q = Queue.new
             Thread.new do
@@ -90,7 +90,7 @@ describe Arachni::Plugin::Base do
                 q.pop
             end
 
-            framework.should_not be_running
+            expect(framework).not_to be_running
         end
     end
 

data/spec/arachni/plugin/manager_spec.rb

@@ -29,18 +29,18 @@ describe Arachni::Plugin::Manager do
         let(:state) { Arachni::State.plugins.runtime }
 
         it 'stores plugin options' do
-            state[:suspendable][:options].should == {
+            expect(state[:suspendable][:options]).to eq({
                 my_option: 'updated'
-            }
+            })
         end
 
         it 'stores plugin state' do
-            state.should include :suspendable
-            state[:suspendable][:data].should == 1
+            expect(state).to include :suspendable
+            expect(state[:suspendable][:data]).to eq(1)
         end
 
         it 'kills the running plugins' do
-            subject.jobs.should be_empty
+            expect(subject.jobs).to be_empty
         end
     end
 
@@ -63,45 +63,45 @@ describe Arachni::Plugin::Manager do
         it 'restores plugin options' do
             subject.restore
 
-            subject.jobs[:suspendable][:instance].options.should == {
+            expect(subject.jobs[:suspendable][:instance].options).to eq({
                 my_option: 'updated'
-            }
+            })
         end
 
         it 'restores plugin state' do
             subject.restore
-            subject.jobs[:suspendable][:instance].counter.should == 2
+            expect(subject.jobs[:suspendable][:instance].counter).to eq(2)
         end
 
         context 'when a loaded plugin has no associated state' do
             it "calls #{Arachni::Plugin::Base}#prepare instead of #{Arachni::Plugin::Base}#restore" do
                 subject.state.delete :suspendable
                 subject.restore
-                subject.jobs[:suspendable][:instance].counter.should == 1
+                expect(subject.jobs[:suspendable][:instance].counter).to eq(1)
             end
         end
     end
 
     describe '#load_default' do
         it 'loads default plugins' do
-            subject.should be_empty
+            expect(subject).to be_empty
             subject.load_default
-            subject.include?( 'default' ).should be_true
+            expect(subject.include?( 'default' )).to be_truthy
             subject.clear
         end
         it 'aliased to #load_defaults' do
-            subject.should be_empty
+            expect(subject).to be_empty
             subject.load_defaults
-            subject.include?( 'default' ).should be_true
+            expect(subject.include?( 'default' )).to be_truthy
         end
     end
 
     describe '#default' do
         it 'returns the default plugins' do
-            subject.default.include?( 'default' ).should be_true
+            expect(subject.default.include?( 'default' )).to be_truthy
         end
         it 'aliased to #defaults' do
-            subject.defaults.include?( 'default' ).should be_true
+            expect(subject.defaults.include?( 'default' )).to be_truthy
         end
     end
 
@@ -110,18 +110,18 @@ describe Arachni::Plugin::Manager do
             subject.load_default
             subject.run
             subject.block
-            subject.results[:default][:results].should be_true
+            expect(subject.results[:default][:results]).to be_truthy
         end
     end
 
     describe '#schedule' do
         it 'returns scheduled plugins' do
             subject.load_default
-            subject.schedule.should == {
+            expect(subject.schedule).to eq({
                 default: {
                     int_opt: 4
                 }
-            }
+            })
         end
 
         context 'when plugins have :priority' do
@@ -137,10 +137,10 @@ describe Arachni::Plugin::Manager do
             it 'orders them based on priority' do
                 subject.load '*'
                 scheduled = subject.schedule.keys
-                scheduled[0..1].sort.should == [:p0, :p00].sort
-                scheduled[2].should == :p1
-                scheduled[3..5].sort.should == [:p22, :p222, :p2].sort
-                scheduled[6..7].sort.should == [:p_nil, :p_nil2].sort
+                expect(scheduled[0..1].sort).to eq([:p0, :p00].sort)
+                expect(scheduled[2]).to eq(:p1)
+                expect(scheduled[3..5].sort).to eq([:p22, :p222, :p2].sort)
+                expect(scheduled[6..7].sort).to eq([:p_nil, :p_nil2].sort)
             end
         end
 
@@ -155,12 +155,12 @@ describe Arachni::Plugin::Manager do
     describe '#sane_env?' do
         context 'when gem dependencies are met' do
             it 'returns true' do
-                subject.sane_env?( subject['default'] ).should == true
+                expect(subject.sane_env?( subject['default'] )).to eq(true)
             end
         end
         context 'when gem dependencies are not met' do
             it 'returns a hash with errors' do
-                subject.sane_env?( subject['bad'] ).include?( :gem_errors ).should be_true
+                expect(subject.sane_env?( subject['bad'] ).include?( :gem_errors )).to be_truthy
                 subject.delete( 'bad' )
             end
         end
@@ -168,7 +168,7 @@ describe Arachni::Plugin::Manager do
 
     describe '#create' do
         it 'returns a plugin instance' do
-            subject.create( 'default' ).instance_of?( subject['default'] ).should be_true
+            expect(subject.create( 'default' ).instance_of?( subject['default'] )).to be_truthy
         end
     end
 
@@ -177,7 +177,7 @@ describe Arachni::Plugin::Manager do
             it 'returns true' do
                 subject.load :wait
                 subject.run
-                subject.busy?.should be_true
+                expect(subject.busy?).to be_truthy
                 framework.state.running = false
                 subject.block
             end
@@ -186,7 +186,7 @@ describe Arachni::Plugin::Manager do
             it 'returns false' do
                 subject.run
                 subject.block
-                subject.busy?.should be_false
+                expect(subject.busy?).to be_falsey
             end
         end
     end
@@ -195,7 +195,7 @@ describe Arachni::Plugin::Manager do
         context 'when plugins are running' do
             it 'returns the names of the running plugins' do
                 subject.run
-                subject.job_names.should == subject.keys
+                expect(subject.job_names).to eq(subject.keys)
                 subject.block
             end
         end
@@ -203,7 +203,7 @@ describe Arachni::Plugin::Manager do
             it 'returns an empty array' do
                 subject.run
                 subject.block
-                subject.job_names.should be_empty
+                expect(subject.job_names).to be_empty
             end
         end
     end
@@ -213,7 +213,7 @@ describe Arachni::Plugin::Manager do
             it 'returns the plugins threads' do
                 subject.load :wait
                 subject.run
-                subject.jobs[:wait].should be_instance_of Thread
+                expect(subject.jobs[:wait]).to be_instance_of Thread
 
                 framework.state.running = false
 
@@ -227,7 +227,7 @@ describe Arachni::Plugin::Manager do
                 framework.state.running = false
 
                 subject.block
-                subject.jobs.should be_empty
+                expect(subject.jobs).to be_empty
             end
         end
     end
@@ -240,7 +240,7 @@ describe Arachni::Plugin::Manager do
                 ret = subject.kill( 'loop' )
                 subject.block
 
-                ret.should be_true
+                expect(ret).to be_truthy
                 subject.delete( 'loop' )
             end
         end
@@ -249,31 +249,32 @@ describe Arachni::Plugin::Manager do
             it 'returns false' do
                 subject.run
                 subject.block
-                subject.kill( 'default' ).should be_false
+                expect(subject.kill( 'default' )).to be_falsey
             end
         end
     end
 
     describe '#results' do
         it "delegates to ##{Arachni::Data::Plugins}#results" do
-            Arachni::Data.plugins.results.object_id.should ==
+            expect(Arachni::Data.plugins.results.object_id).to eq(
                 subject.results.object_id
+            )
         end
     end
 
     describe '#reset' do
         it 'calls #kill' do
-            subject.should receive(:killall).at_least(1).times
+            expect(subject).to receive(:killall).at_least(1).times
             subject.reset
         end
 
         it 'calls #clear' do
-            subject.should receive(:clear).at_least(1).times
+            expect(subject).to receive(:clear).at_least(1).times
             subject.reset
         end
 
         it 'calls .reset' do
-            described_class.should receive(:reset).at_least(1).times
+            expect(described_class).to receive(:reset).at_least(1).times
             subject.reset
         end
     end

data/spec/arachni/report_spec.rb

@@ -23,7 +23,7 @@ describe Arachni::Report do
         cloned = Arachni::RPC::Serializer.deep_clone( report )
         cloned.options.delete :input
 
-        report.should == cloned
+        expect(report).to eq(cloned)
     end
 
     describe '#to_rpc_data' do
@@ -32,13 +32,14 @@ describe Arachni::Report do
 
         %w(sitemap version).each do |attribute|
             it "includes '#{attribute}'" do
-                data[attribute].should == subject.send( attribute )
+                expect(data[attribute]).to eq(subject.send( attribute ))
             end
         end
 
         it "includes 'options'" do
-            data['options'].should ==
+            expect(data['options']).to eq(
                 Arachni::Options.update( subject.options ).to_rpc_data
+            )
         end
 
         it "includes 'plugins'" do
@@ -48,17 +49,17 @@ describe Arachni::Report do
             info_1 = data['plugins'].each { |name, d| d.delete :options }
             info_2 = subject.plugins.each { |name, d| d.delete :options }
 
-            info_1.should == info_2
-            options_1.should == options_2
+            expect(info_1).to eq(info_2)
+            expect(options_1).to eq(options_2)
         end
 
         it "includes 'issues'" do
-            data['issues'].should == subject.issues.map(&:to_rpc_data)
+            expect(data['issues']).to eq(subject.issues.map(&:to_rpc_data))
         end
 
         %w(start_datetime finish_datetime).each do |attribute|
             it "includes '#{attribute}'" do
-                data[attribute].should == subject.send( attribute ).to_s
+                expect(data[attribute]).to eq(subject.send( attribute ).to_s)
             end
         end
     end
@@ -71,7 +72,7 @@ describe Arachni::Report do
 
         %w(sitemap issues plugins version).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
 
@@ -79,32 +80,32 @@ describe Arachni::Report do
             restored.options.delete :input
             subject.options.delete :input
 
-            restored.options.should == subject.options
+            expect(restored.options).to eq(subject.options)
         end
 
         %w(start_datetime finish_datetime).each do |attribute|
             it "restores '#{attribute}'" do
-                restored.send( attribute ).should be_kind_of Time
-                restored.send( attribute ).to_s.should == subject.send( attribute ).to_s
+                expect(restored.send( attribute )).to be_kind_of Time
+                expect(restored.send( attribute ).to_s).to eq(subject.send( attribute ).to_s)
             end
         end
     end
 
     describe '#version' do
         it 'returns the version number' do
-            report.version.should == Arachni::VERSION
+            expect(report.version).to eq(Arachni::VERSION)
         end
     end
 
     describe '#url' do
         it 'returns the targeted URL' do
-            report.url.should == report.options[:url]
+            expect(report.url).to eq(report.options[:url])
         end
     end
 
     describe '#options' do
         it 'returns Arachni::Options as a hash' do
-           report.options.should == Arachni::Options.to_hash
+           expect(report.options).to eq(Arachni::Options.to_hash)
         end
 
         it 'defaults to Arachni::Options#to_hash' do
@@ -114,26 +115,26 @@ describe Arachni::Report do
             new.delete :input
             hash.delete :input
 
-            new.should == hash
+            expect(new).to eq(hash)
         end
     end
 
     describe '#sitemap' do
         it 'returns the sitemap' do
-            report.sitemap.should == {@opts.url.to_s => 200}
+            expect(report.sitemap).to eq({@opts.url.to_s => 200})
         end
     end
 
     describe '#issues' do
         it 'returns the issues' do
             issues = [Factory[:issue]]
-            described_class.new( issues: issues ).issues.should == issues
+            expect(described_class.new( issues: issues ).issues).to eq(issues)
         end
     end
 
     describe '#issue_by_check' do
         it 'returns issue logged by the given check' do
-            report.issues.should be_any
+            expect(report.issues).to be_any
 
             report.issues.first.check[:shortname] << 'stuff'
 
@@ -141,63 +142,64 @@ describe Arachni::Report do
 
             filtered_issues = report.issues_by_check( check )
             filtered_issues.each do |issue|
-                issue.check[:shortname].should == check
+                expect(issue.check[:shortname]).to eq(check)
             end
 
-            report.issues.size.should > filtered_issues.size
+            expect(report.issues.size).to be > filtered_issues.size
         end
     end
 
     describe '#issue_by_digest' do
         it 'returns an issue based on its digest' do
-            report.issues.should be_any
+            expect(report.issues).to be_any
 
             report.issues.each do |issue|
-                report.issue_by_digest( issue.digest ).should == issue
+                expect(report.issue_by_digest( issue.digest )).to eq(issue)
             end
         end
     end
 
     describe '#plugins' do
         it 'returns the plugin results' do
-            report.plugins.should == Factory[:report_data][:plugins]
+            expect(report.plugins).to eq(Factory[:report_data][:plugins])
         end
     end
 
     describe '#start_datetime' do
         it 'returns a Time object' do
-            report.start_datetime.should be_kind_of Time
+            expect(report.start_datetime).to be_kind_of Time
         end
         context 'when no start datetime info has been provided' do
             it 'falls-back to Time.now' do
-                report_empty.start_datetime.should be_kind_of Time
+                expect(report_empty.start_datetime).to be_kind_of Time
             end
         end
     end
 
     describe '#finish_datetime' do
         it 'returns a Time object' do
-            report.finish_datetime.should be_kind_of Time
+            expect(report.finish_datetime).to be_kind_of Time
         end
         it 'returns the start finish of the scan' do
-            report.finish_datetime.to_s.should ==
+            expect(report.finish_datetime.to_s).to eq(
                 Factory[:report_data][:finish_datetime].to_s
+            )
         end
         context 'when no start datetime info has been provided' do
             it 'falls-back to Time.now' do
-                report_empty.finish_datetime.should be_kind_of Time
+                expect(report_empty.finish_datetime).to be_kind_of Time
             end
         end
     end
 
     describe '#delta_time' do
         it 'returns the time difference between start and finish time' do
-            report.delta_time.should == '02:46:40'
+            expect(report.delta_time).to eq('02:46:40')
         end
         context 'when no #finish_datetime has been provided' do
             it 'uses Time.now for the calculation' do
                 report_empty.start_datetime = Time.now - 2000
-                report_empty.delta_time.to_s.should == '00:33:19'
+                expect(report_empty.delta_time.to_s).to eq('00:33:19')
             end
         end
     end
@@ -205,8 +207,9 @@ describe Arachni::Report do
     describe '.read_summary' do
         it 'returns summary' do
             @report_file = report.save
-            described_class.read_summary( @report_file ).should ==
+            expect(described_class.read_summary( @report_file )).to eq(
                 Arachni::RPC::Serializer.load( Arachni::RPC::Serializer.dump( report.summary ) )
+            )
         end
     end
 
@@ -214,7 +217,7 @@ describe Arachni::Report do
         it 'dumps the object to a file' do
             @report_file = report.save
 
-            described_class.load( @report_file ).should == report
+            expect(described_class.load( @report_file )).to eq(report)
         end
 
         context 'when given a location' do
@@ -223,7 +226,7 @@ describe Arachni::Report do
                     @report_file = 'report'
                     report.save( @report_file )
 
-                    described_class.load( @report_file ).should == report
+                    expect(described_class.load( @report_file )).to eq(report)
                 end
             end
 
@@ -232,7 +235,7 @@ describe Arachni::Report do
                     directory = Dir.tmpdir
                     @report_file = report.save( directory )
 
-                    described_class.load( @report_file ).should == report
+                    expect(described_class.load( @report_file )).to eq(report)
                 end
             end
         end
@@ -242,13 +245,13 @@ describe Arachni::Report do
         it 'returns the object in AFR format' do
             @report_file = report.save
 
-            IO.binread( @report_file ).should == report.to_afr
+            expect(IO.binread( @report_file )).to eq(report.to_afr)
         end
     end
 
     describe '#to_h' do
         it 'returns the object as a hash' do
-            report.to_h.should == {
+            expect(report.to_h).to eq({
                 version:         report.version,
                 options:         Arachni::Options.hash_to_rpc_data( report.options ),
                 sitemap:         report.sitemap,
@@ -272,27 +275,27 @@ describe Arachni::Report do
                         ]
                     }
                 }
-            }
+            })
         end
     end
 
     describe '#to_hash' do
         it 'alias of #to_h' do
-            report.to_h.should == report.to_hash
+            expect(report.to_h).to eq(report.to_hash)
         end
     end
 
     describe '#==' do
         context 'when the reports are equal' do
             it 'returns true' do
-                report.deep_clone.should == report
+                expect(report.deep_clone).to eq(report)
             end
         end
         context 'when the reports are not equal' do
             it 'returns false' do
                 a = report.deep_clone
                 a.options[:url] = 'http://stuff/'
-                a.should_not == report
+                expect(a).not_to eq(report)
             end
         end
     end