arachni 1.2.1 → 1.3

data/spec/arachni/data/framework/rpc_spec.rb

@@ -15,15 +15,16 @@ describe Arachni::Data::Framework::RPC do
 
     describe '#distributed_page_queue' do
         it "returns an instance of #{Arachni::Support::Database::Queue}" do
-            subject.distributed_page_queue.should be_kind_of Arachni::Support::Database::Queue
+            expect(subject.distributed_page_queue).to be_kind_of Arachni::Support::Database::Queue
         end
     end
 
     describe '#statistics' do
         it 'includes #distributed_page_queue size' do
             subject.distributed_page_queue << page
-            subject.statistics[:distributed_page_queue].should ==
+            expect(subject.statistics[:distributed_page_queue]).to eq(
                 subject.distributed_page_queue.size
+            )
         end
     end
 
@@ -33,8 +34,8 @@ describe Arachni::Data::Framework::RPC do
             subject.distributed_page_queue << page
             subject.distributed_page_queue << page
 
-            subject.distributed_page_queue.buffer.should include page
-            subject.distributed_page_queue.disk.size.should == 1
+            expect(subject.distributed_page_queue.buffer).to include page
+            expect(subject.distributed_page_queue.disk.size).to eq(1)
 
             subject.dump( dump_directory )
 
@@ -42,7 +43,7 @@ describe Arachni::Data::Framework::RPC do
             Dir["#{dump_directory}/distributed_page_queue/*"].each do |page_file|
                 pages << Marshal.load( IO.read( page_file ) )
             end
-            pages.should == [page, page]
+            expect(pages).to eq([page, page])
         end
     end
 
@@ -55,16 +56,16 @@ describe Arachni::Data::Framework::RPC do
             subject.dump( dump_directory )
 
             page_queue = described_class.load( dump_directory ).distributed_page_queue
-            page_queue.size.should == 2
-            page_queue.pop.should == page
-            page_queue.pop.should == page
+            expect(page_queue.size).to eq(2)
+            expect(page_queue.pop).to eq(page)
+            expect(page_queue.pop).to eq(page)
         end
     end
 
     describe '#clear' do
         %w(distributed_page_queue).each do |method|
             it "clears ##{method}" do
-                subject.send(method).should receive(:clear)
+                expect(subject.send(method)).to receive(:clear)
                 subject.clear
             end
         end

data/spec/arachni/data/framework_spec.rb

@@ -18,58 +18,77 @@ describe Arachni::Data::Framework do
         let(:statistics) { subject.statistics }
 
         it "includes #{described_class::RPC}#statistics" do
-            statistics[:rpc].should == subject.rpc.statistics
+            expect(statistics[:rpc]).to eq(subject.rpc.statistics)
         end
 
         it 'includes the #sitemap size' do
             subject.add_page_to_sitemap page
 
-            statistics[:sitemap].should == subject.sitemap.size
+            expect(statistics[:sitemap]).to eq(subject.sitemap.size)
         end
 
         it 'includes the #page_queue size' do
             subject.push_to_page_queue page
-            statistics[:page_queue].should == subject.page_queue.size
+            expect(statistics[:page_queue]).to eq(subject.page_queue.size)
         end
 
         it 'includes the #page_queue_total_size' do
             subject.push_to_page_queue page
-            statistics[:page_queue_total_size].should == subject.page_queue_total_size
+            expect(statistics[:page_queue_total_size]).to eq(subject.page_queue_total_size)
         end
 
         it 'includes the #url_queue size' do
             subject.push_to_url_queue url
-            statistics[:url_queue_total_size].should == subject.url_queue_total_size
+            expect(statistics[:url_queue_total_size]).to eq(subject.url_queue_total_size)
         end
 
         it 'includes the #url_queue_total_size' do
             subject.push_to_url_queue page
-            statistics[:url_queue_total_size].should == subject.url_queue_total_size
+            expect(statistics[:url_queue_total_size]).to eq(subject.url_queue_total_size)
         end
     end
 
     describe '#rpc' do
         it "returns an instance of #{described_class::RPC}" do
-            subject.rpc.should be_kind_of described_class::RPC
+            expect(subject.rpc).to be_kind_of described_class::RPC
         end
     end
 
     describe '#sitemap' do
         it 'returns a Hash' do
-            subject.sitemap.should be_kind_of Hash
+            expect(subject.sitemap).to be_kind_of Hash
         end
     end
 
     describe '#page_queue' do
         it "returns an instance of #{Arachni::Support::Database::Queue}" do
