arachni 1.2.1 → 1.3

data/spec/arachni/support/database/queue_spec.rb

@@ -36,12 +36,12 @@ describe Arachni::Support::Database::Queue do
         consumed = []
         consumed << poped.pop while !poped.empty?
 
-        consumed.sort.should == (0...entries).map { |i| 'a' * i }
+        expect(consumed.sort).to eq((0...entries).map { |i| 'a' * i })
     end
 
     describe "#{described_class}::DEFAULT_MAX_BUFFER_SIZE" do
         it 'returns 100' do
-            described_class::DEFAULT_MAX_BUFFER_SIZE.should == 100
+            expect(described_class::DEFAULT_MAX_BUFFER_SIZE).to eq(100)
         end
     end
 
@@ -50,7 +50,7 @@ describe Arachni::Support::Database::Queue do
             subject << 1
             subject << 2
 
-            subject.buffer.should == [1, 2]
+            expect(subject.buffer).to eq([1, 2])
         end
     end
 
@@ -60,9 +60,9 @@ describe Arachni::Support::Database::Queue do
             subject << 1
             subject << 2
 
-            subject.disk.size.should == 2
+            expect(subject.disk.size).to eq(2)
             subject.disk.each do |path|
-                File.exists?( path ).should be_true
+                expect(File.exists?( path )).to be_truthy
             end
         end
     end
@@ -70,7 +70,7 @@ describe Arachni::Support::Database::Queue do
     describe '#max_buffer_size' do
         context 'by default' do
             it "returns #{described_class}::DEFAULT_MAX_BUFFER_SIZE" do
-                subject.max_buffer_size.should == described_class::DEFAULT_MAX_BUFFER_SIZE
+                expect(subject.max_buffer_size).to eq(described_class::DEFAULT_MAX_BUFFER_SIZE)
             end
         end
     end
@@ -78,21 +78,21 @@ describe Arachni::Support::Database::Queue do
     describe '#max_buffer_size=' do
         it 'sets #max_buffer_size' do
             subject.max_buffer_size = 10
-            subject.max_buffer_size.should == 10
+            expect(subject.max_buffer_size).to eq(10)
         end
     end
 
     describe '#empty?' do
         context 'when the queue is empty' do
             it 'returns true' do
-                subject.empty?.should be_true
+                expect(subject.empty?).to be_truthy
             end
         end
 
         context 'when the queue is not empty' do
             it 'returns false' do
                 subject << :stuff
-                subject.empty?.should be_false
+                expect(subject.empty?).to be_falsey
             end
         end
     end
@@ -104,7 +104,7 @@ describe Arachni::Support::Database::Queue do
             end
 
             sample_size.times do |i|
-                subject.pop.should == "stuff #{i}"
+                expect(subject.pop).to eq("stuff #{i}")
             end
         end
     end
@@ -112,14 +112,14 @@ describe Arachni::Support::Database::Queue do
     describe '#push' do
         it 'pushes an object' do
             subject.push :stuff
-            subject.pop.should == :stuff
+            expect(subject.pop).to eq(:stuff)
         end
     end
 
     describe '#enq' do
         it 'pushes an object' do
             subject.enq :stuff
-            subject.pop.should == :stuff
+            expect(subject.pop).to eq(:stuff)
         end
     end
 
@@ -130,7 +130,7 @@ describe Arachni::Support::Database::Queue do
             end
 
             sample_size.times do |i|
-                subject.pop.should == "stuff #{i}"
+                expect(subject.pop).to eq("stuff #{i}")
             end
         end
 
@@ -142,76 +142,76 @@ describe Arachni::Support::Database::Queue do
             Thread.new { subject << :stuff }
             t.join
 
-            val.should == :stuff
+            expect(val).to eq(:stuff)
         end
     end
 
     describe '#deq' do
         it 'removes an object' do
             subject << :stuff
