arachni 1.2.1 → 1.3

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

@@ -0,0 +1,42 @@
+shared_examples_for 'auditable_dom' do
+    it_should_behave_like 'auditable'
+
+    describe '#with_browser_cluster' do
+        context 'when a browser cluster is' do
+            context 'available' do
+                it 'passes a BrowserCluster to the given block' do
+                    worker = nil
+
+                    subject.with_browser_cluster do |cluster|
+                        worker = cluster
+                    end
+
+                    expect(worker).to eq(subject.auditor.browser_cluster)
+                end
+            end
+        end
+    end
+
+    describe '#with_browser' do
+        context 'when a browser cluster is' do
+            context 'available' do
+                it 'passes a BrowserCluster::Worker to the given block' do
+                    worker = nil
+
+                    expect(subject.with_browser do |browser|
+                        worker = browser
+                    end).to be_truthy
+                    subject.auditor.browser_cluster.wait
+
+                    expect(worker).to be_kind_of Arachni::BrowserCluster::Worker
+                end
+            end
+        end
+    end
+
+    describe '#auditor' do
+        it 'returns the assigned auditor' do
+            expect(subject.auditor).to be_kind_of Arachni::Check::Auditor
+        end
+    end
+end

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

@@ -0,0 +1,5 @@
+shared_examples_for 'inputtable_dom' do |options = {}|
+    it_should_behave_like 'inputtable', options
+
+    it 'does not support null bytes'
+end

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

@@ -0,0 +1,3 @@
+shared_examples_for 'mutable_dom' do |options = {}|
+    it_should_behave_like 'mutable', options.merge( supports_nulls: false )
+end

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

@@ -0,0 +1,119 @@
+shared_examples_for 'submittable_dom' do
+    it_should_behave_like 'submittable'
+
+    describe '#submit' do
+        it 'submits the element' do
+            inputs = { subject.inputs.keys.first => subject.inputs.values.first + '1' }
+            subject.inputs = inputs
+
+            called = false
+            subject.submit do |page|
+                expect(inputs).to eq(auditable_extract_parameters( page ))
+                called = true
+            end
+
+            subject.auditor.browser_cluster.wait
+            expect(called).to be_truthy
+        end
+
+        it 'sets the #performer on the returned page' do
+            called = false
+            subject.submit do |page|
+                expect(page.performer).to be_kind_of described_class
+                called = true
+            end
+
+            subject.auditor.browser_cluster.wait
+            expect(called).to be_truthy
+        end
+
+        it 'sets the #browser on the #performer' do
+            called = false
+            subject.submit do |page|
+                expect(page.performer.browser).to be_kind_of Arachni::BrowserCluster::Worker
+                called = true
+            end
+
+            subject.auditor.browser_cluster.wait
+            expect(called).to be_truthy
+        end
+
+        it 'sets the #element on the #performer',
+           if: described_class.ancestors.include?( Arachni::Element::Capabilities::WithNode ) do
+
+            called = false
+            subject.submit do |page|
+                expect(page.performer.element).to be_kind_of Watir::HTMLElement
+                called = true
+            end
+
+            subject.auditor.browser_cluster.wait
+            expect(called).to be_truthy
+        end
+
+        it 'adds the submission transitions to the Page::DOM#transitions' do
+            transitions = []
+            subject.with_browser do |browser|
+                subject.browser = browser
+                browser.load subject.page
+                transitions = subject.trigger
+            end
+            subject.auditor.browser_cluster.wait
+
+            submitted_page = nil
+            subject.dup.submit do |page|
+                submitted_page = page
+            end
+            subject.auditor.browser_cluster.wait
+
+            transitions.each do |transition|
+                expect(subject.page.dom.transitions).not_to include transition
+                expect(submitted_page.dom.transitions).to include transition
+            end
+        end
+
+        context 'when the element could not be submitted' do
+            it 'does not call the block' do
+                allow(subject).to receive( :trigger ) { false }
+
+                called = false
+                subject.submit do
+                    called = true
+                end
+                subject.auditor.browser_cluster.wait
+                expect(called).to be_falsey
+            end
+        end
+
+        describe :options do
+            describe :custom_code do
+                it 'injects the given code' do
+                    called = false
+                    title = 'Injected title'
+
+                    subject.submit custom_code: "document.title = #{title.inspect}" do |page|
+                        expect(page.document.css('title').text).to eq(title)
+                        called = true
+                    end
+
+                    subject.auditor.browser_cluster.wait
+                    expect(called).to be_truthy
+                end
+            end
+
+            describe :taint do
+                it 'sets the Browser::Javascript#taint' do
+                    taint = Arachni::Utilities.generate_token
+
+                    set_taint = nil
+                    subject.submit taint: taint do |page|
+                        set_taint = page.performer.browser.javascript.taint
+                    end
+
+                    subject.auditor.browser_cluster.wait
+                    expect(set_taint).to eq(taint)
+                end
+            end
+        end
+    end
+end

