arachni 1.2.1 → 1.3

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

@@ -19,7 +19,7 @@ describe Arachni::Element::Capabilities::Analyzable::Timeout do
         Arachni::HTTP::Client.on_complete do |response|
             next if response.url.include? 'ignore'
 
-            response.body.should be_empty
+            expect(response.body).to be_empty
         end
     end
 
@@ -52,9 +52,9 @@ describe Arachni::Element::Capabilities::Analyzable::Timeout do
                     subject.timing_attack_remark_data = h
 
                     dupped = subject.dup
-                    dupped.should == dupped
-                    dupped.timing_attack_remark_data.should == h
-                    dupped.timing_attack_remark_data.object_id.should_not == h.object_id
+                    expect(dupped).to eq(dupped)
+                    expect(dupped.timing_attack_remark_data).to eq(h)
+                    expect(dupped.timing_attack_remark_data.object_id).not_to eq(h.object_id)
                 end
             end
         end
@@ -62,7 +62,7 @@ describe Arachni::Element::Capabilities::Analyzable::Timeout do
 
     describe '#to_rpc_data' do
         it "does not include 'timing_attack_remark_data'" do
-            subject.to_rpc_data.should_not include 'timing_attack_remark_data'
+            expect(subject.to_rpc_data).not_to include 'timing_attack_remark_data'
         end
     end
 
@@ -74,83 +74,83 @@ describe Arachni::Element::Capabilities::Analyzable::Timeout do
             id = subject.timeout_id
 
             subject.auditor = '2'
-            subject.timeout_id.should_not == id
+            expect(subject.timeout_id).not_to eq(id)
 
             subject.auditor = 1
             id = subject.timeout_id
 
             subject.auditor = 2
-            subject.timeout_id.should == id
+            expect(subject.timeout_id).to eq(id)
         end
 
         it 'takes into account #action' do
             e = subject.dup
-            e.stub(:action) { action }
+            allow(e).to receive(:action) { action }
 
             c = subject.dup
-            c.stub(:action) { "#{action}2" }
+            allow(c).to receive(:action) { "#{action}2" }
 
-            e.timeout_id.should_not == c.timeout_id
+            expect(e.timeout_id).not_to eq(c.timeout_id)
         end
 
         it 'takes into account #type' do
             e = subject.dup
-            e.stub(:type) { :blah }
+            allow(e).to receive(:type) { :blah }
 
             c = subject.dup
-            c.stub(:type) { :blooh }
+            allow(c).to receive(:type) { :blooh }
 
-            e.timeout_id.should_not == c.timeout_id
+            expect(e.timeout_id).not_to eq(c.timeout_id)
         end
 
         it 'takes into account #inputs names' do
             e = subject.dup
-            e.stub(:inputs) { {input1: 'stuff' } }
+            allow(e).to receive(:inputs) { {input1: 'stuff' } }
 
             c = subject.dup
-            c.stub(:inputs) { {input1: 'stuff2' } }
-            e.timeout_id.should == c.timeout_id
+            allow(c).to receive(:inputs) { {input1: 'stuff2' } }
+            expect(e.timeout_id).to eq(c.timeout_id)
 
             e = subject.dup
-            e.stub(:inputs) { {input1: 'stuff' } }
+            allow(e).to receive(:inputs) { {input1: 'stuff' } }
 
             c = subject.dup
-            c.stub(:inputs) { {input2: 'stuff' } }
+            allow(c).to receive(:inputs) { {input2: 'stuff' } }
 
-            e.timeout_id.should_not == c.timeout_id
+            expect(e.timeout_id).not_to eq(c.timeout_id)
         end
 
         it 'takes into account the #affected_input_value' do
             e = subject.dup
-            e.stub(:affected_input_value) { :blah }
+            allow(e).to receive(:affected_input_value) { :blah }
 
             c = subject.dup
-            c.stub(:affected_input_value) { :blooh }
+            allow(c).to receive(:affected_input_value) { :blooh }
 
