arachni 1.2.1 → 1.3

data/spec/arachni/state/http_spec.rb

@@ -13,13 +13,13 @@ describe Arachni::State::HTTP do
 
     describe '#headers' do
         it 'returns a Hash' do
-            subject.headers.should be_kind_of Hash
+            expect(subject.headers).to be_kind_of Hash
         end
     end
 
     describe '#cookie_jar' do
         it "returns a #{Arachni::HTTP::CookieJar}" do
-            subject.cookie_jar.should be_kind_of Arachni::HTTP::CookieJar
+            expect(subject.cookie_jar).to be_kind_of Arachni::HTTP::CookieJar
         end
     end
 
@@ -28,7 +28,7 @@ describe Arachni::State::HTTP do
 
         it 'includes :cookies' do
             subject.cookie_jar << cookie
-            statistics[:cookies].should == [cookie.to_s]
+            expect(statistics[:cookies]).to eq([cookie.to_s])
         end
     end
 
@@ -46,15 +46,15 @@ describe Arachni::State::HTTP do
             subject.dump( dump_directory )
 
             http = described_class.load( dump_directory )
-            http.headers.should == subject.headers
-            http.cookie_jar.should == subject.cookie_jar
+            expect(http.headers).to eq(subject.headers)
+            expect(http.cookie_jar).to eq(subject.cookie_jar)
         end
     end
 
     describe '#clear' do
         it 'clears the list' do
-            subject.headers.should receive(:clear)
-            subject.cookie_jar.should receive(:clear)
+            expect(subject.headers).to receive(:clear)
+            expect(subject.cookie_jar).to receive(:clear)
 
             subject.clear
         end

data/spec/arachni/state/options_spec.rb

@@ -10,24 +10,24 @@ describe Arachni::State::Options do
         @dump_directory = "#{Dir.tmpdir}/options-#{Arachni::Utilities.generate_token}"
     end
 
-    it { should respond_to :clear}
+    it { is_expected.to respond_to :clear}
 
     describe '#statistics' do
         let(:statistics) { subject.statistics }
 
         it 'includes :url' do
             Arachni::Options.url = 'http://test/'
-            statistics[:url].should == Arachni::Options.url
+            expect(statistics[:url]).to eq(Arachni::Options.url)
         end
 
         it 'includes :checks' do
             Arachni::Options.checks = %w(xss* sql_injection)
-            statistics[:checks].should == Arachni::Options.checks
+            expect(statistics[:checks]).to eq(Arachni::Options.checks)
         end
 
         it 'includes :plugins' do
             Arachni::Options.plugins = { 'autologin' => {} }
-            statistics[:plugins].should == %w(autologin)
+            expect(statistics[:plugins]).to eq(%w(autologin))
         end
     end
 
@@ -36,8 +36,8 @@ describe Arachni::State::Options do
             Arachni::Options.datastore.my_custom_option = 'my value'
             subject.dump( dump_directory )
 
-            Arachni::Options.load( "#{dump_directory}/options" ).
-                datastore.my_custom_option.should == 'my value'
+            expect(Arachni::Options.load( "#{dump_directory}/options" ).
+                datastore.my_custom_option).to eq('my value')
         end
     end
 
@@ -48,7 +48,7 @@ describe Arachni::State::Options do
 
             described_class.load( dump_directory )
 
-            Arachni::Options.datastore.my_custom_option.should == 'my value'
+            expect(Arachni::Options.datastore.my_custom_option).to eq('my value')
         end
     end
 

data/spec/arachni/state/plugins_spec.rb

@@ -18,7 +18,7 @@ describe Arachni::State::Plugins do
 
     describe '#runtime' do
         it 'returns a Hash' do
-            subject.runtime.should be_kind_of Hash
+            expect(subject.runtime).to be_kind_of Hash
         end
     end
 
@@ -29,7 +29,7 @@ describe Arachni::State::Plugins do
 
             subject.store( :distributable, result )
 
-            subject.statistics[:names].should == [:distributable]
+            expect(subject.statistics[:names]).to eq([:distributable])
         end
     end
 