data/spec/support/shared/external/wavsep.rb

@@ -69,9 +69,9 @@ shared_examples_for 'wavsep' do
                         test_cases( http_method ).each do |description, info|
                             context description do
                                 it "logs #{(info[:vulnerable] || []).size + (info[:vulnerable_absolute] || []).size} unique resources using #{[info[:checks]].flatten.join( ', ' )}" do
-                                    pending "'WAVSEP_URL' env variable has not been set." if !wavsep_url
+                                    skip "'WAVSEP_URL' env variable has not been set." if !wavsep_url
 
-                                    Arachni::Data.issues.should be_empty
+                                    expect(Arachni::Data.issues).to be_empty
 
                                     if info[:root_url]
                                         @framework.options.url = wavsep_url
@@ -96,7 +96,7 @@ shared_examples_for 'wavsep' do
                                     # pp resources.map { |u| u.gsub( @framework.options.url, '' ) }
                                     # puts format_error( urls, resources, expected )
 
-                                    resources.should eq(expected), format_error( urls, resources, expected )
+                                    expect(resources).to eq(expected), format_error( urls, resources, expected )
 
                                     instance_eval &block if block_given?
                                 end

data/spec/support/shared/fingerprinter.rb

@@ -7,13 +7,13 @@ shared_examples_for 'fingerprinter' do
 
     def check_platforms( page )
         platforms.each do |p|
-            platforms_for( page ).should include p
+            expect(platforms_for( page )).to include p
         end
     end
 
     def platforms_for( page )
         Arachni::Platform::Manager.reset
-        page.platforms.should be_empty
+        expect(page.platforms).to be_empty
 
         described_class.new( page ).run
         page.platforms

data/spec/support/shared/framework.rb

@@ -10,7 +10,7 @@ shared_examples_for 'framework' do
     before( :each ) do
         reset_options
         @options.paths.reporters = fixtures_path + '/reporters/manager_spec/'
-        @options.paths.checks    = fixtures_path + '/taint_check/'
+        @options.paths.checks    = fixtures_path + '/signature_check/'
 
         @f = Arachni::Framework.new
         @f.options.url = @url

data/spec/support/shared/http/message.rb

@@ -12,25 +12,25 @@ shared_examples_for 'Arachni::HTTP::Message' do
                 }
             }
             r = described_class.new(options)
-            r.headers.should == options[:headers]
+            expect(r.headers).to eq(options[:headers])
         end
     end
 
     describe '#scope' do
         it "returns #{described_class::Scope}" do
-            subject.scope.should be_kind_of described_class::Scope
+            expect(subject.scope).to be_kind_of described_class::Scope
         end
     end
 
     describe '#url=' do
         it 'sets the #url' do
             subject.url = "#{url}/2"
-            subject.url.should == "#{url}/2"
+            expect(subject.url).to eq("#{url}/2")
         end
 
         it 'forces it to a string' do
             subject.url = nil
-            subject.url.should == ''
+            expect(subject.url).to eq('')
         end
 
         it 'it freezes it' do
@@ -38,34 +38,34 @@ shared_examples_for 'Arachni::HTTP::Message' do
 
             r = described_class.new( url: url )
             r.url = url
