arachni 1.2.1 → 1.3

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

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+describe Arachni::Element::UIInput::DOM do
+    inputs = { 'my-input' => '1' }
+
+    it_should_behave_like 'element_dom'
+
+    it_should_behave_like 'with_node'
+
+    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 run
+        auditor.browser_cluster.wait
+    end
+
+    def auditable_extract_parameters( page )
+        { 'my-input' => page.document.css('#container').text.strip }
+    end
+
+    def element
+        e = Arachni::Element::UIInput.new(
+            method: 'input',
+            action: @page.url,
+            source: '<input oninput="handleOnInput();" id="my-input" name="my-input" value="1" />'
+        ).dom
+        e.page    = @page
+        e.auditor = @auditor
+        e
+    end
+
+    before :each do
+        @framework = Arachni::Framework.new
+        @page      = Arachni::Page.from_url( url )
+        @auditor   = Auditor.new( @page, @framework )
+    end
+
+    after :each do
+        @framework.clean_up
+        @framework.reset
+    end
+
+    subject { element }
+    let(:parent) { subject.parent }
+    let(:url) { web_server_url_for( :input_dom ) }
+    let(:auditor) { @auditor }
+    let(:inputtable) { element }
+
+    describe '#type' do
+        it 'returns :ui_input_dom' do
+            expect(subject.type).to eq(:ui_input_dom)
+        end
+    end
+
+    describe '.type' do
+        it 'returns :ui_input_dom' do
+            expect(described_class.type).to eq(:ui_input_dom)
+        end
+    end
+
+    describe '#parent' do
+        it 'returns the parent element' do
+            expect(subject.parent).to be_kind_of Arachni::Element::UIInput
+        end
+    end
+
+    describe '#inputs' do
+        it 'uses the node attribute data' do
+            expect(subject.inputs).to eq(inputs)
+        end
+    end
+
+    describe '#locate' do
+        it 'locates the live element' do
+            called = false
+            subject.with_browser do |browser|
+                subject.browser = browser
+                browser.load subject.page
+
+                element = subject.locate
+                expect(element).to be_kind_of Watir::HTMLElement
+
+                expect(Arachni::Browser::ElementLocator.
+                           from_html( element.opening_tag ).attributes
+                ).to eq(subject.locator.attributes)
+
+                called = true
+            end
+
+            subject.auditor.browser_cluster.wait
+            expect(called).to be_truthy
+        end
+    end
+
+    describe '#trigger' do
+        let(:new_inputs) { { subject.inputs.keys.first  => 'The.Dude' } }
+
+        it 'triggers the event required to submit the element' do
+            subject.update new_inputs
+
+            called = false
+            subject.with_browser do |browser|
+                subject.browser = browser
+                browser.load subject.page
+
+                subject.trigger
+
+                page = browser.to_page
+
+                expect(subject.inputs).to eq(auditable_extract_parameters( page ))
+                called = true
+            end
+
+            subject.auditor.browser_cluster.wait
+            expect(called).to be_truthy
+        end
+
+        it 'returns a playable transition' do
+            subject.update new_inputs
+
+            transitions = []
+            called = false
+            subject.with_browser do |browser|
+                subject.browser = browser
+                browser.load subject.page
+
+                transitions = subject.trigger
+
+                page = browser.to_page
+
+                expect(subject.inputs).to eq(auditable_extract_parameters( page ))
+                called = true
+            end
+
+            subject.auditor.browser_cluster.wait
+            expect(called).to be_truthy
+
+            called = false
+            auditor.with_browser do |browser|
+                browser.load subject.page
+                expect(auditable_extract_parameters( browser.to_page ).values.first).to eq ''
+
+                transitions.each do |transition|
+                    transition.play browser
+                end
+
+                expect(auditable_extract_parameters( browser.to_page )).to eq(new_inputs)
+                called = true
+            end
+            auditor.browser_cluster.wait
+            expect(called).to be_truthy
+        end
+    end
+
+end