-            e.timeout_id.should_not == c.timeout_id
+            expect(e.timeout_id).not_to eq(c.timeout_id)
         end
 
         it 'takes into account the #affected_input_name' do
             e = subject.dup
-            e.stub(:affected_input_name) { :blah }
+            allow(e).to receive(:affected_input_name) { :blah }
 
             c = subject.dup
-            c.stub(:affected_input_name) { :blooh }
+            allow(c).to receive(:affected_input_name) { :blooh }
 
-            e.timeout_id.should_not == c.timeout_id
+            expect(e.timeout_id).not_to eq(c.timeout_id)
         end
     end
 
     describe '#ensure_responsiveness' do
         context 'when the server is responsive' do
             it 'returns true' do
-                subject.ensure_responsiveness.should be_true
+                expect(subject.ensure_responsiveness).to be_truthy
             end
         end
         context 'when the server is not responsive' do
             it 'returns false' do
-                Arachni::Element::Link.new( url: @url + '/sleep' ).
-                    ensure_responsiveness( 1 ).should be_false
+                expect(Arachni::Element::Link.new( url: @url + '/sleep' ).
+                    ensure_responsiveness( 1 )).to be_falsey
             end
         end
     end
@@ -159,13 +159,13 @@ describe Arachni::Element::Capabilities::Analyzable::Timeout do
         context 'when there are candidates' do
             it 'returns true' do
                 described_class.add_phase_2_candidate subject
-                described_class.has_candidates?.should be_true
+                expect(described_class.has_candidates?).to be_truthy
             end
         end
 
         context 'when there are no candidates' do
             it 'returns false' do
-                described_class.has_candidates?.should be_false
+                expect(described_class.has_candidates?).to be_falsey
             end
         end
     end
@@ -185,7 +185,7 @@ describe Arachni::Element::Capabilities::Analyzable::Timeout do
             end
             run
 
-            response.body.should be_empty
+            expect(response.body).to be_empty
         end
 
         context 'when element submission results in a response with a response time' do
@@ -197,7 +197,7 @@ describe Arachni::Element::Capabilities::Analyzable::Timeout do
                     end
                     run
 
-                    candidate.should be_true
+                    expect(candidate).to be_truthy
                 end
             end
 
@@ -216,7 +216,7 @@ describe Arachni::Element::Capabilities::Analyzable::Timeout do
                     end
                     run
 
-                    candidate.should be_nil
+                    expect(candidate).to be_nil
                 end
             end
         end
@@ -253,14 +253,14 @@ describe Arachni::Element::Capabilities::Analyzable::Timeout do
                 end
                 run
 
-                candidate.should be_true
+                expect(candidate).to be_truthy
 
                 verified = nil
                 candidate.timing_attack_verify( 1000 ) do
                     verified = true
                 end
 
-                verified.should be_nil
+                expect(verified).to be_nil
             end
         end
 
@@ -277,7 +277,7 @@ describe Arachni::Element::Capabilities::Analyzable::Timeout do
                     response = r
                 end
 
-                response.should be_kind_of Arachni::HTTP::Response
+                expect(response).to be_kind_of Arachni::HTTP::Response
             end
         end
 
@@ -299,14 +299,14 @@ describe Arachni::Element::Capabilities::Analyzable::Timeout do
                     end
                     run
 
-                    candidate.should be_true
+                    expect(candidate).to be_truthy
 
                     verified = nil
                     candidate.timing_attack_verify( 1000 ) do
                         verified = true
                     end
 
-                    verified.should be_nil
+                    expect(verified).to be_nil
                 end
             end
 
@@ -327,14 +327,14 @@ describe Arachni::Element::Capabilities::Analyzable::Timeout do
                     end
                     run
 
-                    candidate.should be_true
+                    expect(candidate).to be_truthy
 
                     verified = nil
                     candidate.timing_attack_verify( 1000 ) do
                         verified = true
                     end
 