-            subject.deq.should == :stuff
+            expect(subject.deq).to eq(:stuff)
         end
     end
 
     describe '#shift' do
         it 'removes an object' do
             subject << :stuff
-            subject.shift.should == :stuff
+            expect(subject.shift).to eq(:stuff)
         end
     end
 
     describe '#size' do
         it 'returns the size of the queue' do
             sample_size.times { |i| subject << i }
-            subject.size.should == sample_size
+            expect(subject.size).to eq(sample_size)
         end
     end
 
     describe '#free_buffer_size' do
         it 'returns the size of the available buffer' do
             (subject.max_buffer_size - 2).times { |i| subject << i }
-            subject.free_buffer_size.should == 2
+            expect(subject.free_buffer_size).to eq(2)
         end
     end
 
     describe '#buffer_size' do
         it 'returns the size of the in-memory entries' do
-            subject.buffer_size.should == 0
+            expect(subject.buffer_size).to eq(0)
 
             (subject.max_buffer_size - 1).times { |i| subject << i }
-            subject.buffer_size.should == subject.max_buffer_size - 1
+            expect(subject.buffer_size).to eq(subject.max_buffer_size - 1)
 
             subject.clear
 
             sample_size.times { |i| subject << i }
-            subject.buffer_size.should == subject.max_buffer_size
+            expect(subject.buffer_size).to eq(subject.max_buffer_size)
         end
     end
 
     describe '#disk_size' do
         it 'returns the size of the disk entries' do
-            subject.buffer_size.should == 0
+            expect(subject.buffer_size).to eq(0)
 
             (subject.max_buffer_size + 1).times { |i| subject << i }
-            subject.disk_size.should == 1
+            expect(subject.disk_size).to eq(1)
 
             subject.clear
 
             sample_size.times { |i| subject << i }
-            subject.disk_size.should == sample_size - subject.max_buffer_size
+            expect(subject.disk_size).to eq(sample_size - subject.max_buffer_size)
         end
     end
 
     describe '#num_waiting' do
         it 'returns the amount of threads waiting to pop' do
-            subject.num_waiting.should == 0
+            expect(subject.num_waiting).to eq(0)
 
             2.times do
                 Thread.new { subject.pop }
             end
             sleep 0.1
 
-            subject.num_waiting.should == 2
+            expect(subject.num_waiting).to eq(2)
         end
     end
 
@@ -219,7 +219,7 @@ describe Arachni::Support::Database::Queue do
         it 'empties the queue' do
             sample_size.times { |i| subject << i }
             subject.clear
-            subject.size.should == 0
+            expect(subject.size).to eq(0)
         end
     end
 

data/spec/arachni/support/lookup/hash_set_spec.rb

@@ -11,8 +11,8 @@ describe Arachni::Support::LookUp::HashSet do
             new     << 'test2'
 
             subject.merge new
-            subject.should include 'test'
-            subject.should include 'test2'
+            expect(subject).to include 'test'
+            expect(subject).to include 'test2'
         end
     end
 
@@ -24,8 +24,8 @@ describe Arachni::Support::LookUp::HashSet do
             new     << 'test2'
 
             subject.replace new
-            subject.should include 'test2'
-            subject.should_not include 'test'
+            expect(subject).to include 'test2'
+            expect(subject).not_to include 'test'
         end
     end
 
@@ -42,13 +42,13 @@ describe Arachni::Support::LookUp::HashSet do
 
         context 'when the set is a superset of another set' do
             it 'returns true' do
-                new.should be_superset subject
+                expect(new).to be_superset subject
             end
         end
 
         context 'when the set is not a superset of another set' do
             it 'returns true' do
-                subject.should be_superset new
+                expect(subject).to be_superset new
             end
         end
     end
@@ -66,13 +66,13 @@ describe Arachni::Support::LookUp::HashSet do
 
         context 'when the set is a subset of another set' do
             it 'returns true' do