@@ -39,7 +39,7 @@ describe Arachni::State::Plugins do
             result = { stuff: 1 }
 
             subject.store( :distributable, result )
-            subject[:distributable].should == result
+            expect(subject[:distributable]).to eq(result)
         end
     end
 
@@ -49,10 +49,10 @@ describe Arachni::State::Plugins do
             subject.dump( dump_directory )
 
             results_file = "#{dump_directory}/runtime/distributable"
-            File.exists?( results_file ).should be_true
-            subject.runtime.should == {
+            expect(File.exists?( results_file )).to be_truthy
+            expect(subject.runtime).to eq({
                 distributable: Marshal.load( IO.read( results_file ) )
-            }
+            })
         end
     end
 
@@ -61,14 +61,14 @@ describe Arachni::State::Plugins do
             subject.runtime[:distributable] = { stuff: 1 }
             subject.dump( dump_directory )
 
-            subject.runtime.should == described_class.load( dump_directory ).runtime
+            expect(subject.runtime).to eq(described_class.load( dump_directory ).runtime)
         end
     end
 
     describe '#clear' do
         %w(runtime).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/state_spec.rb

@@ -15,37 +15,37 @@ describe Arachni::State do
 
     describe '#audit' do
         it "returns an instance of #{described_class::Audit}" do
-            subject.audit.should be_kind_of described_class::Audit
+            expect(subject.audit).to be_kind_of described_class::Audit
         end
     end
 
     describe '#element_filter' do
         it "returns an instance of #{described_class::ElementFilter}" do
-            subject.element_filter.should be_kind_of described_class::ElementFilter
+            expect(subject.element_filter).to be_kind_of described_class::ElementFilter
         end
     end
 
     describe '#framework' do
         it "returns an instance of #{described_class::Framework}" do
-            subject.framework.should be_kind_of described_class::Framework
+            expect(subject.framework).to be_kind_of described_class::Framework
         end
     end
 
     describe '#options' do
         it "returns an instance of #{described_class::Options}" do
-            subject.options.should be_kind_of described_class::Options
+            expect(subject.options).to be_kind_of described_class::Options
         end
     end
 
     describe '#http' do
         it "returns an instance of #{described_class::HTTP}" do
-            subject.http.should be_kind_of described_class::HTTP
+            expect(subject.http).to be_kind_of described_class::HTTP
         end
     end
 
     describe '#plugins' do
         it "returns an instance of #{described_class::Plugins}" do
-            subject.plugins.should be_kind_of described_class::Plugins
+            expect(subject.plugins).to be_kind_of described_class::Plugins
         end
     end
 
@@ -56,7 +56,7 @@ describe Arachni::State do
     describe '#statistics' do
         %w(options audit element_filter framework http plugins).each do |name|
             it "includes :#{name} statistics" do
-                subject.statistics[name.to_sym].should == subject.send(name).statistics
+                expect(subject.statistics[name.to_sym]).to eq(subject.send(name).statistics)
             end
         end
     end
@@ -70,8 +70,8 @@ describe Arachni::State do
 
                 new_instance = subject.load( dump_directory ).send(name)
 
-                new_instance.should be_kind_of subject.send(name).class
-                new_instance.object_id.should_not == previous_instance.object_id
+                expect(new_instance).to be_kind_of subject.send(name).class
+                expect(new_instance.object_id).not_to eq(previous_instance.object_id)
             end
         end
     end
@@ -79,7 +79,7 @@ describe Arachni::State do
     describe '#clear' do
         %w(options audit element_filter framework http plugins).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/support/buffer/autoflush_spec.rb

@@ -14,11 +14,11 @@ describe Arachni::Support::Buffer::AutoFlush do
 
                     20.times { |i| b << i }
 
-                    buffers.size.should == 2
-                    buffers.shift.should == (0..9).to_a
-                    buffers.shift.should == (10...20).to_a
+                    expect(buffers.size).to eq(2)
+                    expect(buffers.shift).to eq((0..9).to_a)
+                    expect(buffers.shift).to eq((10...20).to_a)
 