-                    verified.should be_nil
+                    expect(verified).to be_nil
                 end
             end
         end
@@ -357,7 +357,7 @@ describe Arachni::Element::Capabilities::Analyzable::Timeout do
             )
             run
 
-            issues.first.remarks[:timing_attack].size.should == 3
+            expect(issues.first.remarks[:timing_attack].size).to eq(3)
         end
 
         context 'when the element action matches a skip rule' do
@@ -369,10 +369,10 @@ describe Arachni::Element::Capabilities::Analyzable::Timeout do
             end
 
             it 'returns false' do
-                subject.timeout_analysis(
+                expect(subject.timeout_analysis(
                     '__TIME__',
                     options.merge( timeout: 2000 )
-                ).should be_false
+                )).to be_falsey
             end
         end
 
@@ -393,8 +393,8 @@ describe Arachni::Element::Capabilities::Analyzable::Timeout do
                 run
 
                 issue = issues.first
-                issue.platform_name.should == :windows
-                issue.platform_type.should == :os
+                expect(issue.platform_name).to eq(:windows)
+                expect(issue.platform_type).to eq(:os)
             end
         end
 
@@ -410,8 +410,8 @@ describe Arachni::Element::Capabilities::Analyzable::Timeout do
                 c.timeout_analysis( '__TIME__', options.merge( timeout: 2000 ) )
                 run
 
-                issues.should be_any
-                issues.flatten.first.vector.seed.should == '8000'
+                expect(issues).to be_any
+                expect(issues.flatten.first.vector.seed).to eq('8000')
             end
         end
 
@@ -425,8 +425,8 @@ describe Arachni::Element::Capabilities::Analyzable::Timeout do
                 )
                 run
 
-                issues.should be_any
-                issues.flatten.first.vector.seed.should == '8'
+                expect(issues).to be_any
+                expect(issues.flatten.first.vector.seed).to eq('8')
             end
         end
 
@@ -445,8 +445,8 @@ describe Arachni::Element::Capabilities::Analyzable::Timeout do
                 )
                 run
 
-                issues.should be_any
-                issues.flatten.first.response.time.to_i.should == 11
+                expect(issues).to be_any
+                expect(issues.flatten.first.response.time.to_i).to eq(11)
             end
         end
     end

data/spec/arachni/element/capabilities/with_scope/scope_spec.rb

@@ -10,14 +10,14 @@ describe Arachni::Element::Capabilities::WithScope::Scope do
 
     describe '#out?' do
         it 'returns false' do
-            subject.should_not be_out
+            expect(subject).not_to be_out
         end
 
         context 'when #redundant?' do
             context 'is true' do
                 it 'returns true' do
-                    subject.stub(:redundant?) { true }
-                    subject.should be_out
+                    allow(subject).to receive(:redundant?) { true }
+                    expect(subject).to be_out
                 end
             end
         end
@@ -25,8 +25,8 @@ describe Arachni::Element::Capabilities::WithScope::Scope do
         context "when #{Arachni::OptionGroups::Audit}#element?" do
             context 'is false' do
                 it 'returns true' do
-                    Arachni::Options.audit.stub(:element?) { false }
-                    subject.should be_out
+                    allow(Arachni::Options.audit).to receive(:element?) { false }
+                    expect(subject).to be_out
                 end
             end
         end

data/spec/arachni/element/cookie/dom_spec.rb

@@ -1,12 +1,23 @@
 require 'spec_helper'
 
 describe Arachni::Element::Cookie::DOM do
-    it_should_behave_like 'element_dom', single_input: true, without_node: true
+    inputs = { 'param' => '1' }
+
+    it_should_behave_like 'element_dom'
+
+    it_should_behave_like 'submittable_dom'
+    it_should_behave_like 'inputtable_dom', single_input: true, inputs: inputs
+    it_should_behave_like 'mutable_dom',    single_input: true, inputs: inputs
+    it_should_behave_like 'auditable_dom'
 
     def auditable_extract_parameters( page )
         Hash[[page.document.css('#container').text.split( '=' )]]
     end
 
