arachni 1.2.1 → 1.3

data/spec/arachni/browser_cluster/job_spec.rb

@@ -15,19 +15,21 @@ class MockWorker
 end
 
 class JobTest < Arachni::BrowserCluster::Job
+    include RSpec::Matchers
+
     def ran?
         !!@ran
     end
 
     def run
-        browser.class.should == MockWorker
+        expect(browser.class).to eq MockWorker
         @ran = true
     end
 end
 
 class JobConfigureAndRunTest < JobTest
     def run
-        browser.class.should == MockWorker
+        expect(browser.class).to eq MockWorker
         super
     end
 end
@@ -42,8 +44,8 @@ class JobSaveResultTest < JobTest
         save_result my_data: val
 
         result = browser.master.result
-        result.job.id.should == self.id
-        result.my_data.should == val
+        expect(result.job.id).to eq self.id
+        expect(result.my_data).to eq val
 
         super
     end
@@ -51,13 +53,13 @@ end
 
 class JobCleanCopyTest < JobTest
     def run
-        browser.class.should == MockWorker
+        expect(browser.class).to eq MockWorker
 
         copy = self.clean_copy
-        copy.browser.should == nil
-        copy.id.should == self.id
+        expect(copy.browser).to eq nil
+        expect(copy.id).to eq self.id
 
-        browser.class.should == MockWorker
+        expect(browser.class).to eq MockWorker
 
         super
     end
@@ -89,7 +91,7 @@ describe Arachni::BrowserCluster::Job do
                 id = described_class.new.id
                 next if i == 0
 
-                described_class.new.id.should == id + 1
+                expect(described_class.new.id).to eq(id + 1)
             end
         end
     end
@@ -101,20 +103,20 @@ describe Arachni::BrowserCluster::Job do
             context true do
                 it 'returns true' do
                     subject.never_ending = true
-                    subject.never_ending?.should be_true
+                    expect(subject.never_ending?).to be_truthy
                 end
             end
 
             context false do
                 it 'returns false' do
                     subject.never_ending = false
-                    subject.never_ending?.should be_false
+                    expect(subject.never_ending?).to be_falsey
                 end
             end
 
             context nil do
                 it 'returns false' do
-                    subject.never_ending?.should be_false
+                    expect(subject.never_ending?).to be_falsey
                 end
             end
         end
@@ -128,16 +130,16 @@ describe Arachni::BrowserCluster::Job do
         end
 
         it 'calls #run' do
-            subject.ran?.should be_false
+            expect(subject.ran?).to be_falsey
             subject.configure_and_run( worker )
-            subject.ran?.should be_true
+            expect(subject.ran?).to be_truthy
         end
 
         it 'removes #browser' do
-            subject.ran?.should be_false
+            expect(subject.ran?).to be_falsey
             subject.configure_and_run( worker )
-            subject.browser.should be_nil
-            subject.ran?.should be_true
+            expect(subject.browser).to be_nil
+            expect(subject.ran?).to be_truthy
         end
     end
 
@@ -145,9 +147,9 @@ describe Arachni::BrowserCluster::Job do
         subject { JobSaveResultTest.new }
 
         it 'forwards the result to the BrowserCluster' do
-            subject.ran?.should be_false
+            expect(subject.ran?).to be_falsey
             subject.configure_and_run( worker )
-            subject.ran?.should be_true
+            expect(subject.ran?).to be_truthy
         end
     end
 
@@ -155,9 +157,9 @@ describe Arachni::BrowserCluster::Job do
         subject { JobCleanCopyTest.new }
 
         it 'copies the Job without the resources set by #configure_and_run' do
-            subject.ran?.should be_false
+            expect(subject.ran?).to be_falsey
             subject.configure_and_run( worker )
-            subject.ran?.should be_true
+            expect(subject.ran?).to be_truthy
         end
     end
 
@@ -165,11 +167,29 @@ describe Arachni::BrowserCluster::Job do
         subject { JobDupTest.new( never_ending: true, my_data: 'stuff' ) }
 
         it 'copies the Job' do
