arachni 1.2.1 → 1.3

data/spec/support/shared/element/capabilities/refreshable.rb

@@ -11,9 +11,9 @@ shared_examples_for 'refreshable' do
                     http.get( refreshable_url + '_disappear_clear', mode: :sync )
 
                     response = http.get( refreshable_url + '_disappear', mode: :sync )
-                    refreshable.from_response( response ).select do |f|
+                    expect(refreshable.from_response( response ).select do |f|
                         !!f.inputs['nonce']
-                    end.first.refresh.should be_nil
+                    end.first.refresh).to be_nil
                 end
             end
 
@@ -25,7 +25,7 @@ shared_examples_for 'refreshable' do
                     refreshable.from_response( response ).select do |f|
                         !!f.inputs['nonce']
                     end.first.refresh do |r|
-                        r.should be_nil
+                        expect(r).to be_nil
                     end
                 end
             end
@@ -44,11 +44,11 @@ shared_examples_for 'refreshable' do
                 f.update updates
 
                 refreshed = f.refresh
-                refreshed.inputs['nonce'].should_not     == nonce
-                refreshed.default_inputs['nonce'].should == nonce
+                expect(refreshed.inputs['nonce']).not_to     eq(nonce)
+                expect(refreshed.default_inputs['nonce']).to eq(nonce)
 
                 updates['nonce'] = f.refresh.inputs['nonce']
-                f.inputs.should == updates
+                expect(f.inputs).to eq(updates)
             end
         end
         context 'when called with a block' do
@@ -65,17 +65,17 @@ shared_examples_for 'refreshable' do
 
                 ran = false
                 f.refresh do |form|
-                    form.inputs['nonce'].should_not     == nonce
-                    form.default_inputs['nonce'].should == nonce
+                    expect(form.inputs['nonce']).not_to     eq(nonce)
+                    expect(form.default_inputs['nonce']).to eq(nonce)
 
                     updates['nonce'] = form.refresh.inputs['nonce']
-                    form.inputs.should == updates
+                    expect(form.inputs).to eq(updates)
 
                     ran = true
                 end
 
                 http.run
-                ran.should be_true
+                expect(ran).to be_truthy
             end
         end
     end

data/spec/support/shared/element/capabilities/{submitable.rb → submittable.rb}

@@ -18,7 +18,7 @@ shared_examples_for 'submittable' do
 
         rpc_attributes.each do |attribute|
             it "includes '#{attribute}'" do
-                data[attribute].should == submittable.send( attribute )
+                expect(data[attribute]).to eq(submittable.send( attribute ))
             end
         end
     end
@@ -29,7 +29,7 @@ shared_examples_for 'submittable' do
 
         rpc_attributes.each do |attribute|
             it "restores '#{attribute}'" do
-                restored.send( attribute ).should == submittable.send( attribute )
+                expect(restored.send( attribute )).to eq(submittable.send( attribute ))
             end
         end
     end
@@ -37,34 +37,34 @@ shared_examples_for 'submittable' do
     describe '#method' do
         it 'returns the HTTP method' do
             submittable.method = :stuff
-            submittable.method.should == :stuff
+            expect(submittable.method).to eq(:stuff)
         end
     end
 
     describe '#http_method' do
         it 'is aliased to #method' do
             submittable.method = :stuff
-            submittable.http_method.should == :stuff
+            expect(submittable.http_method).to eq(:stuff)
         end
     end
 
     describe '#method=' do
         it 'returns the HTTP method' do
             submittable.method = :stuff
-            submittable.http_method.should == :stuff
+            expect(submittable.http_method).to eq(:stuff)
         end
     end
 
     describe '#http_method=' do
         it 'is aliased to #method=' do
             submittable.http_method = :stuff
-            submittable.method.should == :stuff
+            expect(submittable.method).to eq(:stuff)
         end
     end
 
     describe '#platforms' do
         it 'returns platforms for the given element' do
-            submittable.platforms.should be_kind_of Arachni::Platform::Manager
+            expect(submittable.platforms).to be_kind_of Arachni::Platform::Manager
         end
     end
 
@@ -77,7 +77,7 @@ shared_examples_for 'submittable' do
             end
 
             run
-            submittable.inputs.should == submitted
+            expect(submittable.inputs).to eq(submitted)
         end
 
         it 'assigns the auditable element as the request performer' do
@@ -85,46 +85,46 @@ shared_examples_for 'submittable' do
             submittable.submit { |res| response = res }
 
             run
-            response.request.performer.should == submittable
+            expect(response.request.performer).to eq(submittable)
         end
     end
 
     describe '#id' do
         before do