-                    b.should be_empty
+                    expect(b).to be_empty
                 end
             end
         end
@@ -35,10 +35,10 @@ describe Arachni::Support::Buffer::AutoFlush do
 
                     20.times { |i| b << i }
 
-                    buffers.size.should == 2
-                    buffers.shift.should == (0..9).to_a
-                    buffers.shift.should == (10...20).to_a
-                    b.should be_empty
+                    expect(buffers.size).to eq(2)
+                    expect(buffers.shift).to eq((0..9).to_a)
+                    expect(buffers.shift).to eq((10...20).to_a)
+                    expect(b).to be_empty
 
                     b = described_class.new( 99999, 10 )
 
@@ -49,10 +49,10 @@ describe Arachni::Support::Buffer::AutoFlush do
 
                     20.times { |i| b.batch_push (0..1000).to_a }
 
-                    buffers.size.should == 2
-                    buffers.shift.should == (0..1000).to_a
-                    buffers.shift.should == (0..1000).to_a
-                    b.should be_empty
+                    expect(buffers.size).to eq(2)
+                    expect(buffers.shift).to eq((0..1000).to_a)
+                    expect(buffers.shift).to eq((0..1000).to_a)
+                    expect(b).to be_empty
                 end
             end
         end
@@ -62,15 +62,15 @@ describe Arachni::Support::Buffer::AutoFlush do
                 b = described_class.new( 10, 999, Set )
                 b << 'test'
                 b << 'test'
-                b.size.should == 1
-                b.flush.class.should == Set
+                expect(b.size).to eq(1)
+                expect(b.flush.class).to eq(Set)
 
                 b = described_class.new
                 b << 'test'
                 b << 'test'
-                b.size.should == 2
+                expect(b.size).to eq(2)
 
-                b.flush.class.should == Array
+                expect(b.flush.class).to eq(Array)
             end
         end
     end

data/spec/arachni/support/buffer/base_spec.rb

@@ -7,7 +7,7 @@ describe Arachni::Support::Buffer::Base do
             it 'determines whether or not the buffer is full' do
                 b = described_class.new( 10 )
                 20.times { |i| b << i }
-                b.full?.should be_true
+                expect(b.full?).to be_truthy
             end
         end
 
@@ -16,15 +16,15 @@ describe Arachni::Support::Buffer::Base do
                 b = described_class.new( 10, Set )
                 b << 'test'
                 b << 'test'
-                b.size.should == 1
-                b.flush.class.should == Set
+                expect(b.size).to eq(1)
+                expect(b.flush.class).to eq(Set)
 
                 b = described_class.new
                 b << 'test'
                 b << 'test'
-                b.size.should == 2
+                expect(b.size).to eq(2)
 
-                b.flush.class.should == Array
+                expect(b.flush.class).to eq(Array)
             end
         end
     end
@@ -34,13 +34,13 @@ describe Arachni::Support::Buffer::Base do
             b = described_class.new
             b << 'test'
             b << 'test'
-            b.size.should == 2
+            expect(b.size).to eq(2)
         end
         it 'aliased to #push' do
             b = described_class.new
             b.push 'test'
             b.push 'test'
-            b.size.should == 2
+            expect(b.size).to eq(2)
         end
     end
 
@@ -48,7 +48,7 @@ describe Arachni::Support::Buffer::Base do
         it 'pushes a batch of entries' do
             b = described_class.new
             b.batch_push [ 'test', 'test2' ]
-            b.size.should == 2
+            expect(b.size).to eq(2)
         end
     end
 
@@ -56,7 +56,7 @@ describe Arachni::Support::Buffer::Base do
         it 'returns the number of entries in the buffer' do
             b = described_class.new
             b.batch_push [ 'test', 'test2', 'test3' ]
-            b.size.should == 3
+            expect(b.size).to eq(3)
         end
     end
 
@@ -65,14 +65,14 @@ describe Arachni::Support::Buffer::Base do
             context 'is empty' do
                 it 'returns true' do
                     b = described_class.new( 10 )