-            r.url.should be_frozen
+            expect(r.url).to be_frozen
         end
 
         it 'normalizes it' do
             url = 'HttP://Stuff.Com/'
             r = described_class.new( url: url )
             r.url = url
-            r.url.should == url.downcase
+            expect(r.url).to eq(url.downcase)
         end
     end
 
     describe '#headers' do
         context 'when not configured' do
             it 'defaults to an empty Hash' do
-                subject.headers.should == {}
+                expect(subject.headers).to eq({})
             end
         end
 
         it 'returns the configured value' do
             headers = { 'Content-Type' => 'text/plain' }
-            described_class.new(url: url, headers: headers).headers.should == headers
+            expect(described_class.new(url: url, headers: headers).headers).to eq(headers)
         end
     end
 
     describe '#body' do
         it 'returns the configured body' do
             body = 'Stuff...'
-            described_class.new(url: url, body: body).body.should == body
+            expect(described_class.new(url: url, body: body).body).to eq(body)
         end
     end
 

data/spec/support/shared/option_group.rb

@@ -1,23 +1,23 @@
 shared_examples_for 'option_group' do
-    it { should respond_to :to_h }
+    it { is_expected.to respond_to :to_h }
 
     describe '#to_rpc_data' do
         let(:data) { subject.to_rpc_data }
 
         it 'converts self to a serializable hash' do
-            data.should be_kind_of Hash
+            expect(data).to be_kind_of Hash
 
-            Arachni::RPC::Serializer.load(
+            expect(Arachni::RPC::Serializer.load(
                 Arachni::RPC::Serializer.dump( data )
-            ).should == data
+            )).to eq(data)
         end
     end
 
     described_class.defaults.each do |k, v|
         describe "##{k}" do
             it "defaults to #{v}" do
-                subject.instance_variable_get( "@#{k}".to_sym ).should == v
-                subject.send( k ).should == v
+                expect(subject.instance_variable_get( "@#{k}".to_sym )).to eq(v)
+                expect(subject.send( k )).to eq(v)
             end
         end
     end
@@ -25,35 +25,35 @@ shared_examples_for 'option_group' do
     it 'honors default values for attributes' do
         subject.defaults.each do |k, v|
             subject.send "#{k}=", nil
-            subject.instance_variable_get( "@#{k}".to_sym ).should == v
-            subject.send( k ).should == v
+            expect(subject.instance_variable_get( "@#{k}".to_sym )).to eq(v)
+            expect(subject.send( k )).to eq(v)
         end
     end
 
     describe '#to_hash' do
         it 'returns a hash' do
-            subject.to_hash.should be_kind_of Hash
+            expect(subject.to_hash).to be_kind_of Hash
         end
     end
 
     describe '#to_h' do
         it 'returns a hash' do
-            subject.to_h.should be_kind_of Hash
+            expect(subject.to_h).to be_kind_of Hash
         end
 
         it 'only includes attributes with accessors' do
             method = subject.methods.find { |m| m.to_s.end_with? '=' }
             if method == :=== || method == :==
-                subject.to_h.should be_empty
+                expect(subject.to_h).to be_empty
                 next
             end
 
             subject.send( method, subject.defaults[method.to_s[0..-1].to_sym] )
 
             hash = subject.to_h
-            hash.should be_any
+            expect(hash).to be_any
             hash.each do |k, v|
-                subject.should respond_to "#{k}="
+                expect(subject).to respond_to "#{k}="
             end
         end
     end
@@ -67,11 +67,11 @@ shared_examples_for 'option_group' do
             value  = subject.defaults[method.to_s[0..-1].to_sym]
 
             subject.update( { method => value } )
-            subject.send( method ).should == value
+            expect(subject.send( method )).to eq(value)
         end
 
         it 'returns self' do
-            subject.update({}).should == subject
+            expect(subject.update({})).to eq(subject)
         end
     end
 
@@ -87,12 +87,12 @@ shared_examples_for 'option_group' do
             group.update( { method => value } )
 
             subject.merge( group )