-            described_class.any_instance.stub(:valid_input_name?) { true }
-            described_class.any_instance.stub(:valid_input_value?) { true }
+            allow_any_instance_of(described_class).to receive(:valid_input_name?) { true }
+            allow_any_instance_of(described_class).to receive(:valid_input_value?) { true }
         end
 
         let(:action) { "#{url}/action" }
 
         it 'uniquely identifies the element based on #action' do
             e = submittable.dup
-            e.stub(:action) { action }
+            allow(e).to receive(:action) { action }
 
             c = submittable.dup
-            c.stub(:action) { "#{action}2" }
+            allow(c).to receive(:action) { "#{action}2" }
 
-            e.id.should_not == c.id
+            expect(e.id).not_to eq(c.id)
         end
 
         it 'uniquely identifies the element based on #method' do
             e = submittable.dup
-            e.stub(:method) { :get }
+            allow(e).to receive(:method) { :get }
 
             c = submittable.dup
-            c.stub(:method) { :post }
+            allow(c).to receive(:method) { :post }
 
-            e.id.should_not == c.id
+            expect(e.id).not_to eq(c.id)
         end
 
         it 'uniquely identifies the element based on #type' do
             e = submittable.dup
-            e.stub(:type) { :stuff }
+            allow(e).to receive(:type) { :stuff }
 
             c = submittable.dup
-            c.stub(:type) { :stoof }
+            allow(c).to receive(:type) { :stoof }
 
-            e.id.should_not == c.id
+            expect(e.id).not_to eq(c.id)
         end
 
         it 'uniquely identifies the element based on #inputs' do
@@ -134,7 +134,7 @@ shared_examples_for 'submittable' do
             c = submittable.dup
             c.inputs = { input1: 'stuff2' }
 
-            e.id.should_not == c.id
+            expect(e.id).not_to eq(c.id)
         end
     end
 
@@ -142,19 +142,19 @@ shared_examples_for 'submittable' do
         let(:dupped) { submittable.dup }
 
         it 'preserves #method' do
-            dupped.method.should == submittable.method
+            expect(dupped.method).to eq(submittable.method)
         end
         it 'preserves #action' do
-            dupped.action.should == submittable.action
+            expect(dupped.action).to eq(submittable.action)
         end
     end
 
     describe '#to_h' do
         it 'returns a hash representation of self' do
             hash = submittable.to_h
-            hash[:url].should    == submittable.url
-            hash[:action].should == submittable.action
-            hash[:method].should == submittable.method
+            expect(hash[:url]).to    eq(submittable.url)
+            expect(hash[:action]).to eq(submittable.action)
+            expect(hash[:method]).to eq(submittable.method)
         end
     end
 end

data/spec/support/shared/element/capabilities/with_auditor.rb

@@ -22,42 +22,42 @@ shared_examples_for 'with_auditor' do
         let(:data) { auditable.to_rpc_data }
 
         it "does not include 'auditor'" do
-            data.should_not include 'auditor'
+            expect(data).not_to include 'auditor'
         end
     end
 
     describe '#prepare_for_report' do
         it 'removes the #auditor' do
-            auditable.auditor.should be_true
+            expect(auditable.auditor).to be_truthy
             auditable.prepare_for_report
-            auditable.auditor.should be_nil
+            expect(auditable.auditor).to be_nil
         end
     end
 
     describe '#marshal_dump' do
         it 'excludes @auditor' do
-            auditable.marshal_dump.should_not include :@auditor
+            expect(auditable.marshal_dump).not_to include :@auditor
         end
     end
 
     describe '#remove_auditor' do
         it 'removes the auditor' do
             auditable.auditor = :some_auditor
-            auditable.auditor.should == :some_auditor
+            expect(auditable.auditor).to eq(:some_auditor)
             auditable.remove_auditor
-            auditable.auditor.should be_nil
+            expect(auditable.auditor).to be_nil
         end
     end
 
     describe '#orphan?' do
         context 'when it has no auditor' do
             it 'returns true' do
-                orphan.orphan?.should be_true
+                expect(orphan.orphan?).to be_truthy
             end
         end
         context 'when it has an auditor' do
             it 'returns true' do
-                auditable.orphan?.should be_false
+                expect(auditable.orphan?).to be_falsey
             end
         end
     end
@@ -66,10 +66,10 @@ shared_examples_for 'with_auditor' do
         let(:dupped) { auditable.dup }
 
         it 'preserves the #auditor' do
-            dupped.auditor.should == auditable.auditor
+            expect(dupped.auditor).to eq(auditable.auditor)
 
             subject.remove_auditor
-            dup.auditor.should be_true
+            expect(dup.auditor).to be_truthy
         end
     end
 end

data/spec/support/shared/element/capabilities/with_dom.rb

@@ -16,7 +16,7 @@ shared_examples_for 'with_dom' do |html = nil|
                 end
 
                 it 'forces #dom to return nil' do