-                    b.empty?.should be_true
+                    expect(b.empty?).to be_truthy
                 end
             end
             context 'is not empty' do
                 it 'returns false' do
                     b = described_class.new( 10 )
                     b << 1
-                    b.empty?.should be_false
+                    expect(b.empty?).to be_falsey
                 end
             end
         end
@@ -84,14 +84,14 @@ describe Arachni::Support::Buffer::Base do
                 it 'returns true' do
                     b = described_class.new( 10 )
                     20.times { |i| b << i }
-                    b.full?.should be_true
+                    expect(b.full?).to be_truthy
                 end
             end
             context 'not reached its maximum size' do
                 it 'returns false' do
                     b = described_class.new( 100 )
                     20.times { |i| b << i }
-                    b.full?.should be_false
+                    expect(b.full?).to be_falsey
                 end
             end
         end
@@ -101,18 +101,18 @@ describe Arachni::Support::Buffer::Base do
         it 'returns buffer contents' do
             b = described_class.new
             b.batch_push [ 'test', 'test2', 'test3' ]
-            b.size.should == 3
+            expect(b.size).to eq(3)
 
-            b.flush.should == [ 'test', 'test2', 'test3' ]
-            b.size.should == 0
+            expect(b.flush).to eq([ 'test', 'test2', 'test3' ])
+            expect(b.size).to eq(0)
         end
         it 'empties the buffer' do
             b = described_class.new
             b.batch_push [ 'test', 'test2', 'test3' ]
-            b.size.should == 3
+            expect(b.size).to eq(3)
 
-            b.flush.should == [ 'test', 'test2', 'test3' ]
-            b.size.should == 0
+            expect(b.flush).to eq([ 'test', 'test2', 'test3' ])
+            expect(b.size).to eq(0)
         end
     end
 
@@ -123,30 +123,30 @@ describe Arachni::Support::Buffer::Base do
             b = described_class.new
 
             call_args = []
-            b.on_push do |buffer|
+            expect(b.on_push do |buffer|
                 call_args << buffer
-            end.should == b
+            end).to eq(b)
 
-            b.on_push do |buffer|
+            expect(b.on_push do |buffer|
                 call_args << buffer
-            end.should == b
+            end).to eq(b)
 
             b << item
-            call_args.should == [ item, item]
+            expect(call_args).to eq([ item, item])
 
             b = described_class.new
 
             call_args = []
-            b.on_push do |buffer|
+            expect(b.on_push do |buffer|
                 call_args << buffer
-            end.should == b
+            end).to eq(b)
 
-            b.on_push do |buffer|
+            expect(b.on_push do |buffer|
                 call_args << buffer
-            end.should == b
+            end).to eq(b)
 
             b.push item
-            call_args.should == [ item, item]
+            expect(call_args).to eq([ item, item])
         end
     end
 
@@ -157,16 +157,16 @@ describe Arachni::Support::Buffer::Base do
             b = described_class.new
 
             call_args = []
-            b.on_batch_push do |buffer|
+            expect(b.on_batch_push do |buffer|
                 call_args << buffer
-            end.should == b
+            end).to eq(b)
 
-            b.on_batch_push do |buffer|
+            expect(b.on_batch_push do |buffer|
                 call_args << buffer
-            end.should == b
+            end).to eq(b)
 
             b.batch_push item
-            call_args.should == [ item, item]
+            expect(call_args).to eq([ item, item])
         end
     end
 
@@ -178,16 +178,16 @@ describe Arachni::Support::Buffer::Base do
             b << item
 
             call_args = []
-            b.on_flush do |buffer|
+            expect(b.on_flush do |buffer|
                 call_args << buffer
-            end.should == b
+            end).to eq(b)
 
-            b.on_flush do |buffer|
+            expect(b.on_flush do |buffer|
                 call_args << buffer
-            end.should == b
+            end).to eq(b)
 
             b.flush
-            call_args.should == [ [item], [item]]
+            expect(call_args).to eq([ [item], [item]])
         end
     end
 end