-            subject.send( method ).should == value
+            expect(subject.send( method )).to eq(value)
         end
 
         it 'returns self' do
             group = described_class.new
-            subject.merge( group ).should == subject
+            expect(subject.merge( group )).to eq(subject)
         end
     end
 end

data/spec/support/shared/path_extractor.rb

@@ -19,7 +19,7 @@ shared_examples_for "path_extractor" do
         it "extracts the expected paths" do
             raise 'No paths provided via #results, use \':nil\' for \'nil\' results.' if !results
 
-            actual_results.sort.should == results.sort
+            expect(actual_results.sort).to eq results.sort
             instance_eval &block if block_given?
         end
     end

data/spec/support/shared/plugin.rb

@@ -19,12 +19,12 @@ shared_examples_for 'plugin' do
     def results
     end
 
-    def self.easy_test( &block )
+    def self.easy_test( match = true, &block )
         it 'logs the expected results' do
             raise 'No results provided via #results, use \':nil\' for \'nil\' results.' if !results
 
             run
-            actual_results.should be_eql( expected_results )
+            expect(actual_results).to eq( expected_results ) if match
 
             instance_eval &block if block_given?
         end

data/spec/support/shared/support/cache.rb

@@ -7,12 +7,12 @@ shared_examples_for 'cache' do
         describe 'max_size' do
             describe 'nil' do
                 it 'leaves the cache uncapped' do
-                    described_class.new.capped?.should be_false
+                    expect(described_class.new.capped?).to be_falsey
                 end
             end
             describe Integer do
                 it 'imposes a limit to the size of the cache' do
-                    described_class.new( 10 ).capped?.should be_true
+                    expect(described_class.new( 10 ).capped?).to be_truthy
                 end
             end
         end
@@ -21,13 +21,13 @@ shared_examples_for 'cache' do
     describe '#max_size' do
         context 'when just initialized' do
             it 'returns nil (unlimited)' do
-                subject.max_size.should be_nil
+                expect(subject.max_size).to be_nil
             end
         end
         context 'when set' do
             it 'returns the set value' do
-                (subject.max_size = 50).should == 50
-                subject.max_size.should == 50
+                expect(subject.max_size = 50).to eq(50)
+                expect(subject.max_size).to eq(50)
             end
         end
     end
@@ -44,14 +44,14 @@ shared_examples_for 'cache' do
         context 'when the cache has no size limit' do
             it 'returns false' do
                 subject.uncap
-                subject.capped?.should be_false
-                subject.max_size.should be_nil
+                expect(subject.capped?).to be_falsey
+                expect(subject.max_size).to be_nil
             end
         end
         context 'when the cache has a size limit' do
             it 'returns true' do
                 subject.max_size = 1
-                subject.capped?.should be_true
+                expect(subject.capped?).to be_truthy
             end
         end
     end
@@ -60,15 +60,15 @@ shared_examples_for 'cache' do
         context 'when the cache has no size limit' do
             it 'returns true' do
                 subject.uncap
-                subject.uncapped?.should be_true
-                subject.max_size.should be_nil
+                expect(subject.uncapped?).to be_truthy
+                expect(subject.max_size).to be_nil
             end
         end
         context 'when the cache has a size limit' do
             it 'returns false' do
                 subject.max_size = 1
-                subject.max_size.should == 1
-                subject.uncapped?.should be_false
+                expect(subject.max_size).to eq(1)
+                expect(subject.uncapped?).to be_falsey
             end
         end
     end
@@ -76,19 +76,19 @@ shared_examples_for 'cache' do
     describe '#uncap' do
         it 'removes the size limit' do
             subject.max_size = 1
-            subject.uncapped?.should be_false
-            subject.max_size.should == 1
+            expect(subject.uncapped?).to be_falsey
+            expect(subject.max_size).to eq(1)
 
             subject.uncap
-            subject.uncapped?.should be_true
-            subject.max_size.should be_nil
+            expect(subject.uncapped?).to be_truthy
+            expect(subject.max_size).to be_nil
         end
     end
 
     describe '#max_size=' do
         it 'sets the maximum size for the cache' do
