arachni 1.2.1 → 1.3

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

@@ -1,12 +1,26 @@
 require 'spec_helper'
 
 describe Arachni::Element::Link::DOM do
-    it_should_behave_like 'element_dom', inputs: { 'param' => '1' }
+    inputs = { 'param' => '1' }
+
+    it_should_behave_like 'element_dom'
+
+    it_should_behave_like 'with_node'
+    it_should_behave_like 'with_auditor'
+
+    it_should_behave_like 'submittable_dom'
+    it_should_behave_like 'inputtable_dom', inputs: inputs
+    it_should_behave_like 'mutable_dom',    inputs: inputs
+    it_should_behave_like 'auditable_dom'
 
     def auditable_extract_parameters( page )
         { 'param' => page.document.css('#container').text }
     end
 
+    def run
+        auditor.browser_cluster.wait
+    end
+
     before :each do
         @framework = Arachni::Framework.new
         @page      = Arachni::Page.from_url( "#{url}/link" )
@@ -33,43 +47,43 @@ describe Arachni::Element::Link::DOM do
 
     describe '#type' do
         it 'returns :link_dom' do
-            subject.type.should == :link_dom
+            expect(subject.type).to eq(:link_dom)
         end
     end
 
     describe '.type' do
         it 'returns :link_dom' do
-            described_class.type.should == :link_dom
+            expect(described_class.type).to eq(:link_dom)
         end
     end
 
     describe '#parent' do
         it 'returns the parent element' do
-            subject.parent.should be_kind_of Arachni::Element::Link
+            expect(subject.parent).to be_kind_of Arachni::Element::Link
         end
     end
 
     describe '#inputs' do
         it 'parses query-style inputs from URL fragments' do
-            subject.inputs.should == { 'param' => 'some-name' }
+            expect(subject.inputs).to eq({ 'param' => 'some-name' })
         end
     end
 
     describe '#fragment' do
         it 'returns the URL fragment' do
-            subject.fragment.should == '/test/?param=some-name'
+            expect(subject.fragment).to eq('/test/?param=some-name')
         end
     end
 
     describe '#fragment_path' do
         it 'returns the path from the URL fragment' do
-            subject.fragment_path.should == '/test/'
+            expect(subject.fragment_path).to eq('/test/')
         end
     end
 
     describe '#fragment_query' do
         it 'returns the query from the URL fragment' do
-            subject.fragment_query.should == 'param=some-name'
+            expect(subject.fragment_query).to eq('param=some-name')
         end
     end
 
@@ -81,17 +95,17 @@ describe Arachni::Element::Link::DOM do
                 browser.load subject.page
 
                 element = subject.locate
-                element.should be_kind_of Watir::HTMLElement
+                expect(element).to be_kind_of Watir::HTMLElement
 
-                parent.class.from_document(
+                expect(parent.class.from_document(
                     parent.url, Nokogiri::HTML(element.html)
-                ).first.should == parent
+                ).first).to eq(parent)
 
                 called = true
             end
 
             subject.auditor.browser_cluster.wait
-            called.should be_true
+            expect(called).to be_truthy
         end
     end
 
@@ -106,69 +120,73 @@ describe Arachni::Element::Link::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
-                auditable_extract_parameters( browser.to_page ).should ==
+                expect(auditable_extract_parameters( browser.to_page )).to eq(
                     { 'param' => '' }
+                )
+
+                transitions.each do |transition|
+                    transition.play browser
+                end
 
-                transition.play browser
-                auditable_extract_parameters( browser.to_page ).should == inputs
+                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
 
     describe '.data_from_node' do
         it 'returns a hash with DOM data' do
-            described_class.data_from_node( subject.node ).should == {
+            expect(described_class.data_from_node( subject.node )).to eq({
                 inputs:         {
                     'param' => 'some-name'
                 },
                 fragment:       '/test/?param=some-name',
                 fragment_path:  '/test/',
                 fragment_query: 'param=some-name'
-            }
+            })
         end
 
         it 'decodes inputs' do
             html = "<a href='#/?stuff%20here=bl%20ah'>Stuff</a>"
             node = Nokogiri::HTML.fragment(html).children.first
 
-            described_class.data_from_node( node )[:inputs].should == {
+            expect(described_class.data_from_node( node )[:inputs]).to eq({
                 'stuff here' => 'bl ah'
-            }
+            })
         end
 
         context 'when there is no URL fragment' do
@@ -178,7 +196,7 @@ describe Arachni::Element::Link::DOM do
             end
 
             it 'return nil' do
-                described_class.data_from_node( node ).should be_nil
+                expect(described_class.data_from_node( node )).to be_nil
             end
         end
 
@@ -189,7 +207,7 @@ describe Arachni::Element::Link::DOM do
             end
 
             it 'return nil' do
-                described_class.data_from_node( node ).should be_nil
+                expect(described_class.data_from_node( node )).to be_nil
             end
         end
     end

data/spec/arachni/element/link_spec.rb