-            subject.my_data.should == 'stuff'
+            expect(subject.my_data).to eq('stuff')
+
+            dup = subject.dup
+            expect(dup.my_data).to eq('stuff')
+            expect(dup.never_ending?).to eq(true)
+        end
+
+        it 'preserves #time' do
+            subject.time = 10
+            expect(subject.time).to eq 10
+
+            dup = subject.dup
+            expect(dup.time).to eq 10
+        end
+
+        it 'preserves #timed_out' do
+            subject.timed_out! 10
+            expect(subject.time).to eq 10
+            expect(subject).to be_timed_out
 
             dup = subject.dup
-            dup.my_data.should == 'stuff'
-            dup.never_ending?.should == true
+            expect(dup.time).to eq 10
+            expect(subject).to be_timed_out
         end
     end
 
@@ -178,33 +198,33 @@ describe Arachni::BrowserCluster::Job do
 
         it 'sets the original Job as the #forwarder' do
             id = subject.id
-            subject.forward.forwarder.should == subject
+            expect(subject.forward.forwarder).to eq(subject)
         end
 
         it 'creates a new Job with the same #id' do
             id = subject.id
-            subject.forward.id.should == id
+            expect(subject.forward.id).to eq(id)
         end
 
         it 'creates a new Job with the same #never_ending' do
-            subject.forward.never_ending?.should be_false
+            expect(subject.forward.never_ending?).to be_falsey
 
             job = JobForwardTest.new( never_ending: true, my_data: 'stuff' )
-            job.never_ending?.should be_true
-            job.forward.never_ending?.should be_true
+            expect(job.never_ending?).to be_truthy
+            expect(job.forward.never_ending?).to be_truthy
 
             job = JobForwardTest.new( never_ending: false, my_data: 'stuff' )
-            job.never_ending?.should be_false
-            job.forward.never_ending?.should be_false
+            expect(job.never_ending?).to be_falsey
+            expect(job.forward.never_ending?).to be_falsey
         end
 
         it 'does not preserve any existing data' do
-            subject.forward.my_data.should be_nil
+            expect(subject.forward.my_data).to be_nil
         end
 
         context 'when options are given' do
             it 'sets initialization options' do
-                subject.forward( my_data: 'stuff2' ).my_data.should == 'stuff2'
+                expect(subject.forward( my_data: 'stuff2' ).my_data).to eq('stuff2')
             end
         end
     end
@@ -214,49 +234,49 @@ describe Arachni::BrowserCluster::Job do
 
         it 'sets the original Job as the #forwarder' do
             id = subject.id
-            subject.forward_as( JobForwardAsTest ).forwarder.should == subject
+            expect(subject.forward_as( JobForwardAsTest ).forwarder).to eq(subject)
         end
 
         it 'creates a new Job type with the same #id' do
-            subject.should_not be_kind_of JobForwardAsTest
+            expect(subject).not_to be_kind_of JobForwardAsTest
 
             id = subject.id
 
             forwarded = subject.forward_as( JobForwardAsTest )
 
-            forwarded.id.should == id
-            forwarded.should be_kind_of JobForwardAsTest
+            expect(forwarded.id).to eq(id)
+            expect(forwarded).to be_kind_of JobForwardAsTest
         end
 
         it 'creates a new Job with the same #never_ending' do
-            subject.forward_as( JobForwardAsTest ).never_ending?.should be_false
+            expect(subject.forward_as( JobForwardAsTest ).never_ending?).to be_falsey
 
             job = JobForwardTest.new( never_ending: true, my_data: 'stuff' )
-            job.never_ending?.should be_true
-            job.forward_as( JobForwardAsTest ).never_ending?.should be_true
+            expect(job.never_ending?).to be_truthy
+            expect(job.forward_as( JobForwardAsTest ).never_ending?).to be_truthy
 
             job = JobForwardTest.new( never_ending: false, my_data: 'stuff' )
