arachni 1.2.1 → 1.3

data/spec/arachni/element_filter_spec.rb

@@ -30,40 +30,40 @@ describe Arachni::ElementFilter do
 
     describe '#forms' do
         it "keeps track of forms by #{Arachni::Element::Form}#id" do
-            subject.forms.should be_empty
+            expect(subject.forms).to be_empty
             subject.update_forms form
-            subject.forms.should be_any
-            subject.forms.should include form.id
+            expect(subject.forms).to be_any
+            expect(subject.forms).to include form.id
         end
 
         it "returns a #{Arachni::Support::LookUp::HashSet}" do
-            subject.forms.should be_kind_of Arachni::Support::LookUp::HashSet
+            expect(subject.forms).to be_kind_of Arachni::Support::LookUp::HashSet
         end
     end
 
     describe '#links' do
         it "keeps track of links by #{Arachni::Element::Link}#id" do
-            subject.links.should be_empty
+            expect(subject.links).to be_empty
             subject.update_links link
-            subject.links.should be_any
-            subject.links.should include link.id
+            expect(subject.links).to be_any
+            expect(subject.links).to include link.id
         end
 
         it "returns a #{Arachni::Support::LookUp::HashSet}" do
-            subject.links.should be_kind_of Arachni::Support::LookUp::HashSet
+            expect(subject.links).to be_kind_of Arachni::Support::LookUp::HashSet
         end
     end
 
     describe '#cookies' do
         it "keeps track of cookies by #{Arachni::Element::Link}#id" do
-            subject.cookies.should be_empty
+            expect(subject.cookies).to be_empty
             subject.update_cookies cookie
-            subject.cookies.should be_any
-            subject.cookies.should include cookie.id
+            expect(subject.cookies).to be_any
+            expect(subject.cookies).to include cookie.id
         end
 
         it "returns a #{Arachni::Support::LookUp::HashSet}" do
-            subject.cookies.should be_kind_of Arachni::Support::LookUp::HashSet
+            expect(subject.cookies).to be_kind_of Arachni::Support::LookUp::HashSet
         end
     end
 
@@ -74,15 +74,15 @@ describe Arachni::ElementFilter do
                 subject.update_forms form
                 subject.update_cookies cookie
 
-                subject.should include link
-                subject.should include form
-                subject.should include cookie
+                expect(subject).to include link
+                expect(subject).to include form
+                expect(subject).to include cookie
             end
         end
 
         context 'when the given element is not included' do
             it 'returns false' do
-                subject.should_not include link
+                expect(subject).not_to include link
             end
         end
     end
@@ -90,16 +90,16 @@ describe Arachni::ElementFilter do
     describe '#forms_include?' do
         context 'when #forms includes the given form' do
             it 'returns true' do
-                subject.forms.should be_empty
+                expect(subject.forms).to be_empty
                 subject.update_forms form
-                subject.forms.should be_any
-                subject.forms_include?( form ).should be_true
+                expect(subject.forms).to be_any
+                expect(subject.forms_include?( form )).to be_truthy
             end
         end
 
         context 'when #forms does not include the given form' do
             it 'returns false' do
-                subject.forms_include?( form ).should be_false
+                expect(subject.forms_include?( form )).to be_falsey
             end
         end
     end
@@ -107,16 +107,16 @@ describe Arachni::ElementFilter do
     describe '#links_include?' do
         context 'when #links includes the given form' do
             it 'returns true' do
-                subject.links.should be_empty
+                expect(subject.links).to be_empty
                 subject.update_links link
-                subject.links.should be_any
-                subject.links_include?( link ).should be_true
+                expect(subject.links).to be_any
+                expect(subject.links_include?( link )).to be_truthy
             end
         end
 
         context 'when #links does not include the given form' do
             it 'returns false' do
-                subject.links_include?( link ).should be_false
+                expect(subject.links_include?( link )).to be_falsey
             end
         end
     end