@@ -4,11 +4,29 @@ describe Arachni::Element::Link do
     html = '<a href="/stuff#?stuff=blah">Bla</a>'
 
     it_should_behave_like 'element'
-    it_should_behave_like 'with_node', html
+    it_should_behave_like 'with_node'
     it_should_behave_like 'with_dom',  html
     it_should_behave_like 'refreshable'
+    it_should_behave_like 'with_source'
+    it_should_behave_like 'with_auditor'
+
+    it_should_behave_like 'submittable'
+    it_should_behave_like 'inputtable'
+    it_should_behave_like 'mutable'
     it_should_behave_like 'auditable'
 
+    before :each do
+        @framework ||= Arachni::Framework.new
+        @auditor     = Auditor.new( Arachni::Page.from_url( url ), @framework )
+    end
+
+    after :each do
+        @framework.reset
+        reset_options
+    end
+
+    let(:auditor) { @auditor }
+
     def auditable_extract_parameters( resource )
         YAML.load( resource.body )
     end
@@ -31,19 +49,19 @@ describe Arachni::Element::Link do
     end
 
     it 'is assigned to Arachni::Link for easy access' do
-        Arachni::Link.should == described_class
+        expect(Arachni::Link).to eq(described_class)
     end
 
     describe '#initialize' do
         describe :action do
             it 'sets #action' do
                 action = "#{url}stuff"
-                described_class.new( url: url, action: action ).action.should == action
+                expect(described_class.new( url: url, action: action ).action).to eq(action)
             end
 
             context 'when nil' do
                 it 'defaults to :url' do
-                    described_class.new( url: url ).action.should == url
+                    expect(described_class.new( url: url ).action).to eq(url)
                 end
             end
         end
@@ -72,11 +90,11 @@ describe Arachni::Element::Link do
         end
 
         it 'removes the URL query' do
-            subject.action.should == url
+            expect(subject.action).to eq(url)
         end
 
         it 'merges the URL query parameters with the given :inputs' do
-            subject.inputs.should == query_inputs.merge( option_inputs )
+            expect(subject.inputs).to eq(query_inputs.merge( option_inputs ))
         end
 
         context 'when URL query parameters and :inputs have the same name' do
@@ -88,7 +106,7 @@ describe Arachni::Element::Link do
             end
 
             it 'it gives precedence to the :inputs' do
-                subject.inputs.should == query_inputs.merge( option_inputs )
+                expect(subject.inputs).to eq(query_inputs.merge( option_inputs ))
             end
         end
 
@@ -100,9 +118,9 @@ describe Arachni::Element::Link do
                     url:    url,
                     action: "#{url}/articles/some-stuff/23"
                 )
-                link.action.should == url + 'articles.php'
-                link.url.should == url
-                link.inputs.should == { 'id'  => '23' }
+                expect(link.action).to eq(url + 'articles.php')
+                expect(link.url).to eq(url)
+                expect(link.inputs).to eq({ 'id'  => '23' })
             end
         end
     end
@@ -111,33 +129,33 @@ describe Arachni::Element::Link do
         context 'when there are no DOM#inputs' do
             it 'returns nil' do
                 subject.source = '<a href="/stuff">Bla</a>'
-                subject.dom.should be_nil
+                expect(subject.dom).to be_nil
             end
         end
 
         context 'when there is no #node' do
             it 'returns nil' do
                 subject.source = nil
-                subject.dom.should be_nil
+                expect(subject.dom).to be_nil
             end
         end
     end
 
     describe '#simple' do
         it 'should return a simplified version as a hash' do
-            subject.simple.should == { subject.action => subject.inputs }
+            expect(subject.simple).to eq({ subject.action => subject.inputs })
         end
     end
 
     describe '#to_s' do
         it 'returns a URL' do
-            subject.to_s.should == "#{subject.action}?name1=value1&name2=value2"
+            expect(subject.to_s).to eq("#{subject.action}?name1=value1&name2=value2")
         end
     end
 
     describe '#type' do
         it 'should be "link"' do
-            subject.type.should == :link
+            expect(subject.type).to eq(:link)
         end
     end
 
@@ -149,7 +167,7 @@ describe Arachni::Element::Link do
             c = subject.dup
             c.source = '<a href="/stuff#?stuff=blooh">Bla</a>'
 
-            c.coverage_id.should == e.coverage_id
+            expect(c.coverage_id).to eq(e.coverage_id)
 
             e = subject.dup
             e.source = '<a href="/stuff#?stuff=blah">Bla</a>'
@@ -157,7 +175,7 @@ describe Arachni::Element::Link do
             c = subject.dup
             c.source = '<a href="/stuff#?stuff2=blooh">Bla</a>'
 
-            c.coverage_id.should_not == e.coverage_id
+            expect(c.coverage_id).not_to eq(e.coverage_id)
         end
     end
 
@@ -169,7 +187,7 @@ describe Arachni::Element::Link do
             c = subject.dup
             c.source = '<a href="/stuff#?stuff=blah">Bla</a>'
 