-                subject.should be_subset new
+                expect(subject).to be_subset new
             end
         end
 
         context 'when the set is not a subset of another set' do
             it 'returns true' do
-                new.should be_subset subject
+                expect(new).to be_subset subject
             end
         end
     end

data/spec/arachni/support/lookup/moolb_spec.rb

@@ -17,10 +17,10 @@ describe Arachni::Support::LookUp::Moolb do
                     lu << i
                 end
 
-                lu.include?( 0 ).should be_false
+                expect(lu.include?( 0 )).to be_falsey
 
                 1.upto( 3 ) do |i|
-                    lu.include?( i ).should be_true
+                    expect(lu.include?( i )).to be_truthy
                 end
             end
         end
@@ -34,7 +34,7 @@ describe Arachni::Support::LookUp::Moolb do
                     lu << i
                 end
 
-                lu.size.should == 3
+                expect(lu.size).to eq(3)
             end
         end
     end

data/spec/arachni/support/mixins/observable_spec.rb

@@ -23,11 +23,11 @@ describe Arachni::Support::Mixins::Observable do
             subject.my_event { called = true }
             subject.notify :my_event
 
-            called.should be_true
+            expect(called).to be_truthy
         end
 
         it 'returns self' do
-            subject.my_event { }.should == subject
+            expect(subject.my_event { }).to eq(subject)
         end
 
         context 'when no block is given' do
@@ -46,7 +46,7 @@ describe Arachni::Support::Mixins::Observable do
                 end
                 subject.notify :my_other_event, sent_args
 
-                received_args.should == sent_args
+                expect(received_args).to eq(sent_args)
             end
         end
 
@@ -60,7 +60,7 @@ describe Arachni::Support::Mixins::Observable do
     describe '#notify' do
         it 'returns nil' do
             subject.my_event { }
-            subject.notify( :my_event ).should be_nil
+            expect(subject.notify( :my_event )).to be_nil
         end
 
         context 'when a callback raises an exception' do
@@ -73,7 +73,7 @@ describe Arachni::Support::Mixins::Observable do
 
                 subject.notify( :my_event )
 
-                called.should == [1, 2, 3]
+                expect(called).to eq([1, 2, 3])
             end
         end
     end
@@ -87,7 +87,7 @@ describe Arachni::Support::Mixins::Observable do
 
             subject.notify :my_event
 
-            called.should be_false
+            expect(called).to be_falsey
 
         end
     end

data/spec/arachni/support/signature_spec.rb

@@ -26,19 +26,19 @@ describe Arachni::Support::Signature do
 
                     s  = described_class.new( seed1, threshold: 0.01 )
                     s1 = described_class.new( seed2 )
-                    s.should_not be_similar s1
+                    expect(s).not_to be_similar s1
 
                     s  = described_class.new( seed1, threshold: 0.1 )
                     s1 = described_class.new( seed2 )
-                    s.should_not be_similar s1
+                    expect(s).not_to be_similar s1
 
                     s  = described_class.new( seed1, threshold: 0.7 )
                     s1 = described_class.new( seed2 )
-                    s.should be_similar s1
+                    expect(s).to be_similar s1
 
                     s  = described_class.new( seed1, threshold: 1 )
                     s1 = described_class.new( seed2 )
-                    s.should be_similar s1
+                    expect(s).to be_similar s1
                 end
 
                 context 'when not a number' do
@@ -54,7 +54,7 @@ describe Arachni::Support::Signature do
 
     describe '#refine' do
         it 'removes noise from the signature' do
-            string_with_noise.should_not == string_with_noise
+            expect(string_with_noise).not_to eq(string_with_noise)
 
             signature1 = described_class.new( string_with_noise )
 
@@ -63,18 +63,18 @@ describe Arachni::Support::Signature do
             signature2 = described_class.new( string_with_noise )
             10.times{ signature2 = signature2.refine( string_with_noise ) }
 