data/spec/arachni/element/ui_input_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+
+describe Arachni::Element::UIInput do
+    html = '<input type=password name="my_first_input" value="my_first_value"" />'
+
+    it_should_behave_like 'dom_only', html
+
+    def new_element( html )
+        described_class.new(
+            action: url,
+            source: html,
+            method: 'onmouseover'
+        )
+    end
+
+    subject { new_element( html ) }
+    let(:inputtable) { new_element( html ) }
+    let(:url) { "#{web_server_url_for( :input_dom )}/" }
+
+    let(:browser) { @browser }
+    let(:page) { Arachni::Page.from_url( url ) }
+
+    describe '#type' do
+        it 'returns :ui_input' do
+            expect(subject.type).to eq(:ui_input)
+        end
+    end
+
+    describe '.type' do
+        it 'returns :ui_input' do
+            expect(described_class.type).to eq(:ui_input)
+        end
+    end
+
+    describe '.from_browser' do
+        before :each do
+            @browser = Arachni::Browser.new
+            @browser.load page
+        end
+
+        after :each do
+            @browser.shutdown
+        end
+
+        context 'when there no inputs' do
+            let(:url) { "#{super()}/without-inputs" }
+
+            it 'returns empty array' do
+                expect(described_class.from_browser( @browser, page )).to be_empty
+            end
+        end
+
+        context 'with inputs as' do
+            context '<input type="text">' do
+                let(:url) { "#{super()}/input/type/text" }
+
+                context 'with events' do
+                    let(:url) { "#{super()}/with_events" }
+                    let(:source) { '<input type="text" id="my-input" value="stuff">' }
+
+                    it 'returns array of elements' do
+                        input = described_class.from_browser( @browser, page ).first
+
+                        expect(input.source).to eq source
+                        expect(input.url).to eq page.url
+                        expect(input.action).to eq page.url
+                        expect(input.method).to eq :input
+                        expect(input.inputs).to eq( 'my-input' => 'stuff' )
+                    end
+                end
+
+                context 'without events' do
+                    let(:url) { "#{super()}/without_events" }
+
+                    it 'returns empty array' do
+                        expect(described_class.from_browser( @browser, page )).to be_empty
+                    end
+                end
+            end
+
+            context '<input>' do
+                let(:url) { "#{super()}/input/type/none" }
+
+                context 'with events' do
+                    let(:url) { "#{super()}/with_events" }
+                    let(:source) { '<input id="my-input" value="stuff">' }
+
+                    it 'returns array of elements' do
+                        input = described_class.from_browser( @browser, page ).first
+
+                        expect(input.source).to eq source
+                        expect(input.url).to eq page.url
+                        expect(input.action).to eq page.url
+                        expect(input.method).to eq :input
+                        expect(input.inputs).to eq( 'my-input' => 'stuff' )
+                    end
+                end
+
+                context 'without events' do
+                    let(:url) { "#{super()}/without_events" }
+
+                    it 'returns empty array' do
+                        expect(described_class.from_browser( @browser, page )).to be_empty
+                    end
+                end
+            end
+
+            context '<textarea>' do
+                let(:url) { "#{super()}/textarea" }
+
+                context 'with events' do
+                    let(:url) { "#{super()}/with_events" }
+                    let(:source) { '<textarea id="my-input" type="text">' }
+
+                    it 'returns array of elements' do
+                        input = described_class.from_browser( @browser, page ).first
+
+                        expect(input.source).to eq source
+                        expect(input.url).to eq page.url
+                        expect(input.action).to eq page.url
+                        expect(input.method).to eq :input
+                        expect(input.inputs).to eq( 'my-input' => '' )
+                    end
+                end
+
+                context 'without events' do
+                    let(:url) { "#{super()}/without_events" }
+
+                    it 'returns empty array' do
+                        expect(described_class.from_browser( @browser, page )).to be_empty
+                    end
+                end
+            end
+        end
+    end
+end

data/spec/arachni/element/xml_spec.rb

@@ -4,9 +4,27 @@ describe Arachni::Element::XML do
     inputtable_source = '<input1>value1</input1><input2>value2</input2>'
 
     it_should_behave_like 'element'
-    it_should_behave_like 'with_source', inputtable_source
-    it_should_behave_like 'auditable',
+
+    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',
                           inputs: described_class.parse_inputs( inputtable_source )
+    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 )
         described_class.parse_inputs( resource.body )
@@ -75,20 +93,20 @@ EOXML
     let(:utilities) { Arachni::Utilities }
 
     it 'is assigned to Arachni::Link for easy access' do
-        Arachni::XML.should == described_class
+        expect(Arachni::XML).to eq(described_class)
     end
 
     describe '#initialize' do
         describe ':source' do
             it 'parses it into #inputs' do