-            c.id.should == e.id
+            expect(c.id).to eq(e.id)
 
             e = subject.dup
             e.source = '<a href="/stuff#?stuff=blah">Bla</a>'
@@ -177,23 +195,23 @@ describe Arachni::Element::Link do
             c = subject.dup
             c.source = '<a href="/stuff#?stuff=blooh">Bla</a>'
 
-            c.id.should_not == e.id
+            expect(c.id).not_to eq(e.id)
         end
     end
 
     describe '#to_rpc_data' do
         it "does not include 'dom_data'" do
             subject.source = html
-            subject.dom.should be_true
+            expect(subject.dom).to be_truthy
 
-            subject.to_rpc_data.should_not include 'dom_data'
+            expect(subject.to_rpc_data).not_to include 'dom_data'
         end
     end
 
     describe '.from_document' do
         context 'when the response does not contain any links' do
             it 'should return an empty array' do
-                described_class.from_document( '', '' ).should be_empty
+                expect(described_class.from_document( '', '' )).to be_empty
             end
         end
         context 'when links have actions that are out of scope' do
@@ -210,8 +228,8 @@ describe Arachni::Element::Link do
                 Arachni::Options.scope.exclude_path_patterns = [/exclude/]
 
                 links = described_class.from_document( url, html )
-                links.size.should == 1
-                links.first.action.should == url + 'stuff'
+                expect(links.size).to eq(1)
+                expect(links.first.action).to eq(url + 'stuff')
             end
         end
         context 'when the response contains links' do
@@ -224,12 +242,12 @@ describe Arachni::Element::Link do
                 </html>'
 
                 link = described_class.from_document( url, html ).first
-                link.action.should == url + 'test2'
-                link.url.should == url
-                link.inputs.should == {
+                expect(link.action).to eq(url + 'test2')
+                expect(link.url).to eq(url)
+                expect(link.inputs).to eq({
                     'param_one'  => 'value_one',
                     'param_two'  => 'value_two'
-                }
+                })
             end
             context 'and includes a base attribute' do
                 it 'should return an array of links with adjusted URIs' do
@@ -245,12 +263,12 @@ describe Arachni::Element::Link do
                     </html>'
 
                     link = described_class.from_document( url, html ).first
-                    link.action.should == base_url + 'test'
-                    link.url.should == url
-                    link.inputs.should == {
+                    expect(link.action).to eq(base_url + 'test')
+                    expect(link.url).to eq(url)
+                    expect(link.inputs).to eq({
                         'param_one'  => 'value_one',
                         'param_two'  => 'value_two'
-                    }
+                    })
                 end
             end
         end
@@ -273,7 +291,7 @@ describe Arachni::Element::Link do
                 let(:size) { described_class::MAX_SIZE }
 
                 it 'returns empty array' do
-                    link.should be_nil
+                    expect(link).to be_nil
                 end
             end
 
@@ -281,7 +299,7 @@ describe Arachni::Element::Link do
                 let(:size) { described_class::MAX_SIZE + 1 }
 
                 it 'sets empty value' do
-                    link.should be_nil
+                    expect(link).to be_nil
                 end
             end
 
@@ -289,7 +307,7 @@ describe Arachni::Element::Link do
                 let(:size) { described_class::MAX_SIZE - 1 }
 
                 it 'leaves the values alone' do
-                    link.inputs['param'].should_not be_empty
+                    expect(link.inputs['param']).not_to be_empty
                 end
             end
         end
@@ -298,26 +316,26 @@ describe Arachni::Element::Link do
     describe '.encode' do
         it 'URL-encodes the passed string' do
             v = '% value\ +=&;'
-            described_class.encode( v ).should == '%25%20value%5C%20%2B%3D%26%3B'
+            expect(described_class.encode( v )).to eq('%25%20value%5C%20%2B%3D%26%3B')
         end
     end
     describe '#encode' do
         it 'URL-encodes the passed string' do
             v = '% value\ +=&;'
-            subject.encode( v ).should == described_class.encode( v )
+            expect(subject.encode( v )).to eq(described_class.encode( v ))
         end
     end
 
     describe '.decode' do
         it 'URL-decodes the passed string' do
             v = '%25%20value%5C%20%2B%3D%26%3B'
-            described_class.decode( v ).should == URI.decode( v )
+            expect(described_class.decode( v )).to eq(URI.decode( v ))
         end
     end
     describe '#decode' do
         it 'URL-decodes the passed string' do
             v = '%25%20value%5C%20%2B%3D%26%3B'
-            subject.decode( v ).should == described_class.decode( v )
+            expect(subject.decode( v )).to eq(described_class.decode( v ))
         end
     end
 
@@ -327,7 +345,7 @@ describe Arachni::Element::Link do
                 url:  url + '/?param=val',
                 body: '<a href="test?param_one=value_one&param_two=value_two"></a>'
             )
-            described_class.from_response( res ).size.should == 2
+            expect(described_class.from_response( res ).size).to eq(2)
         end
     end
 end