-            signature1.should == signature2
+            expect(signature1).to eq(signature2)
         end
 
         it 'returns a new signature instance' do
             signature1 = described_class.new( string_with_noise )
-            signature1.refine( string_with_noise ).object_id.should_not == signature1.object_id
+            expect(signature1.refine( string_with_noise ).object_id).not_to eq(signature1.object_id)
         end
     end
 
     describe '#refine!' do
         it 'destructively removes noise from the signature' do
-            string_with_noise.should_not == string_with_noise
+            expect(string_with_noise).not_to eq(string_with_noise)
 
             signature1 = described_class.new( string_with_noise )
             10.times{ signature1.refine!( string_with_noise ) }
@@ -82,12 +82,12 @@ describe Arachni::Support::Signature do
             signature2 = described_class.new( string_with_noise )
             10.times{ signature2.refine!( string_with_noise ) }
 
-            signature1.should == signature2
+            expect(signature1).to eq(signature2)
         end
 
         it 'returns self' do
             signature = described_class.new( string_with_noise )
-            signature.refine!( string_with_noise ).object_id.should == signature.object_id
+            expect(signature.refine!( string_with_noise ).object_id).to eq(signature.object_id)
         end
     end
 
@@ -98,12 +98,12 @@ describe Arachni::Support::Signature do
             signature3 = described_class.new( different_string_with_noise )
             signature4 = described_class.new( different_string_with_noise )
 
-            signature1.differences( signature2 ).round(3).should == 0.348
-            signature2.differences( signature2 ).should == 0
+            expect(signature1.differences( signature2 ).round(3)).to eq(0.348)
+            expect(signature2.differences( signature2 )).to eq(0)
 
-            signature3.differences( signature4 ).should == 0.2
-            signature4.differences( signature4 ).should == 0
-            signature1.differences( signature3 ).round(3).should == 0.667
+            expect(signature3.differences( signature4 )).to eq(0.2)
+            expect(signature4.differences( signature4 )).to eq(0)
+            expect(signature1.differences( signature3 ).round(3)).to eq(0.667)
         end
     end
 
@@ -116,7 +116,7 @@ describe Arachni::Support::Signature do
                 signature2 = described_class.new( string_with_noise )
                 10.times{ signature2.refine!( string_with_noise ) }
 
-                signature1.should == signature2
+                expect(signature1).to eq(signature2)
             end
         end
 
@@ -128,15 +128,15 @@ describe Arachni::Support::Signature do
                 signature2 = described_class.new( different_string_with_noise )
                 10.times{ signature2.refine!( different_string_with_noise ) }
 
-                signature1.should_not == signature2
+                expect(signature1).not_to eq(signature2)
             end
         end
     end
 
     describe '#dup' do
         it 'returns a duplicate instance' do
-            signature.dup.should == signature
-            signature.dup.object_id.should_not == signature.object_id
+            expect(signature.dup).to eq(signature)
+            expect(signature.dup.object_id).not_to eq(signature.object_id)
         end
     end
 end

data/spec/arachni/trainer_spec.rb

@@ -76,43 +76,43 @@ describe Arachni::Trainer do
     describe 'HTTP requests with "train" set to' do
         describe 'nil' do
             it 'skips the Trainer' do
-                @framework.pages.size.should == 0
+                expect(@framework.pages.size).to eq(0)
 
                 Arachni::HTTP::Client.request( @url + '/elems' )
                 @framework.run
 
-                @framework.pages.size.should == 0
+                expect(@framework.pages.size).to eq(0)
             end
         end
         describe false do
             it 'skips the Trainer' do
-                @framework.pages.size.should == 0
+                expect(@framework.pages.size).to eq(0)
 
                 Arachni::HTTP::Client.request( @url + '/elems', train: false )
                 @framework.run
 
-                @framework.pages.size.should == 0
+                expect(@framework.pages.size).to eq(0)
             end
         end
         describe true do
             it 'passes the response to the Trainer' do