@@ -124,16 +124,16 @@ describe Arachni::ElementFilter do
     describe '#cookies_include?' do
         context 'when #cookies includes the given form' do
             it 'returns true' do
-                subject.cookies.should be_empty
+                expect(subject.cookies).to be_empty
                 subject.update_cookies cookie
-                subject.cookies.should be_any
-                subject.cookies_include?( cookie ).should be_true
+                expect(subject.cookies).to be_any
+                expect(subject.cookies_include?( cookie )).to be_truthy
             end
         end
 
         context 'when #cookies does not include the given form' do
             it 'returns false' do
-                subject.cookies_include?( cookie ).should be_false
+                expect(subject.cookies_include?( cookie )).to be_falsey
             end
         end
     end
@@ -144,20 +144,20 @@ describe Arachni::ElementFilter do
                 subject.update_from_page( page )
 
                 (page.links | page.forms | page.cookies).each do |element|
-                    subject.should include element
+                    expect(subject).to include element
                 end
             end
 
             it 'returns the amount of new ones' do
                 subject.update_links( page.links )
-                subject.update_from_page( page ).should == (page.forms | page.cookies).size
+                expect(subject.update_from_page( page )).to eq((page.forms | page.cookies).size)
             end
         end
 
         context 'when there are no new elements' do
             it 'returns 0' do
                 subject.update_from_page( page )
-                subject.update_from_page( page ).should == 0
+                expect(subject.update_from_page( page )).to eq(0)
             end
         end
     end
@@ -165,33 +165,34 @@ describe Arachni::ElementFilter do
     describe '#update_from_page_cache' do
         context 'when there are new elements in the Page#cache' do
             it 'adds them to the list' do
-                page.cache.should_not include :links
+                expect(page.cache).not_to include :links
                 page.links
-                page.cache[:links].should == page.links
+                expect(page.cache[:links]).to eq(page.links)
 
                 subject.update_from_page_cache( page )
 
                 page.links.each do |element|
-                    subject.should include element
+                    expect(subject).to include element
                 end
 
                 (page.forms | page.cookies).each do |element|
-                    subject.should_not include element
+                    expect(subject).not_to include element
                 end
             end
 
             it 'returns the amount of new ones' do
                 page.links
-                subject.update_from_page_cache( page ).should == page.links.size
+                expect(subject.update_from_page_cache( page )).to eq(page.links.size)
             end
         end
 
         context 'when there are no new elements in the Page#cache' do
             it 'returns 0' do
-                page.elements.should be_any
-                subject.update_from_page_cache( page ).should ==
+                expect(page.elements).to be_any
+                expect(subject.update_from_page_cache( page )).to eq(
                     (page.links | page.forms | page.cookies).size
-                subject.update_from_page_cache( page ).should == 0
+                )
+                expect(subject.update_from_page_cache( page )).to eq(0)
             end
         end
     end
@@ -200,19 +201,19 @@ describe Arachni::ElementFilter do
         context 'when there are new links' do
             it 'adds them to the list' do
                 subject.update_links( link )
-                subject.links_include?( link ).should be_true
+                expect(subject.links_include?( link )).to be_truthy
             end
 
             it 'returns the amount of new ones' do
                 subject.update_links( page.links )
-                subject.update_links( [link] | page.links ).should == 1
+                expect(subject.update_links( [link] | page.links )).to eq(1)
             end
         end
 
         context 'when there are no new links' do
             it 'returns 0' do
                 subject.update_links( page.links )
-                subject.update_links( page.links ).should == 0
+                expect(subject.update_links( page.links )).to eq(0)
             end
         end
     end
@@ -221,19 +222,19 @@ describe Arachni::ElementFilter do
         context 'when there are new links' do
             it 'adds them to the list' do
                 subject.update_forms( form )
-                subject.forms_include?( form ).should be_true
+                expect(subject.forms_include?( form )).to be_truthy
             end
 
             it 'returns the amount of new ones' do
                 subject.update_forms( page.forms )