-            subject.page_queue.should be_kind_of Arachni::Support::Database::Queue
+            expect(subject.page_queue).to be_kind_of Arachni::Support::Database::Queue
         end
     end
 
     describe '#add_page_to_sitemap' do
         it 'updates the sitemap with the given page' do
+            expect(subject).to receive(:update_sitemap).with( page.dom.url => page.code )
             subject.add_page_to_sitemap page
-            subject.sitemap[page.url].should == page.code
+        end
+    end
+
+    describe '#update_sitemap' do
+        let(:url) { 'http://stuff/' }
+        let(:code) { 201 }
+
+        it 'updates the sitemap with the given data' do
+            subject.update_sitemap( url => code )
+            expect(subject.sitemap[url]).to eq(code)
+        end
+
+        context "when the URL includes #{Arachni::Utilities}.random_seed" do
+            let(:url) { super() + Arachni::Utilities.random_seed }
+
+            it 'is ignored' do
+                subject.update_sitemap( url => code )
+                expect(subject.sitemap).not_to include url
+            end
         end
     end
 
@@ -79,32 +98,32 @@ describe Arachni::Data::Framework do
         end
 
         it 'increments #page_queue_total_size' do
-            subject.page_queue_total_size.should == 0
+            expect(subject.page_queue_total_size).to eq(0)
             subject.push_to_page_queue page
-            subject.page_queue_total_size.should == 1
+            expect(subject.page_queue_total_size).to eq(1)
         end
 
         it 'updates the sitemap' do
-            subject.should receive(:add_page_to_sitemap).with(page)
+            expect(subject).to receive(:add_page_to_sitemap).with(page)
             subject.push_to_page_queue page
         end
     end
 
     describe '#page_queue_total_size' do
         it 'defaults to 0' do
-            subject.page_queue_total_size.should == 0
+            expect(subject.page_queue_total_size).to eq(0)
         end
     end
 
     describe '#url_queue' do
         it "returns an instance of #{Arachni::Support::Database::Queue}" do
-            subject.url_queue.should be_kind_of Arachni::Support::Database::Queue
+            expect(subject.url_queue).to be_kind_of Arachni::Support::Database::Queue
         end
     end
 
     describe '#url_queue_total_size' do
         it 'defaults to 0' do
-            subject.url_queue_total_size.should == 0
+            expect(subject.url_queue_total_size).to eq(0)
         end
     end
 
@@ -114,25 +133,25 @@ describe Arachni::Data::Framework do
         end
 
         it 'increments #url_queue_total_size' do
-            subject.url_queue_total_size.should == 0
+            expect(subject.url_queue_total_size).to eq(0)
             subject.push_to_url_queue url
-            subject.url_queue_total_size.should == 1
+            expect(subject.url_queue_total_size).to eq(1)
         end
     end
 
     describe '#dump' do
         it 'stores #rpc to disk' do
             subject.dump( dump_directory )
-            described_class::RPC.load( "#{dump_directory}/rpc" ).should be_kind_of described_class::RPC
+            expect(described_class::RPC.load( "#{dump_directory}/rpc" )).to be_kind_of described_class::RPC
         end
 
         it 'stores #sitemap to disk' do
             subject.sitemap[page.url] = page.code
             subject.dump( dump_directory )
 
-            Marshal.load( IO.read( "#{dump_directory}/sitemap" ) ).should == {
+            expect(Marshal.load( IO.read( "#{dump_directory}/sitemap" ) )).to eq({
                 page.url => page.code
-            }
+            })
         end
 
         it 'stores #page_queue to disk' do
@@ -140,8 +159,8 @@ describe Arachni::Data::Framework do
             subject.push_to_page_queue page
             subject.push_to_page_queue page
 
-            subject.page_queue.buffer.should include page
-            subject.page_queue.disk.size.should == 1
+            expect(subject.page_queue.buffer).to include page
+            expect(subject.page_queue.disk.size).to eq(1)
 
             subject.dump( dump_directory )
 
@@ -149,17 +168,17 @@ describe Arachni::Data::Framework do
             Dir["#{dump_directory}/page_queue/*"].each do |page_file|
                 pages << Marshal.load( IO.read( page_file ) )
             end
-            pages.should == [page, page]
+            expect(pages).to eq([page, page])
         end
 
         it 'stores #page_queue_total_size to disk' do
             subject.push_to_page_queue page
             subject.push_to_page_queue page
-            subject.page_queue_total_size.should == 2
+            expect(subject.page_queue_total_size).to eq(2)
 
             subject.dump( dump_directory )
 