-                @framework.pages.size.should == 0
+                expect(@framework.pages.size).to eq(0)
 
                 Arachni::HTTP::Client.request( @url + '/elems', train: true )
 
-                @trainer.should receive(:push)
+                expect(@trainer).to receive(:push)
                 @framework.run
             end
 
             context 'when a redirection leads to new elements' do
                 it 'passes the response to the Trainer' do
-                    @framework.pages.size.should == 0
+                    expect(@framework.pages.size).to eq(0)
 
                     Arachni::HTTP::Client.request( @url + '/train/redirect', train: true )
                     @framework.run
 
                     page = @framework.pages.first
-                    page.links.first.inputs.include?( 'msg' ).should be_true
+                    expect(page.links.first.inputs.include?( 'msg' )).to be_truthy
                 end
             end
         end
@@ -121,25 +121,25 @@ describe Arachni::Trainer do
     context 'when a page' do
         context 'has not changed' do
             it 'is skipped' do
-                @framework.pages.should be_empty
+                expect(@framework.pages).to be_empty
 
                 Arachni::HTTP::Client.request( @url, train: true )
                 @framework.run
 
-                @framework.pages.should be_empty
+                expect(@framework.pages).to be_empty
             end
 
             context 'but has new paths' do
                 it 'pushes them to the framework' do
-                    @framework.urls.should be_empty
+                    expect(@framework.urls).to be_empty
 
                     Arachni::HTTP::Client.request( @url, train: true )
 
                     Arachni::HTTP::Client.request( @url + '/new-paths', train: true )
                     @framework.run
 
-                    @framework.pages.should be_empty
-                    @framework.urls.should be_any
+                    expect(@framework.pages).to be_empty
+                    expect(@framework.urls).to be_any
                 end
             end
         end
@@ -162,7 +162,7 @@ describe Arachni::Trainer do
 
                 100.times { @trainer.push( get_response.call ) }
 
-                pages.size.should == Arachni::Trainer::MAX_TRAININGS_PER_URL
+                expect(pages.size).to eq(Arachni::Trainer::MAX_TRAININGS_PER_URL)
             end
         end
 
@@ -171,7 +171,7 @@ describe Arachni::Trainer do
                 res = Arachni::HTTP::Response.new(
                     url: @url + '/exclude_me'
                 )
-                @trainer.push( res ).should be_false
+                expect(@trainer.push( res )).to be_falsey
             end
         end
 
@@ -197,7 +197,7 @@ describe Arachni::Trainer do
                 Arachni::Options.scope.redundant_path_patterns = { /match_this/ => 0 }
                 trainer.push( get_response.call )
 
-                pages.size.should == 0
+                expect(pages.size).to eq(0)
             end
         end
     end
@@ -207,9 +207,9 @@ describe Arachni::Trainer do
             it 'returns nil' do
                 @trainer.page = @page
 
-                @trainer.stub(:analyze) { raise }
+                allow(@trainer).to receive(:analyze) { raise }
 
-                @trainer.push( request( @url ) ).should be_nil
+                expect(@trainer.push( request( @url ) )).to be_nil
             end
         end
 
@@ -218,7 +218,7 @@ describe Arachni::Trainer do
                 @trainer.page = @page
 
                 Arachni::Options.scope.exclude_path_patterns = @url
-                @trainer.push( request( @url ) ).should be_false
+                expect(@trainer.push( request( @url ) )).to be_falsey
             end
         end
 
@@ -226,14 +226,14 @@ describe Arachni::Trainer do
             context 'text-based' do
                 it 'returns true' do
                     @trainer.page = @page
-                    @trainer.push( request( @url ) ).should be_true
+                    expect(@trainer.push( request( @url ) )).to be_truthy
                 end
             end
 
             context 'not text-based' do
                 it 'returns false' do
                     ct = @url + '/non_text_content_type'
-                    @trainer.push( request( ct ) ).should be_false
+                    expect(@trainer.push( request( ct ) )).to be_falsey
                 end
             end
         end