-                subject.update_forms( [form] | page.forms ).should == 1
+                expect(subject.update_forms( [form] | page.forms )).to eq(1)
             end
         end
     
         context 'when there are no new links' do
             it 'returns 0' do
                 subject.update_forms( page.forms )
-                subject.update_forms( page.forms ).should == 0
+                expect(subject.update_forms( page.forms )).to eq(0)
             end
         end
     end
@@ -242,19 +243,19 @@ describe Arachni::ElementFilter do
         context 'when there are new links' do
             it 'adds them to the list' do
                 subject.update_cookies( cookie )
-                subject.cookies_include?( cookie ).should be_true
+                expect(subject.cookies_include?( cookie )).to be_truthy
             end
 
             it 'returns the amount of new ones' do
                 subject.update_cookies( page.cookies )
-                subject.update_cookies( [cookie] | page.cookies ).should == 1
+                expect(subject.update_cookies( [cookie] | page.cookies )).to eq(1)
             end
         end
     
         context 'when there are no new cookies' do
             it 'returns 0' do
                 subject.update_cookies( page.cookies )
-                subject.update_cookies( page.cookies ).should == 0
+                expect(subject.update_cookies( page.cookies )).to eq(0)
             end
         end
     end

data/spec/arachni/error_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Arachni::Error do
     it 'inherits from StandardError' do
-        (Arachni::Error <= StandardError).should be_true
+        expect(Arachni::Error <= StandardError).to be_truthy
 
         caught = false
         begin
@@ -10,7 +10,7 @@ describe Arachni::Error do
         rescue StandardError => e
             caught = true
         end
-        caught.should be_true
+        expect(caught).to be_truthy
 
         caught = false
         begin
@@ -18,6 +18,6 @@ describe Arachni::Error do
         rescue
             caught = true
         end
-        caught.should be_true
+        expect(caught).to be_truthy
     end
 end

data/spec/arachni/framework/parts/audit_spec.rb

@@ -11,24 +11,24 @@ describe Arachni::Framework::Parts::Audit do
                     f.options.url = @url
                     f.options.scope.restrict_paths << @url + '/binary'
                     f.options.audit.elements :links, :forms, :cookies
-                    f.checks.load :taint
+                    f.checks.load :signature
 
                     f.on_page_audit { |p| audited << p.url }
                     f.run
                 end
-                audited.sort.should == [@url + '/binary'].sort
+                expect(audited.sort).to eq([@url + '/binary'].sort)
 
                 audited = []
                 Arachni::Framework.new do |f|
                     f.options.url = @url
                     f.options.scope.restrict_paths << @url + '/binary'
                     f.options.scope.exclude_binaries = true
-                    f.checks.load :taint
+                    f.checks.load :signature
 
                     f.on_page_audit { |p| audited << p.url }
                     f.run
                 end
-                audited.should be_empty
+                expect(audited).to be_empty
             end
         end
 
@@ -38,13 +38,13 @@ describe Arachni::Framework::Parts::Audit do
                     f.options.url = "#{@url}/elem_combo"
                     f.options.scope.extend_paths = %w(/some/stuff /more/stuff)
                     f.options.audit.elements :links, :forms, :cookies
-                    f.checks.load :taint
+                    f.checks.load :signature
 
                     f.run
 
-                    f.report.sitemap.should include "#{@url}/some/stuff"
-                    f.report.sitemap.should include "#{@url}/more/stuff"
-                    f.report.sitemap.size.should > 3
+                    expect(f.report.sitemap).to include "#{@url}/some/stuff"
+                    expect(f.report.sitemap).to include "#{@url}/more/stuff"
+                    expect(f.report.sitemap.size).to be > 3
                 end
             end
         end
@@ -55,13 +55,13 @@ describe Arachni::Framework::Parts::Audit do
                     f.options.url = "#{@url}/elem_combo"
                     f.options.scope.restrict_paths = %w(/log_remote_file_if_exists/true)
                     f.options.audit.elements :links, :forms, :cookies