-            job.never_ending?.should be_false
-            job.forward_as( JobForwardAsTest ).never_ending?.should be_false
+            expect(job.never_ending?).to be_falsey
+            expect(job.forward_as( JobForwardAsTest ).never_ending?).to be_falsey
         end
 
         it 'does not preserve any existing data' do
-            subject.should_not be_kind_of JobForwardAsTest
+            expect(subject).not_to be_kind_of JobForwardAsTest
 
             forwarded = subject.forward_as( JobForwardAsTest )
 
-            forwarded.my_data.should be_nil
-            forwarded.should be_kind_of JobForwardAsTest
+            expect(forwarded.my_data).to be_nil
+            expect(forwarded).to be_kind_of JobForwardAsTest
         end
 
         context 'when options are given' do
             it 'sets initialization options' do
-                subject.should_not be_kind_of JobForwardAsTest
+                expect(subject).not_to be_kind_of JobForwardAsTest
 
                 forwarded = subject.forward_as( JobForwardAsTest, my_data: 'stuff2' )
 
-                forwarded.my_data.should == 'stuff2'
-                forwarded.should be_kind_of JobForwardAsTest
+                expect(forwarded.my_data).to eq('stuff2')
+                expect(forwarded).to be_kind_of JobForwardAsTest
             end
         end
     end

data/spec/arachni/browser_cluster/jobs/resource_exploration/event_trigger/result_spec.rb

@@ -2,6 +2,6 @@ require 'spec_helper'
 
 describe Arachni::BrowserCluster::Jobs::ResourceExploration::EventTrigger::Result do
     subject { described_class.new }
-    it { should respond_to :page }
-    it { should respond_to :page= }
+    it { is_expected.to respond_to :page }
+    it { is_expected.to respond_to :page= }
 end

data/spec/arachni/browser_cluster/jobs/resource_exploration/event_trigger_spec.rb

@@ -25,17 +25,18 @@ describe Arachni::BrowserCluster::Jobs::ResourceExploration::EventTrigger do
         pages = []
 
         @cluster.queue( job ) do |result|
-            result.should be_kind_of described_class::Result
+            expect(result).to be_kind_of described_class::Result
             pages << result.page
         end
         @cluster.wait
 
-        pages.size.should == 2
+        expect(pages.size).to eq(2)
 
         page = pages.last
-        page.dom.transitions.last.event.should == event
-        Nokogiri::HTML( page.body ).xpath("//div[@id='my-div']").first.to_s.should ==
+        expect(page.dom.transitions.last.event).to eq(event)
+        expect(Nokogiri::HTML( page.body ).xpath("//div[@id='my-div']").first.to_s).to eq(
             '<div id="my-div"><a href="#3">My link</a></div>'
+        )
     end
 
     context 'when the resource is a' do

data/spec/arachni/browser_cluster/jobs/resource_exploration/result_spec.rb

@@ -2,6 +2,6 @@ require 'spec_helper'
 
 describe Arachni::BrowserCluster::Jobs::ResourceExploration::Result do
     subject { described_class.new }
-    it { should respond_to :page }
-    it { should respond_to :page= }
+    it { is_expected.to respond_to :page }
+    it { is_expected.to respond_to :page= }
 end

data/spec/arachni/browser_cluster/jobs/resource_exploration_spec.rb

@@ -15,18 +15,18 @@ describe Arachni::BrowserCluster::Jobs::ResourceExploration do
         has_event_triggers = false
 
         @cluster.queue( job ) do |result|
-            result.should be_kind_of described_class::Result
+            expect(result).to be_kind_of described_class::Result
 
             if result.job.is_a? described_class::EventTrigger
                 has_event_triggers = true
-                result.job.forwarder.should be_kind_of described_class
+                expect(result.job.forwarder).to be_kind_of described_class
             end
 
             pages << result.page
         end
         @cluster.wait
 
-        has_event_triggers.should be_true
+        expect(has_event_triggers).to be_truthy
         browser_explore_check_pages pages
     end
 
@@ -55,7 +55,7 @@ describe Arachni::BrowserCluster::Jobs::ResourceExploration do
                 q << subject
 
                 restored = q.pop