-            (subject.max_size = 100).should == 100
-            subject.max_size.should == 100
+            expect(subject.max_size = 100).to eq(100)
+            expect(subject.max_size).to eq(100)
         end
 
         context 'when passed < 0' do
@@ -99,7 +99,7 @@ shared_examples_for 'cache' do
                 rescue
                     raised = true
                 end
-                raised.should be_true
+                expect(raised).to be_truthy
             end
         end
     end
@@ -107,14 +107,14 @@ shared_examples_for 'cache' do
     describe '#size' do
         context 'when the cache is empty' do
             it 'returns 0' do
-                subject.size.should == 0
+                expect(subject.size).to eq(0)
             end
         end
 
         context 'when the cache is not empty' do
             it 'returns a value > 0' do
                 subject['stuff'] = [ 'ff ' ]
-                subject.size.should > 0
+                expect(subject.size).to be > 0
             end
         end
     end
@@ -122,13 +122,13 @@ shared_examples_for 'cache' do
     describe '#empty?' do
         context 'when the cache is empty' do
             it 'returns true' do
-                subject.empty?.should be_true
+                expect(subject.empty?).to be_truthy
             end
         end
         context 'when the cache is not empty' do
             it 'returns false' do
                 subject['stuff2'] = 'ff'
-                subject.empty?.should be_false
+                expect(subject.empty?).to be_falsey
             end
         end
     end
@@ -136,13 +136,13 @@ shared_examples_for 'cache' do
     describe '#any?' do
         context 'when the cache is empty' do
             it 'returns true' do
-                subject.any?.should be_false
+                expect(subject.any?).to be_falsey
             end
         end
         context 'when the cache is not empty' do
             it 'returns false' do
                 subject['stuff3'] = [ 'ff ' ]
-                subject.any?.should be_true
+                expect(subject.any?).to be_truthy
             end
         end
     end
@@ -150,13 +150,13 @@ shared_examples_for 'cache' do
     describe '#[]=' do
         it 'stores an object' do
             v = 'val'
-            (subject[:key] = v).should == v
-            subject[:key].should == v
+            expect(subject[:key] = v).to eq(v)
+            expect(subject[:key]).to eq(v)
         end
         it 'is alias of #store' do
             v = 'val2'
-            subject.store( :key2, v ).should == v
-            subject[:key2].should == v
+            expect(subject.store( :key2, v )).to eq(v)
+            expect(subject[:key2]).to eq(v)
         end
     end
 
@@ -164,13 +164,13 @@ shared_examples_for 'cache' do
         it 'retrieves an object by key' do
             v = 'val2'
             subject[:key] = v
-            subject[:key].should == v
-            subject.empty?.should be_false
+            expect(subject[:key]).to eq(v)
+            expect(subject.empty?).to be_falsey
         end
 
         context 'when the key does not exist' do
             it 'returns nil' do
-                subject[:some_key].should be_nil
+                expect(subject[:some_key]).to be_nil
             end
         end
     end
@@ -185,7 +185,7 @@ shared_examples_for 'cache' do
                 cache[:my_key] = old_val
                 cache.fetch_or_store( :my_key ) { new_val }
 
-                cache[:my_key].should == old_val
+                expect(cache[:my_key]).to eq(old_val)
             end
         end
 
@@ -195,7 +195,7 @@ shared_examples_for 'cache' do
                 cache = described_class.new
                 cache.fetch_or_store( :my_key ) { new_val }
 
-                cache[:my_key].should == new_val
+                expect(cache[:my_key]).to eq(new_val)
             end
         end
     end
@@ -204,12 +204,12 @@ shared_examples_for 'cache' do
         context 'when the key exists' do
             it 'returns true' do
                 subject[:key1] = 'v'
-                subject.include?( :key1 ).should be_true
+                expect(subject.include?( :key1 )).to be_truthy
             end
         end
         context 'when the key does not exist' do
             it 'returns false' do
-                subject.include?( :key2 ).should be_false
+                expect(subject.include?( :key2 )).to be_falsey
             end
         end
     end