-            Marshal.load( IO.read( "#{dump_directory}/page_queue_total_size" ) ).should == 2
+            expect(Marshal.load( IO.read( "#{dump_directory}/page_queue_total_size" ) )).to eq(2)
         end
 
         it 'stores #url_queue to disk' do
@@ -168,31 +187,31 @@ describe Arachni::Data::Framework do
 
             subject.dump( dump_directory )
 
-            Marshal.load( IO.read( "#{dump_directory}/url_queue" ) ).should == [url, url]
+            expect(Marshal.load( IO.read( "#{dump_directory}/url_queue" ) )).to eq([url, url])
         end
 
         it 'stores #url_queue_total_size to disk' do
             subject.push_to_url_queue url
             subject.push_to_url_queue url
-            subject.url_queue_total_size.should == 2
+            expect(subject.url_queue_total_size).to eq(2)
 
             subject.dump( dump_directory )
 
-            Marshal.load( IO.read( "#{dump_directory}/url_queue_total_size" ) ).should == 2
+            expect(Marshal.load( IO.read( "#{dump_directory}/url_queue_total_size" ) )).to eq(2)
         end
     end
 
     describe '.load' do
         it 'loads #rpc from disk' do
             subject.dump( dump_directory )
-            described_class.load( dump_directory ).rpc.should be_kind_of described_class::RPC
+            expect(described_class.load( dump_directory ).rpc).to be_kind_of described_class::RPC
         end
 
         it 'loads #sitemap from disk' do
             subject.sitemap[page.url] = page.code
             subject.dump( dump_directory )
 
-            described_class.load( dump_directory ).sitemap.should == subject.sitemap
+            expect(described_class.load( dump_directory ).sitemap).to eq(subject.sitemap)
         end
 
         it 'loads #page_queue from disk' do
@@ -203,19 +222,19 @@ describe Arachni::Data::Framework do
             subject.dump( dump_directory )
 
             page_queue = described_class.load( dump_directory ).page_queue
-            page_queue.size.should == 2
-            page_queue.pop.should == page
-            page_queue.pop.should == page
+            expect(page_queue.size).to eq(2)
+            expect(page_queue.pop).to eq(page)
+            expect(page_queue.pop).to eq(page)
         end
 
         it 'loads #page_queue_total_size from disk' do
             subject.push_to_page_queue page
             subject.push_to_page_queue page
-            subject.page_queue_total_size.should == 2
+            expect(subject.page_queue_total_size).to eq(2)
 
             subject.dump( dump_directory )
 
-            described_class.load( dump_directory ).page_queue_total_size.should == 2
+            expect(described_class.load( dump_directory ).page_queue_total_size).to eq(2)
         end
 
         it 'loads #url_queue from disk' do
@@ -225,42 +244,42 @@ describe Arachni::Data::Framework do
             subject.dump( dump_directory )
 
             url_queue = described_class.load( dump_directory ).url_queue
-            url_queue.size.should == 2
-            url_queue.pop.should == url
-            url_queue.pop.should == url
+            expect(url_queue.size).to eq(2)
+            expect(url_queue.pop).to eq(url)
+            expect(url_queue.pop).to eq(url)
         end
 
         it 'loads #url_queue_total_size from disk' do
             subject.push_to_url_queue url
             subject.push_to_url_queue url
-            subject.url_queue_total_size.should == 2
+            expect(subject.url_queue_total_size).to eq(2)
 
             subject.dump( dump_directory )
 
-            described_class.load( dump_directory ).url_queue_total_size.should == 2
+            expect(described_class.load( dump_directory ).url_queue_total_size).to eq(2)
         end
     end
 
     describe '#clear' do
         %w(rpc sitemap page_queue url_queue).each do |method|
             it "clears ##{method}" do
-                subject.send(method).should receive(:clear)
+                expect(subject.send(method)).to receive(:clear)
                 subject.clear
             end
         end
 
         it 'sets #page_queue_total_size to 0' do
             subject.push_to_page_queue page
-            subject.page_queue_total_size.should == 1
+            expect(subject.page_queue_total_size).to eq(1)
             subject.clear
-            subject.page_queue_total_size.should == 0
+            expect(subject.page_queue_total_size).to eq(0)
         end
 
         it 'sets #url_queue_total_size to 0' do
             subject.push_to_url_queue page.url
-            subject.url_queue_total_size.should == 1
+            expect(subject.url_queue_total_size).to eq(1)
             subject.clear
-            subject.url_queue_total_size.should == 0
+            expect(subject.url_queue_total_size).to eq(0)
         end
     end
 end