-                restored.should == subject
+                expect(restored).to eq(subject)
             end
         end
 
@@ -73,7 +73,7 @@ describe Arachni::BrowserCluster::Jobs::ResourceExploration do
                 q << subject
 
                 restored = q.pop
-                restored.should == subject
+                expect(restored).to eq(subject)
             end
         end
     end

data/spec/arachni/browser_cluster/worker_spec.rb

@@ -29,33 +29,33 @@ describe Arachni::BrowserCluster::Worker do
         describe :job_timeout do
             it 'sets how much time to allow each job to run' do
                 @worker = described_class.new( job_timeout: 10 )
-                @worker.job_timeout.should == 10
+                expect(@worker.job_timeout).to eq(10)
             end
 
             it "defaults to #{Arachni::OptionGroups::BrowserCluster}#job_timeout" do
                 Arachni::Options.browser_cluster.job_timeout = 5
                 @worker = described_class.new
-                @worker.job_timeout.should == 5
+                expect(@worker.job_timeout).to eq(5)
             end
         end
 
         describe :max_time_to_live do
             it 'sets how many jobs should be run before respawning' do
                 @worker = described_class.new( max_time_to_live: 10 )
-                @worker.max_time_to_live.should == 10
+                expect(@worker.max_time_to_live).to eq(10)
             end
 
             it "defaults to #{Arachni::OptionGroups::BrowserCluster}#worker_time_to_live" do
                 Arachni::Options.browser_cluster.worker_time_to_live = 5
                 @worker = described_class.new
-                @worker.max_time_to_live.should == 5
+                expect(@worker.max_time_to_live).to eq(5)
             end
         end
     end
 
     describe '#run_job' do
         it 'processes jobs from #master' do
-            subject.should receive(:run_job).with(custom_job)
+            expect(subject).to receive(:run_job).with(custom_job)
             @cluster.queue( custom_job ){}
             @cluster.wait
         end
@@ -66,7 +66,7 @@ describe Arachni::BrowserCluster::Worker do
                 job = subject.job
             end
             @cluster.wait
-            job.should == custom_job
+            expect(job).to eq(custom_job)
         end
 
         context 'before running the job' do
@@ -78,24 +78,24 @@ describe Arachni::BrowserCluster::Worker do
                 @cluster.queue( custom_job ){}
                 @cluster.wait
 
-                subject.pid.should_not == dead_pid
-                Process.getpgid( subject.pid ).should be_true
+                expect(subject.pid).not_to eq(dead_pid)
+                expect(Process.getpgid( subject.pid )).to be_truthy
             end
         end
 
         context 'when a job fails' do
             it 'ignores it' do
-                custom_job.stub(:configure_and_run){ raise 'stuff' }
-                subject.run_job( custom_job ).should be_true
+                allow(custom_job).to receive(:configure_and_run){ raise 'stuff' }
+                expect(subject.run_job( custom_job )).to be_truthy
             end
 
             context Selenium::WebDriver::Error::WebDriverError do
                 it 'respawns' do
-                    subject.watir.stub(:cookies) do
+                    allow(subject.watir).to receive(:cookies) do
                         raise Selenium::WebDriver::Error::WebDriverError
                     end
 
-                    subject.watir.stub(:close) do
+                    allow(subject.watir).to receive(:close) do
                         raise Selenium::WebDriver::Error::WebDriverError
                     end
 
@@ -104,8 +104,8 @@ describe Arachni::BrowserCluster::Worker do
 
                     subject.run_job( custom_job )
 
-                    watir.should_not == subject.watir
-                    pid.should_not == subject.pid
+                    expect(watir).not_to eq(subject.watir)
+                    expect(pid).not_to eq(subject.pid)
                 end
             end
         end
@@ -113,79 +113,46 @@ describe Arachni::BrowserCluster::Worker do
         context 'when the job finishes' do
             let(:page) { Arachni::Page.from_url(url) }
 