@@ -219,21 +219,21 @@ shared_examples_for 'cache' do
             it 'deletes a key' do
                 v = 'my_val'
                 subject[:my_key] = v
-                subject.delete( :my_key ).should == v
-                subject[:my_key].should be_nil
-                subject.include?( :my_key ).should be_false
+                expect(subject.delete( :my_key )).to eq(v)
+                expect(subject[:my_key]).to be_nil
+                expect(subject.include?( :my_key )).to be_falsey
             end
             it 'returns its value' do
                 v = 'my_val'
                 subject[:my_key] = v
-                subject.delete( :my_key ).should == v
-                subject[:my_key].should be_nil
-                subject.include?( :my_key ).should be_false
+                expect(subject.delete( :my_key )).to eq(v)
+                expect(subject[:my_key]).to be_nil
+                expect(subject.include?( :my_key )).to be_falsey
             end
         end
         context 'when the key does not exist' do
             it 'should return nil' do
-                subject.delete( :my_key2 ).should be_nil
+                expect(subject.delete( :my_key2 )).to be_nil
             end
         end
     end
@@ -241,13 +241,13 @@ shared_examples_for 'cache' do
     describe '#empty?' do
         context 'when cache is empty' do
             it 'returns true' do
-                subject.empty?.should be_true
+                expect(subject.empty?).to be_truthy
             end
         end
         context 'when cache is not empty' do
             it 'returns false' do
                 subject['ee'] = 'rr'
-                subject.empty?.should be_false
+                expect(subject.empty?).to be_falsey
             end
         end
     end
@@ -255,13 +255,13 @@ shared_examples_for 'cache' do
     describe '#any?' do
         context 'when cache is empty' do
             it 'returns false' do
-                subject.any?.should be_false
+                expect(subject.any?).to be_falsey
             end
         end
         context 'when cache is not empty' do
             it 'returns true' do
                 subject['ee'] = 'rr'
-                subject.any?.should be_true
+                expect(subject.any?).to be_truthy
             end
         end
     end
@@ -269,12 +269,12 @@ shared_examples_for 'cache' do
     describe '#clear' do
         it 'empties the cache' do
             subject[:my_key2] = 'v'
-            subject.size.should > 0
-            subject.empty?.should be_false
+            expect(subject.size).to be > 0
+            expect(subject.empty?).to be_falsey
             subject.clear
 
-            subject.size.should == 0
-            subject.empty?.should be_true
+            expect(subject.size).to eq(0)
+            expect(subject.empty?).to be_truthy
         end
     end
 
@@ -286,7 +286,7 @@ shared_examples_for 'cache' do
                 subject[:test_key] = 'test_val'
                 new[:test_key]     = 'test_val'
 
-                subject.should == new
+                expect(subject).to eq(new)
             end
         end
 
@@ -297,7 +297,7 @@ shared_examples_for 'cache' do
                 subject[:test_key] = 'test_val'
                 new[:test_key]     = 'test_val2'
 
-                subject.should_not == new
+                expect(subject).not_to eq(new)
             end
         end
     end
@@ -310,7 +310,7 @@ shared_examples_for 'cache' do
                 subject[:test_key] = 'test_val'
                 new[:test_key]     = 'test_val'
 
-                subject.hash.should == new.hash
+                expect(subject.hash).to eq(new.hash)
             end
         end
 
@@ -321,7 +321,7 @@ shared_examples_for 'cache' do
                 subject[:test_key] = 'test_val'
                 new[:test_key]     = 'test_val2'
 
-                subject.hash.should_not == new.hash
+                expect(subject.hash).not_to eq(new.hash)
             end
         end
     end
@@ -331,11 +331,11 @@ shared_examples_for 'cache' do
             subject[:test_key] = 'test_val'
             copy = subject.dup
 
-            copy.should == subject
+            expect(copy).to eq(subject)
 
             copy[:test_key] = 'test_val2'
 
-            copy.should_not == subject
+            expect(copy).not_to eq(subject)
         end
     end
 end