-                subject.inputs.should == described_class.parse_inputs( source )
+                expect(subject.inputs).to eq(described_class.parse_inputs( source ))
             end
 
             context 'when missing' do
                 it 'fails' do
                     expect do
                         described_class.new( url: "#{url}submit" )
-                    end.to raise_error described_class::Error::MissingSource
+                    end.to raise_error Arachni::Element::Capabilities::WithSource::Error::MissingSource
                 end
             end
         end
@@ -96,7 +114,7 @@ EOXML
 
     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
 
@@ -105,26 +123,26 @@ EOXML
             subject.inputs.each do |name, _|
                 s = subject.dup
                 s[name] = "#{name} value"
-                Nokogiri::XML(s.to_xml).css(name).first.content.should == "#{name} value"
+                expect(Nokogiri::XML(s.to_xml).css(name).first.content).to eq("#{name} value")
             end
         end
     end
 
     describe '#to_s' do
         it 'returns #to_xml' do
-            subject.to_s.should == subject.to_xml
+            expect(subject.to_s).to eq(subject.to_xml)
         end
     end
 
     describe '#type' do
         it 'should be "link"' do
-            subject.type.should == :xml
+            expect(subject.type).to eq(:xml)
         end
     end
 
     describe '#to_rpc_data' do
         it "includes 'source'" do
-            subject.to_rpc_data['source'].should == source
+            expect(subject.to_rpc_data['source']).to eq(source)
         end
     end
 
@@ -141,10 +159,10 @@ EOXML
             end
 
             it 'parses a request into an element' do
-                subject.url.should    == url
-                subject.action.should == request.url
-                subject.source.should == request.body
-                subject.method.should == request.method
+                expect(subject.url).to    eq(url)
+                expect(subject.action).to eq(request.url)
+                expect(subject.source).to eq(request.body)
+                expect(subject.method).to eq(request.method)
             end
         end
 
@@ -157,7 +175,7 @@ EOXML
             end
 
             it 'returns nil' do
-                subject.should be_nil
+                expect(subject).to be_nil
             end
         end
 
@@ -171,7 +189,7 @@ EOXML
             end
 
             it 'returns nil' do
-                subject.should be_nil
+                expect(subject).to be_nil
             end
         end
 
@@ -198,7 +216,7 @@ EOXML
 
     describe '.parse_inputs' do
         it 'parses an XML document into a hash of inputs' do
-            described_class.parse_inputs( source ).should == {
+            expect(described_class.parse_inputs( source )).to eq({
                 'bookstore > book:nth-of-type(1) > title > text()' => 'Everyday Italian',
                 'bookstore > book:nth-of-type(1) > title > @lang' => 'en',
                 'bookstore > book:nth-of-type(1) > author > text()' => 'Giada De Laurentiis',
@@ -227,40 +245,40 @@ EOXML
                 'bookstore > book:nth-of-type(4) > year > text()' => '2003',
                 'bookstore > book:nth-of-type(4) > price > text()' => '39.95',
                 'bookstore > book:nth-of-type(4) > @category' => 'WEB'
-            }
+            })
         end
     end
 
     describe '#transform_xml' do
         it 'assigns a callback to process the resulting XML' do
             subject.transform_xml do |xml|
-                xml.should == Nokogiri::XML( subject.source ).to_xml
+                expect(xml).to eq(Nokogiri::XML( subject.source ).to_xml)
                 'stuff'
             end
 
-            subject.to_xml.should == 'stuff'
+            expect(subject.to_xml).to eq('stuff')
         end
     end
 
     describe '.encode' do
         it 'returns the string as is' do
-            described_class.encode( 'stuff' ).should == 'stuff'
+            expect(described_class.encode( 'stuff' )).to eq('stuff')
         end
     end
     describe '#encode' do
         it 'returns the string as is' do
-            subject.encode( 'stuff' ).should == 'stuff'
+            expect(subject.encode( 'stuff' )).to eq('stuff')
         end
     end
 
     describe '.decode' do
         it 'returns the string as is' do
-            described_class.decode( 'stuff' ).should == 'stuff'
+            expect(described_class.decode( 'stuff' )).to eq('stuff')
         end
     end
     describe '#decode' do
         it 'returns the string as is' do
-            subject.decode( 'stuff' ).should == 'stuff'
+            expect(subject.decode( 'stuff' )).to eq('stuff')
         end
     end