-            context 'when there are 5 or more windows open' do
-                before(:each) do
-                    5.times do
-                        subject.javascript.run( 'window.open()' )
-                    end
-                end
-
-                it 'respawns PhantomJS' do
-                    watir         = subject.watir
-                    pid = subject.pid
-
-                    subject.watir.windows.size.should > 5
-                    @cluster.explore( page ) {}
-                    @cluster.wait
-
-                    watir.should_not == subject.watir
-                    pid.should_not == subject.pid
-                    subject.watir.windows.size.should == 2
-                end
-
-                it 'clears the cached HTTP responses' do
-                    subject.preload page
-                    subject.preloads.should be_any
-                    subject.instance_variable_get(:@window_responses)
-
-                    subject.watir.windows.size.should > 5
-                    @cluster.queue( custom_job ) {}
-                    @cluster.wait
-
-                    subject.instance_variable_get(:@window_responses).should be_empty
-                end
-            end
-
             it "clears the #{Arachni::Browser::Javascript}#taint" do
                 subject.javascript.taint = 'stuff'
 
                 @cluster.queue( custom_job ) {}
                 @cluster.wait
 
-                subject.javascript.taint.should be_nil
+                expect(subject.javascript.taint).to be_nil
             end
 
             it 'clears #cookies' do
                 subject.preload page
-                subject.preloads.should be_any
+                expect(subject.preloads).to be_any
 
                 @cluster.with_browser do |browser|
                     browser.load page
-                    subject.cookies.should be_any
+                    expect(subject.cookies).to be_any
                 end
                 @cluster.wait
 
-                subject.cookies.should be_empty
+                expect(subject.cookies).to be_empty
             end
 
             it 'clears #preloads' do
                 subject.preload page
-                subject.preloads.should be_any
+                expect(subject.preloads).to be_any
 
                 @cluster.queue( custom_job ) {}
                 @cluster.wait
 
-                subject.preloads.should be_empty
+                expect(subject.preloads).to be_empty
             end
 
             it 'clears #cache' do
                 subject.cache page
-                subject.cache.should be_any
+                expect(subject.cache).to be_any
 
                 @cluster.queue( custom_job ) {}
                 @cluster.wait
 
-                subject.cache.should be_empty
+                expect(subject.cache).to be_empty
             end
 
             it 'clears #captured_pages' do
@@ -194,7 +161,7 @@ describe Arachni::BrowserCluster::Worker do
                 @cluster.queue( custom_job ) {}
                 @cluster.wait
 
-                subject.captured_pages.should be_empty
+                expect(subject.captured_pages).to be_empty
             end
 
             it 'clears #page_snapshots' do
@@ -203,7 +170,7 @@ describe Arachni::BrowserCluster::Worker do
                 @cluster.queue( custom_job ) {}
                 @cluster.wait
 
-                subject.page_snapshots.should be_empty
+                expect(subject.page_snapshots).to be_empty
             end
 
             it 'clears #page_snapshots_with_sinks' do
@@ -212,7 +179,7 @@ describe Arachni::BrowserCluster::Worker do
                 @cluster.queue( custom_job ) {}
                 @cluster.wait
 
-                subject.page_snapshots_with_sinks.should be_empty
+                expect(subject.page_snapshots_with_sinks).to be_empty
             end
 
             it 'clears #on_new_page callbacks' do
@@ -221,7 +188,7 @@ describe Arachni::BrowserCluster::Worker do
                 @cluster.queue( custom_job ) {}
                 @cluster.wait
 
-                subject.observer_count_for(:on_new_page).should == 0
+                expect(subject.observer_count_for(:on_new_page)).to eq(0)
             end
 
             it 'clears #on_new_page_with_sink callbacks' do
@@ -230,7 +197,7 @@ describe Arachni::BrowserCluster::Worker do
                 @cluster.queue( custom_job ){}
                 @cluster.wait
 
-                subject.observer_count_for(:on_new_page_with_sink).should == 0
+                expect(subject.observer_count_for(:on_new_page_with_sink)).to eq(0)
             end
 
             it 'clears #on_response callbacks' do