-                    with_dom.dom.should be_nil
+                    expect(with_dom.dom).to be_nil
                 end
             end
 
@@ -26,7 +26,7 @@ shared_examples_for 'with_dom' do |html = nil|
                 end
 
                 it 'forces #dom to return nil' do
-                    with_dom.dom.should be_true
+                    expect(with_dom.dom).to be_truthy
                 end
             end
         end
@@ -40,7 +40,7 @@ shared_examples_for 'with_dom' do |html = nil|
                 end
 
                 it 'returns true' do
-                    with_dom.skip_dom?.should be_true
+                    expect(with_dom.skip_dom?).to be_truthy
                 end
             end
 
@@ -50,7 +50,7 @@ shared_examples_for 'with_dom' do |html = nil|
                 end
 
                 it 'forces #dom to return nil' do
-                    with_dom.skip_dom?.should be_false
+                    expect(with_dom.skip_dom?).to be_falsey
                 end
             end
         end
@@ -59,7 +59,7 @@ shared_examples_for 'with_dom' do |html = nil|
         let(:data) { with_dom.to_rpc_data }
 
         it "includes 'dom'" do
-            data['dom'].should == with_dom.dom.to_rpc_data
+            expect(data['dom']).to eq(with_dom.dom.to_rpc_data)
         end
     end
 
@@ -68,13 +68,13 @@ shared_examples_for 'with_dom' do |html = nil|
         let(:data) { Arachni::RPC::Serializer.rpc_data( with_dom ) }
 
         it "restores 'dom'" do
-            restored.dom.should == with_dom.dom
+            expect(restored.dom).to eq(with_dom.dom)
         end
     end
 
     describe '#dom' do
         it "returns #{described_class::DOM}" do
-            with_dom.dom.should be_kind_of described_class::DOM
+            expect(with_dom.dom).to be_kind_of described_class::DOM
         end
     end
 
@@ -82,7 +82,7 @@ shared_examples_for 'with_dom' do |html = nil|
         let(:dupped) { with_dom.dup }
 
         it 'preserves #dom' do
-            dupped.dom.should == with_dom.dom
+            expect(dupped.dom).to eq(with_dom.dom)
         end
     end
 end

data/spec/support/shared/element/capabilities/with_node.rb

@@ -2,16 +2,14 @@ shared_examples_for 'with_node' do |html|
     it_should_behave_like 'with_source', html
 
     let(:with_node) do
-        dupped = subject.dup
-        dupped.source = html
-        dupped
+        subject.dup
     end
 
     describe '#node' do
         it 'returns the set node' do
             node = with_node.node
-            node.is_a?( Nokogiri::XML::Element ).should be_true
-            node.to_s.should == Nokogiri::HTML.fragment( html ).to_s
+            expect(node.is_a?( Nokogiri::XML::Element )).to be_truthy
+            expect(node.to_s).to eq(Nokogiri::HTML.fragment( with_node.source ).to_s)
         end
     end
 
@@ -19,7 +17,7 @@ shared_examples_for 'with_node' do |html|
         let(:dupped) { with_node.dup }
 
         it 'preserves #node' do
-            dupped.node.to_s.should == with_node.node.to_s
+            expect(dupped.node.to_s).to eq(with_node.node.to_s)
         end
     end
 end

data/spec/support/shared/element/capabilities/with_scope.rb

@@ -10,13 +10,13 @@ shared_examples_for 'with_scope' do
         let(:data) { with_scope.to_rpc_data }
 
         it "does not include 'scope'" do
-            data.should_not include 'scope'
+            expect(data).not_to include 'scope'
         end
     end
 
     describe '#scope' do
         it 'returns scope' do
-            subject.scope.should be_kind_of described_class::Scope
+            expect(subject.scope).to be_kind_of described_class::Scope
         end
     end
 end

data/spec/support/shared/element/capabilities/with_source.rb

@@ -1,16 +1,14 @@
 shared_examples_for 'with_source' do |source|
 
     let(:with_source) do
-        dupped = subject.dup
-        dupped.source = source if source
-        dupped
+        subject.dup
     end
 
     describe '#to_rpc_data' do
         let(:data) { with_source.to_rpc_data }
 
         it "includes 'source'" do
-            data['source'].should == with_source.source
+            expect(data['source']).to eq(with_source.source)
         end
     end
 
@@ -26,14 +24,14 @@ shared_examples_for 'with_source' do |source|
 
                 it 'sets the #source' do
                     with_source.source = string
-                    with_source.source.should == string
+                    expect(with_source.source).to eq(string)
                 end
             end
 
             context 'nil' do
                 it 'sets the #html' do
                     with_source.source = nil