-                    f.checks.load :taint
+                    f.checks.load :signature
 
                     f.run
 
                     sitemap = f.report.sitemap.map { |u, _| u.split( '?' ).first }
-                    sitemap.sort.uniq.should == f.options.scope.restrict_paths.
-                        map { |p| f.to_absolute( p ) }.sort
+                    expect(sitemap.sort.uniq).to eq(f.options.scope.restrict_paths.
+                        map { |p| f.to_absolute( p ) }.sort)
                 end
             end
         end
@@ -73,9 +73,9 @@ describe Arachni::Framework::Parts::Audit do
                 @options.url = 'http://blahaha'
                 @options.scope.restrict_paths = [@options.url]
 
-                subject.checks.load :taint
+                subject.checks.load :signature
                 subject.run
-                subject.failures.should be_any
+                expect(subject.failures).to be_any
             end
         end
 
@@ -84,9 +84,9 @@ describe Arachni::Framework::Parts::Audit do
                 @options.url = @f_url + '/fail'
                 @options.scope.restrict_paths = [@options.url]
 
-                subject.checks.load :taint
+                subject.checks.load :signature
                 subject.run
-                subject.failures.should be_any
+                expect(subject.failures).to be_any
             end
         end
 
@@ -94,15 +94,15 @@ describe Arachni::Framework::Parts::Audit do
             @options.url = @f_url + '/fail_4_times'
             @options.scope.restrict_paths = [@options.url]
 
-            subject.checks.load :taint
+            subject.checks.load :signature
             subject.run
-            subject.failures.should be_empty
+            expect(subject.failures).to be_empty
         end
     end
 
     describe '#http' do
         it 'provides access to the HTTP interface' do
-            subject.http.is_a?( Arachni::HTTP::Client ).should be_true
+            expect(subject.http.is_a?( Arachni::HTTP::Client )).to be_truthy
         end
     end
 
@@ -112,9 +112,9 @@ describe Arachni::Framework::Parts::Audit do
                 @options.url = @f_url
                 @options.scope.restrict_paths = [@options.url]
 
-                subject.checks.load :taint
+                subject.checks.load :signature
                 subject.run
-                subject.failures.should be_empty
+                expect(subject.failures).to be_empty
             end
         end
         context 'when there are failed requests' do
@@ -122,9 +122,9 @@ describe Arachni::Framework::Parts::Audit do
                 @options.url = @f_url + '/fail'
                 @options.scope.restrict_paths = [@options.url]
 
-                subject.checks.load :taint
+                subject.checks.load :signature
                 subject.run
-                subject.failures.should be_any
+                expect(subject.failures).to be_any
             end
         end
     end
@@ -138,7 +138,7 @@ describe Arachni::Framework::Parts::Audit do
 
                 f.audit_page Arachni::Page.from_url( @url + '/link' )
             end
-            ok.should be_true
+            expect(ok).to be_truthy
         end
     end
 
@@ -151,22 +151,22 @@ describe Arachni::Framework::Parts::Audit do
 
                 f.audit_page Arachni::Page.from_url( @url + '/link' )
             end
-            ok.should be_true
+            expect(ok).to be_truthy
         end
     end
 
     describe '#audit_page' do
         it 'updates the #sitemap with the DOM URL' do
             subject.options.audit.elements :links, :forms, :cookies
-            subject.checks.load :taint
+            subject.checks.load :signature
 
-            subject.sitemap.should be_empty
+            expect(subject.sitemap).to be_empty
 
             page = Arachni::Page.from_url( @url + '/link' )
             page.dom.url = @url + '/link/#/stuff'
 
             subject.audit_page page
-            subject.sitemap.should include @url + '/link/#/stuff'
+            expect(subject.sitemap).to include @url + '/link/#/stuff'
         end
 
         it "runs #{Arachni::Check::Manager}#without_platforms before #{Arachni::Check::Manager}#with_platforms" do
@@ -184,23 +184,24 @@ describe Arachni::Framework::Parts::Audit do
 
                 f.audit_page page
 