data/spec/arachni/data/issues_spec.rb

@@ -59,52 +59,43 @@ describe Arachni::Data::Issues do
         end
 
         it 'includes the amount of total issues' do
-            statistics[:total].should == subject.size
+            expect(statistics[:total]).to eq(subject.size)
         end
 
         it 'includes the amount of issues by severity' do
-            statistics[:by_severity].should == {
+            expect(statistics[:by_severity]).to eq({
                 low:           1,
                 informational: 1,
                 high:          1,
                 medium:        1
-            }
+            })
         end
 
         it 'includes the amount of issues by type' do
-            statistics[:by_type].should == {
+            expect(statistics[:by_type]).to eq({
                 issue.name => 4
-            }
+            })
         end
 
         it 'includes the amount of issues by check' do
-            statistics[:by_check].should == {
+            expect(statistics[:by_check]).to eq({
                 issue.check[:shortname] => 4
-            }
+            })
         end
     end
 
     describe '#<<' do
         it 'registers an array of issues' do
             subject << issue
-            subject.any?.should be_true
+            expect(subject.any?).to be_truthy
         end
 
-        context 'when an issue was discovered by manipulating an input' do
-            it 'does not register redundant issues' do
-                i = issue.deep_clone
-                i.vector.affected_input_name = 'some input'
-                20.times { subject << i }
+        it 'does not register duplicate issues' do
+            i = issue.deep_clone
+            i.vector.affected_input_name = 'some input'
+            20.times { subject << i }
 
-                subject.size.should == 1
-            end
-        end
-
-        context 'when an issue was not discovered by manipulating an input' do
-            it 'registers it multiple times' do
-                20.times { subject << issue }
-                subject.flatten.size.should == 20
-            end
+            expect(subject.size).to eq(1)
         end
     end
 
@@ -113,7 +104,7 @@ describe Arachni::Data::Issues do
             callback_called = 0
             subject.on_new { callback_called += 1 }
             10.times { subject << active_issue }
-            callback_called.should == 1
+            expect(callback_called).to eq(1)
         end
     end
 
@@ -122,7 +113,7 @@ describe Arachni::Data::Issues do
             callback_called = 0
             subject.on_new_pre_deduplication { callback_called += 1 }
             10.times { subject << issue }
-            callback_called.should == 10
+            expect(callback_called).to eq(10)
         end
     end
 
@@ -130,56 +121,28 @@ describe Arachni::Data::Issues do
         it 'does not store results' do
             subject.do_not_store
             subject << issue
-            subject.empty?.should be_true
+            expect(subject.empty?).to be_truthy
         end
     end
 
     describe '#all' do
         it 'returns all issues' do
             subject << issue
-            subject.all.should == [issue]
-        end
-
-        it 'groups issues as variations' do
-            20.times { subject << issue }
-
-            all   = subject.all
-            first = all.first
-
-            all.should == [issue]
-            first.variations.size.should == 20
-            first.variations.first.should == issue
-        end
-    end
-
-    describe '#summary' do
-        it 'returns first variation of all issues as solo versions' do
-            unsorted_issues.each { |i| subject << i }
-            subject.summary.should == sorted_issues
-            subject.summary.map(&:solo?).uniq.should == [true]
-        end
-    end
-
-    describe '#flatten' do
-        it 'returns all issues as solo versions' do
-            20.times { subject << issue }
-            subject.flatten.size.should == 20
-            subject.flatten.first.should == issue
-            subject.flatten.map(&:solo?).uniq.should == [true]
+            expect(subject.all).to eq([issue])
         end
     end
 
     describe '#[]' do
         it 'provides access to issues by their #digest' do
             subject << issue
-            subject[issue.digest].should == issue
+            expect(subject[issue.digest]).to eq(issue)
         end
     end
 
     describe '#sort'do
         it 'returns a sorted array of Issues' do
             unsorted_issues.each { |i| subject << i }
-            subject.sort.should == sorted_issues
+            expect(subject.sort).to eq(sorted_issues)
         end
     end
 
@@ -188,14 +151,14 @@ describe Arachni::Data::Issues do
             subject << issue
             issues = []
             subject.each { |i| issues << i }
-            issues.should == [issue]
+            expect(issues).to eq([issue])
         end
     end
 
     describe '#map' do
         it 'passes each issue to the given block' do
             subject << issue
-            subject.map { |i| i.severity }.should == [issue.severity]
+            expect(subject.map { |i| i.severity }).to eq([issue.severity])
         end
     end
 