@@ -243,15 +243,15 @@ describe Arachni::Trainer do
                 it 'returns a page with the new form' do
                     url = @url + '/new_form'
                     @trainer.page = @page
-                    @trainer.push( request( url ) ).should be_true
+                    expect(@trainer.push( request( url ) )).to be_truthy
 
                     pages = @framework.pages
-                    pages.size.should == 1
+                    expect(pages.size).to eq(1)
 
                     page = pages.pop
                     new_forms = (page.forms - @page.forms)
-                    new_forms.size.should == 1
-                    new_forms.first.inputs.include?( 'input2' ).should be_true
+                    expect(new_forms.size).to eq(1)
+                    expect(new_forms.first.inputs.include?( 'input2' )).to be_truthy
                 end
             end
 
@@ -259,13 +259,13 @@ describe Arachni::Trainer do
                 it 'returns a page with the new link' do
                     url = @url + '/new_link'
                     @trainer.page = @page
-                    @trainer.push( request( url ) ).should be_true
+                    expect(@trainer.push( request( url ) )).to be_truthy
 
                     page = @framework.pages.first
 
                     new_links = (page.links - @page.links)
-                    new_links.size.should == 1
-                    new_links.select { |l| l.inputs.include?( 'link_param' ) }.should be_any
+                    expect(new_links.size).to eq(1)
+                    expect(new_links.select { |l| l.inputs.include?( 'link_param' ) }).to be_any
                 end
             end
 
@@ -273,11 +273,11 @@ describe Arachni::Trainer do
                 it 'returns a page with the new cookie appended' do
                     url = @url + '/new_cookie'
                     @trainer.page = @page
-                    @trainer.push( request( url ) ).should be_true
+                    expect(@trainer.push( request( url ) )).to be_truthy
 
                     page = @framework.pages.first
-                    page.cookies.size.should == 2
-                    page.cookies.select { |l| l.inputs.include?( 'new_cookie' ) }.should be_any
+                    expect(page.cookies.size).to eq(2)
+                    expect(page.cookies.select { |l| l.inputs.include?( 'new_cookie' ) }).to be_any
                 end
             end
         end
@@ -286,9 +286,9 @@ describe Arachni::Trainer do
             it 'extracts query vars from the effective url' do
                 url = @url + '/redirect?redirected=true'
                 @trainer.page = @page
-                @trainer.push( request( url ) ).should be_true
+                expect(@trainer.push( request( url ) )).to be_truthy
                 page = @framework.pages.first
-                page.links.last.inputs['redirected'].should == 'true'
+                expect(page.links.last.inputs['redirected']).to eq('true')
             end
         end
 
@@ -310,28 +310,28 @@ describe Arachni::Trainer do
             let(:subject) { TrainerMockFramework.new.trainer }
 
             context true do
-                before { TrainerMockFramework.any_instance.stub(:accepts_more_pages?){ true } }
+                before { allow_any_instance_of(TrainerMockFramework).to receive(:accepts_more_pages?){ true } }
 
                 it 'processes pages' do
                     pages = []
                     subject.on_new_page { |p| pages << p }
 
-                    subject.push( get_response.call ).should be_true
+                    expect(subject.push( get_response.call )).to be_truthy
 
-                    pages.size.should == 1
+                    expect(pages.size).to eq(1)
                 end
             end
 
             context false do
-                before { TrainerMockFramework.any_instance.stub(:accepts_more_pages?){ false } }
+                before { allow_any_instance_of(TrainerMockFramework).to receive(:accepts_more_pages?){ false } }
 
                 it 'does not process the page' do
                     pages = []
                     subject.on_new_page { |p| pages << p }
 
-                    subject.push( get_response.call ).should be_false
+                    expect(subject.push( get_response.call )).to be_falsey
 
-                    pages.should be_empty
+                    expect(pages).to be_empty
                 end
             end
         end