+    def run
+        auditor.browser_cluster.wait
+    end
+
     before :each do
         @framework = Arachni::Framework.new
         @page      = Arachni::Page.from_url( "#{url}/" )
@@ -18,7 +29,12 @@ describe Arachni::Element::Cookie::DOM do
         @framework.reset
     end
 
+    let(:auditor) { @auditor }
+
     subject { parent.dom }
+
+    let(:url) { web_server_url_for( :cookie_dom ) }
+
     let(:parent) do
         Arachni::Element::Cookie.new(
             action: "#{url}/",
@@ -30,8 +46,8 @@ describe Arachni::Element::Cookie::DOM do
             c.dom.auditor = auditor
         end
     end
-    let(:url) { web_server_url_for( :cookie_dom ) }
-    let(:auditor) { @auditor }
+
+
     let(:inputtable) do
         Arachni::Element::Cookie.new(
             action: "#{url}/",
@@ -46,37 +62,37 @@ describe Arachni::Element::Cookie::DOM do
 
     describe '#name' do
         it 'returns the cookie name' do
-            subject.name.should == parent.name
+            expect(subject.name).to eq(parent.name)
         end
     end
 
     describe '#value' do
         it 'returns the cookie value' do
-            subject.value.should == parent.value
+            expect(subject.value).to eq(parent.value)
         end
     end
 
     describe '#to_set_cookie' do
         it 'returns a string in a Set-Cookie response header format' do
-            subject.to_set_cookie.should == parent.to_set_cookie
+            expect(subject.to_set_cookie).to eq(parent.to_set_cookie)
         end
     end
 
     describe '#type' do
         it 'returns :cookie_dom' do
-            subject.type.should == :cookie_dom
+            expect(subject.type).to eq(:cookie_dom)
         end
     end
 
     describe '.type' do
         it 'returns :cookie_dom' do
-            described_class.type.should == :cookie_dom
+            expect(described_class.type).to eq(:cookie_dom)
         end
     end
 
     describe '#parent' do
         it 'returns the parent element' do
-            subject.parent.should be_kind_of Arachni::Element::Cookie
+            expect(subject.parent).to be_kind_of Arachni::Element::Cookie
         end
     end
 
@@ -91,45 +107,48 @@ describe Arachni::Element::Cookie::DOM do
 
                 subject.trigger
 
-                subject.inputs.should == auditable_extract_parameters( browser.to_page )
+                expect(subject.inputs).to eq(auditable_extract_parameters( browser.to_page ))
                 called = true
             end
 
             subject.auditor.browser_cluster.wait
-            called.should be_true
+            expect(called).to be_truthy
         end
 
         it 'returns a playable transition' do
             inputs = { 'param'  => 'The.Dude' }
             subject.update inputs
 
-            transition = nil
+            transitions = []
             called = false
             subject.with_browser do |browser|
                 subject.browser = browser
                 browser.load subject.page
 
-                transition = subject.trigger
+                transitions = subject.trigger
 
                 page = browser.to_page
 
-                subject.inputs.should == auditable_extract_parameters( page )
+                expect(subject.inputs).to eq(auditable_extract_parameters( page ))
                 called = true
             end
 
             subject.auditor.browser_cluster.wait
-            called.should be_true
+            expect(called).to be_truthy
 
             called = false
             auditor.with_browser do |browser|
                 browser.load subject.page
 
-                transition.play browser
-                auditable_extract_parameters( browser.to_page ).should == inputs
+                transitions.each do |transition|
+                    transition.play browser
+                end
+
+                expect(auditable_extract_parameters( browser.to_page )).to eq(inputs)
                 called = true
             end
             auditor.browser_cluster.wait
-            called.should be_true
+            expect(called).to be_truthy
         end
     end