@@ -203,7 +166,7 @@ describe Arachni::Data::Issues do
         it 'returns the first issue' do
             subject << issue_low_severity
             subject << issue_high_severity
-            subject.first.should == issue_low_severity
+            expect(subject.first).to eq(issue_low_severity)
         end
     end
 
@@ -211,7 +174,7 @@ describe Arachni::Data::Issues do
         it 'returns the last issue' do
             subject << issue_low_severity
             subject << issue_high_severity
-            subject.last.should == issue_high_severity
+            expect(subject.last).to eq(issue_high_severity)
         end
     end
 
@@ -222,7 +185,7 @@ describe Arachni::Data::Issues do
             context 'and it includes the given issue' do
                 it 'returns true' do
                     subject << issue
-                    subject.should include issue
+                    expect(subject).to include issue
                 end
             end
         end
@@ -230,14 +193,14 @@ describe Arachni::Data::Issues do
         context 'when it includes the given issue' do
             it 'returns true' do
                 subject << issue
-                subject.should include issue
+                expect(subject).to include issue
             end
         end
 
         context 'when it does not includes the given issue' do
             it 'returns true' do
                 subject << active_issue
-                subject.should_not include issue
+                expect(subject).not_to include issue
             end
         end
     end
@@ -246,13 +209,13 @@ describe Arachni::Data::Issues do
         context 'when there are issues' do
             it 'returns true' do
                 subject << issue
-                subject.should be_any
+                expect(subject).to be_any
             end
         end
 
         context 'when there are no issues' do
             it 'returns false' do
-                subject.should_not be_any
+                expect(subject).not_to be_any
             end
         end
     end
@@ -260,14 +223,14 @@ describe Arachni::Data::Issues do
     describe '#empty?' do
         context 'when there are no issues' do
             it 'returns true' do
-                subject.should be_empty
+                expect(subject).to be_empty
             end
         end
 
         context 'when there are issues' do
             it 'returns false' do
                 subject << issue
-                subject.should_not be_empty
+                expect(subject).not_to be_empty
             end
         end
     end
@@ -276,7 +239,7 @@ describe Arachni::Data::Issues do
         it 'returns the amount of issues' do
             subject << issue
             subject << active_issue
-            subject.size.should == 2
+            expect(subject.size).to eq(2)
         end
     end
 
@@ -287,11 +250,10 @@ describe Arachni::Data::Issues do
 
             subject.each do |issue|
                 issue_path = "#{dump_directory}/issue_#{issue.digest}"
-                File.exists?( issue_path ).should be_true
+                expect(File.exists?( issue_path )).to be_truthy
 
                 loaded_issue = Marshal.load( IO.read( issue_path ) )
-                issue.should == loaded_issue
-                issue.variations.should == loaded_issue.variations
+                expect(issue).to eq(loaded_issue)
             end
         end
 
@@ -299,7 +261,7 @@ describe Arachni::Data::Issues do
             unsorted_issues.each { |i| subject << i }
             subject.dump( dump_directory )
 
-            subject.digests.should == Marshal.load( IO.read( "#{dump_directory}/digests" ) )
+            expect(subject.digests).to eq(Marshal.load( IO.read( "#{dump_directory}/digests" ) ))
         end
     end
 
@@ -308,14 +270,14 @@ describe Arachni::Data::Issues do
             unsorted_issues.each { |i| subject << i }
             subject.dump( dump_directory )
 
-            subject.should == described_class.load( dump_directory )
+            expect(subject).to eq(described_class.load( dump_directory ))
         end
 
         it 'restores digests from disk' do
             unsorted_issues.each { |i| subject << i }
             subject.dump( dump_directory )
 
-            subject.digests.should == described_class.load( dump_directory ).digests
+            expect(subject.digests).to eq(described_class.load( dump_directory ).digests)
         end
     end
 
@@ -323,7 +285,7 @@ describe Arachni::Data::Issues do
         it 'clears the collection' do
             subject << issue
             subject.clear
-            subject.should be_empty
+            expect(subject).to be_empty
         end
 
         it 'clears #on_new callbacks' do
@@ -332,7 +294,7 @@ describe Arachni::Data::Issues do
             subject.clear
 
             10.times { subject << active_issue }
-            callback_called.should == 0
+            expect(callback_called).to eq(0)
         end
 
         it 'clears #on_new_pre_deduplication callbacks' do
@@ -341,7 +303,7 @@ describe Arachni::Data::Issues do
             subject.clear
 
             10.times { subject << active_issue }
-            callback_called.should == 0
+            expect(callback_called).to eq(0)
         end
     end
 end