-                    with_source.source.should be_nil
+                    expect(with_source.source).to be_nil
                 end
             end
         end
@@ -41,7 +39,7 @@ shared_examples_for 'with_source' do |source|
 
     describe '#to_h' do
         it "includes 'source'" do
-            subject.to_h[:source].should == subject.source
+            expect(subject.to_h[:source]).to eq(subject.source)
         end
     end
 
@@ -49,7 +47,7 @@ shared_examples_for 'with_source' do |source|
         let(:dupped) { with_source.dup }
 
         it 'preserves #source' do
-            dupped.source.should == with_source.source
+            expect(dupped.source).to eq(with_source.source)
         end
     end
 end

data/spec/support/shared/element/dom.rb

@@ -0,0 +1,144 @@
+shared_examples_for 'element_dom' do
+    it_should_behave_like 'element'
+
+    def run
+        auditor.browser_cluster.wait
+    end
+
+    it "supports #{Arachni::RPC::Serializer}" do
+        expect(subject).to eq(Arachni::RPC::Serializer.deep_clone( subject ))
+    end
+
+    describe '#to_rpc_data' do
+        %w(parent page browser element).each do |attribute|
+            it "excludes #{attribute}" do
+                called = false
+
+                # We do this inside a #submit handler to make sure the associations
+                # which are added during a submit are handled successfully.
+                subject.submit do
+                    expect(subject.to_rpc_data).not_to include attribute
+                    called = true
+                end
+                run
+
+                expect(called).to be_truthy
+            end
+        end
+    end
+
+    describe '#marshal_dump' do
+        [:@parent, :@page, :@browser, :@element].each do |ivar|
+            it "excludes #{ivar}" do
+                called = false
+
+                # We do this inside a #submit handler to make sure the associations
+                # which are added during a submit are handled successfully.
+                subject.submit do
+                    expect(subject.marshal_dump).not_to include ivar
+                    called = true
+                end
+                run
+
+                expect(called).to be_truthy
+            end
+        end
+    end
+
+    describe '#prepare_for_report' do
+        it 'removes #page' do
+            expect(subject.page).to be_truthy
+            subject.prepare_for_report
+            expect(subject.page).to be_nil
+        end
+        it 'removes #parent' do
+            expect(subject.parent).to be_truthy
+            subject.prepare_for_report
+            expect(subject.parent).to be_nil
+        end
+        it 'removes #browser' do
+            called = false
+            subject.with_browser do |browser|
+                subject.browser = browser
+
+                expect(subject.browser).to be_truthy
+                subject.prepare_for_report
+                expect(subject.browser).to be_nil
+
+                called = true
+            end
+            subject.auditor.browser_cluster.wait
+            expect(called).to be_truthy
+        end
+    end
+
+    describe '#trigger' do
+        it 'does not update the page transitions' do
+            page = nil
+            pre_transitions = nil
+            subject.with_browser do |browser|
+                browser.load subject.page
+                subject.browser = browser
+                pre_transitions = browser.transitions.dup
+
+                subject.trigger
+                page = browser.to_page
+            end
+
+            subject.auditor.browser_cluster.wait
+            expect(page.dom.transitions).to eq(pre_transitions)
+        end
+    end
+
+    describe '#valid_input_data?' do
+        it 'returns true' do
+            expect(subject.valid_input_data?( 'stuff' )).to be_truthy
+        end
+
+        described_class::INVALID_INPUT_DATA.each do |invalid_data|
+            context "when the value contains #{invalid_data.inspect}" do
+                it 'returns false' do
+                    expect(subject.valid_input_data?( "stuff #{invalid_data}" )).to be_falsey
+                end
+            end
+        end
+    end
+
+    describe '#page' do
+        it 'returns the page containing the element' do
+            expect(subject.page).to be_kind_of Arachni::Page
+        end
+    end
+
+    describe '#encode' do
+        it 'returns the string as is' do
+            v = 'blah'
+            expect(subject.encode( v ).object_id).to eq(v.object_id)
+        end
+    end
+    describe '.encode' do
+        it 'returns the string as is' do
+            v = 'blah'
+            expect(subject.class.encode( v ).object_id).to eq(v.object_id)
+        end
+    end
+
+    describe '#decode' do
+        it 'returns the string as is' do
+            v = 'blah'
+            expect(subject.decode( v ).object_id).to eq(v.object_id)
+        end
+    end
+    describe '.decode' do
+        it 'returns the string as is' do
+            v = 'blah'
+            expect(subject.class.decode( v ).object_id).to eq(v.object_id)
+        end
+    end
+
+    describe '#dup' do
+        it 'preserves the #parent' do
+            expect(subject.dup.parent).to eq(subject.parent)
+        end
+    end
+end