@@ -239,7 +206,7 @@ describe Arachni::BrowserCluster::Worker do
                 @cluster.queue( custom_job ){}
                 @cluster.wait
 
-                subject.observer_count_for(:on_response).should == 0
+                expect(subject.observer_count_for(:on_response)).to eq(0)
             end
 
             it 'clears #on_fire_event callbacks' do
@@ -248,19 +215,58 @@ describe Arachni::BrowserCluster::Worker do
                 @cluster.queue( custom_job ){}
                 @cluster.wait
 
-                subject.observer_count_for(:on_fire_event).should == 0
+                expect(subject.observer_count_for(:on_fire_event)).to eq(0)
             end
 
             it 'removes #job' do
                 @cluster.queue( custom_job ){}
                 @cluster.wait
-                subject.job.should be_nil
+                expect(subject.job).to be_nil
             end
 
             it 'decrements #time_to_live' do
                 @cluster.queue( custom_job ) {}
                 @cluster.wait
-                subject.time_to_live.should == subject.max_time_to_live - 1
+                expect(subject.time_to_live).to eq(subject.max_time_to_live - 1)
+            end
+
+            it 'sets Job#time' do
+                @cluster.queue( custom_job ) {}
+                @cluster.wait
+                expect(custom_job.time).to be > 0
+            end
+
+            context 'when there are 5 or more windows open' do
+                before(:each) do
+                    5.times do
+                        subject.javascript.run( 'window.open()' )
+                    end
+                end
+
+                it 'respawns PhantomJS' do
+                    watir         = subject.watir
+                    pid = subject.pid
+
+                    expect(subject.watir.windows.size).to be > 5
+                    @cluster.explore( page ) {}
+                    @cluster.wait
+
+                    expect(watir).not_to eq(subject.watir)
+                    expect(pid).not_to eq(subject.pid)
+                    expect(subject.watir.windows.size).to eq(2)
+                end
+
+                it 'clears the cached HTTP responses' do
+                    subject.preload page
+                    expect(subject.preloads).to be_any
+                    subject.instance_variable_get(:@window_responses)
+
+                    expect(subject.watir.windows.size).to be > 5
+                    @cluster.queue( custom_job ) {}
+                    @cluster.wait
+
+                    expect(subject.instance_variable_get(:@window_responses)).to be_empty
+                end
             end
 
             context 'when #time_to_live reaches 0' do
@@ -278,15 +284,15 @@ describe Arachni::BrowserCluster::Worker do
                     @cluster.queue( custom_job ) {}
                     @cluster.wait
 
-                    watir.should_not == subject.watir
-                    pid.should_not == subject.pid
+                    expect(watir).not_to eq(subject.watir)
+                    expect(pid).not_to eq(subject.pid)
                 end
             end
 
             context 'when cookie clearing raises' do
                 context Selenium::WebDriver::Error::NoSuchWindowError do
                     it 'respawns' do
-                        subject.watir.stub(:cookies) do
+                        allow(subject.watir).to receive(:cookies) do
                             raise Selenium::WebDriver::Error::NoSuchWindowError
                         end
 
@@ -295,18 +301,29 @@ describe Arachni::BrowserCluster::Worker do
 
                         subject.run_job( custom_job )
 
-                        watir.should_not == subject.watir
-                        pid.should_not == subject.pid
+                        expect(watir).not_to eq(subject.watir)
+                        expect(pid).not_to eq(subject.pid)
                     end
                 end
             end
         end
 
         context 'when the job takes more than #job_timeout' do
-            it 'aborts it' do
+            before do
                 subject.job_timeout = 1
+            end
+
+            it 'sets Job#time' do
+                @cluster.queue( sleep_job ) {}
+                @cluster.wait
+                expect(sleep_job.time).to be > 1
+                expect(sleep_job.time).to be < 1.1
+            end
+
+            it 'sets Job#timed_out?' do
                 @cluster.queue( sleep_job ) {}
                 @cluster.wait
+                expect(sleep_job).to be_timed_out
             end
         end
     end