-                responses.should ==
+                expect(responses).to eq(
                     %w(http://localhost/test3 http://localhost/test
                         http://localhost/test2)
+                )
             end
         end
 
         context 'when checks were' do
             context 'ran against the page' do
                 it 'returns true' do
-                    subject.checks.load :taint
-                    subject.audit_page( Arachni::Page.from_url( @url + '/link' ) ).should be_true
+                    subject.checks.load :signature
+                    expect(subject.audit_page( Arachni::Page.from_url( @url + '/link' ) )).to be_truthy
                 end
             end
 
             context 'not ran against the page' do
                 it 'returns false' do
-                    subject.audit_page( Arachni::Page.from_url( @url + '/link' ) ).should be_false
+                    expect(subject.audit_page( Arachni::Page.from_url( @url + '/link' ) )).to be_falsey
                 end
             end
         end
@@ -209,15 +210,15 @@ describe Arachni::Framework::Parts::Audit do
             it 'analyzes the DOM and pushes new pages to the page queue' do
                 Arachni::Framework.new do |f|
                     f.options.audit.elements :links, :forms, :cookies
-                    f.checks.load :taint
+                    f.checks.load :signature
 
-                    f.page_queue_total_size.should == 0
+                    expect(f.page_queue_total_size).to eq(0)
 
                     f.audit_page( Arachni::Page.from_url( @url + '/with_javascript' ) )
 
                     sleep 0.1 while f.wait_for_browser_cluster?
 
-                    f.page_queue_total_size.should > 0
+                    expect(f.page_queue_total_size).to be > 0
                 end
             end
 
@@ -226,13 +227,13 @@ describe Arachni::Framework::Parts::Audit do
                     f.options.url = @url
                     f.options.audit.elements :links, :forms, :cookies
 
-                    f.url_queue_total_size.should == 0
+                    expect(f.url_queue_total_size).to eq(0)
 
                     f.audit_page( Arachni::Page.from_url( @url + '/with_javascript' ) )
 
                     f.run
 
-                    f.url_queue_total_size.should == 5
+                    expect(f.url_queue_total_size).to eq(3)
                 end
             end
 
@@ -242,26 +243,26 @@ describe Arachni::Framework::Parts::Audit do
                         f.options.url = @url
 
                         f.options.audit.elements :links, :forms, :cookies
-                        f.checks.load :taint
+                        f.checks.load :signature
                         f.options.scope.dom_depth_limit = 1
-                        f.url_queue_total_size.should == 0
-                        f.audit_page( Arachni::Page.from_url( @url + '/with_javascript' ) ).should be_true
+                        expect(f.url_queue_total_size).to eq(0)
+                        expect(f.audit_page( Arachni::Page.from_url( @url + '/with_javascript' ) )).to be_truthy
                         f.run
-                        f.url_queue_total_size.should == 5
+                        expect(f.url_queue_total_size).to eq(3)
 
                         f.reset
 
                         f.options.audit.elements :links, :forms, :cookies
-                        f.checks.load :taint
+                        f.checks.load :signature
                         f.options.scope.dom_depth_limit = 1
-                        f.url_queue_total_size.should == 0
+                        expect(f.url_queue_total_size).to eq(0)
 
                         page = Arachni::Page.from_url( @url + '/with_javascript' )
                         page.dom.push_transition Arachni::Page::DOM::Transition.new( :page, :load )
 
-                        f.audit_page( page ).should be_true
+                        expect(f.audit_page( page )).to be_truthy
                         f.run
-                        f.url_queue_total_size.should == 1
+                        expect(f.url_queue_total_size).to eq(1)
                     end
                 end
 
@@ -278,13 +279,13 @@ describe Arachni::Framework::Parts::Audit do
                     )
 
                     Arachni::Framework.new do |f|
-                        f.checks.load :taint
+                        f.checks.load :signature
 
                         f.options.scope.dom_depth_limit = 10
-                        f.audit_page( page ).should be_true
+                        expect(f.audit_page( page )).to be_truthy
 
                         f.options.scope.dom_depth_limit = 2
-                        f.audit_page( page ).should be_false
+                        expect(f.audit_page( page )).to be_falsey
                     end
                 end
             end
@@ -295,15 +296,15 @@ describe Arachni::Framework::Parts::Audit do
                 subject.options.scope.exclude_path_patterns << /link/
                 subject.options.audit.elements :links, :forms, :cookies
 
-                subject.checks.load :taint
+                subject.checks.load :signature
 
                 subject.audit_page( Arachni::Page.from_url( @url + '/link' ) )
-                subject.report.issues.size.should == 0
+                expect(subject.report.issues.size).to eq(0)
             end
 
             it 'returns false' do
                 subject.options.scope.exclude_path_patterns << /link/
-                subject.audit_page( Arachni::Page.from_url( @url + '/link' ) ).should be_false
+                expect(subject.audit_page( Arachni::Page.from_url( @url + '/link' ) )).to be_falsey
             end
         end
 
@@ -319,11 +320,11 @@ describe Arachni::Framework::Parts::Audit do
                         subject.options.platforms = [:unix]
                         subject.options.audit.elements :links, :forms, :cookies
 
-                        subject.checks.load :taint
-                        subject.checks[:taint].platforms << :unix
+                        subject.checks.load :signature
+                        subject.checks[:signature].platforms << :unix
 
                         subject.audit_page( Arachni::Page.from_url( @url + '/link' ) )
-                        subject.report.issues.should be_any
+                        expect(subject.report.issues).to be_any
                     end
                 end
 
@@ -333,11 +334,11 @@ describe Arachni::Framework::Parts::Audit do
 
                         subject.options.audit.elements :links, :forms, :cookies
 
-                        subject.checks.load :taint
-                        subject.checks[:taint].platforms << :unix
+                        subject.checks.load :signature
+                        subject.checks[:signature].platforms << :unix
 
                         subject.audit_page( Arachni::Page.from_url( @url + '/link' ) )
-                        subject.report.issues.should be_empty
+                        expect(subject.report.issues).to be_empty
                     end
                 end
             end
@@ -347,20 +348,20 @@ describe Arachni::Framework::Parts::Audit do
                     subject.options.platforms = []
                     subject.options.audit.elements :links, :forms, :cookies
 
-                    subject.checks.load :taint
-                    subject.checks[:taint].platforms << :unix
+                    subject.checks.load :signature
+                    subject.checks[:signature].platforms << :unix
 
                     subject.audit_page( Arachni::Page.from_url( @url + '/link' ) )
-                    subject.report.issues.should be_any
+                    expect(subject.report.issues).to be_any
                 end
             end
         end
 
         context "when #{Arachni::Check::Auditor}.has_timeout_candidates?" do
             it "calls #{Arachni::Check::Auditor}.timeout_audit_run" do
-                Arachni::Check::Auditor.stub(:has_timeout_candidates?){ true }
+                allow(Arachni::Check::Auditor).to receive(:has_timeout_candidates?){ true }
 
-                Arachni::Check::Auditor.should receive(:timeout_audit_run)
+                expect(Arachni::Check::Auditor).to receive(:timeout_audit_run)
                 subject.audit_page( Arachni::Page.from_url( @url + '/link' ) )
             end
         end
@@ -376,7 +377,7 @@ describe Arachni::Framework::Parts::Audit do
                 Arachni::Framework.new do |f|
                     f.checks.load_all
 
-                    f.checks[:test].any_instance.stub(:run) { raise }
+                    allow_any_instance_of(f.checks[:test]).to receive(:run) { raise }
 
                     page = Arachni::Page.from_url( @url + '/link' )
 
@@ -387,7 +388,7 @@ describe Arachni::Framework::Parts::Audit do
 
                     f.audit_page page
 
-                    responses.should == %w(http://localhost/test3 http://localhost/test2)
+                    expect(responses).to eq(%w(http://localhost/test3 http://localhost/test2))
                 end
             end
         end