arachni 1.2.1 → 1.3

data/spec/arachni/rpc/server/output_spec.rb

@@ -29,7 +29,7 @@ describe Arachni::UI::Output do
 
         it 'sends output to the logfile' do
             @out.print_line( 'blah' )
-            IO.read( @logfile ).split( "\n" ).size == 1
+            expect(IO.read( @logfile ).split( "\n" ).size).to eq(1)
         end
     end
 end

data/spec/arachni/rpc/server/plugin/manager_spec.rb

@@ -5,14 +5,14 @@ describe 'Arachni::RPC::Server::Plugin::Manager' do
 
     describe '#available' do
         it 'returns an array of available plugins' do
-            instance_spawn.plugins.available.should be_any
+            expect(instance_spawn.plugins.available).to be_any
         end
     end
 
     describe '#loaded' do
         context 'when there are loaded plugins' do
             it 'returns an empty array' do
-                instance_spawn.plugins.loaded.should be_empty
+                expect(instance_spawn.plugins.loaded).to be_empty
             end
         end
         context 'when there are loaded plugins' do
@@ -20,7 +20,7 @@ describe 'Arachni::RPC::Server::Plugin::Manager' do
                 plugins = instance_spawn.plugins
 
                 plugins.load( { 'default' => {}} )
-                plugins.loaded.should be_any
+                expect(plugins.loaded).to be_any
             end
         end
     end
@@ -30,7 +30,7 @@ describe 'Arachni::RPC::Server::Plugin::Manager' do
             plugins = instance_spawn.plugins
 
             plugins.load( { 'default' => {}} )
-            plugins.loaded.should == ['default']
+            expect(plugins.loaded).to eq(['default'])
         end
 
         context 'with invalid options' do
@@ -41,7 +41,7 @@ describe 'Arachni::RPC::Server::Plugin::Manager' do
                 rescue Exception
                     raised = true
                 end
-                raised.should be_true
+                expect(raised).to be_truthy
             end
         end
     end
@@ -49,7 +49,7 @@ describe 'Arachni::RPC::Server::Plugin::Manager' do
     describe '#merge_results' do
         it "delegates to ##{Arachni::Data::Plugins}#merge_results" do
             plugins = Arachni::RPC::Server::Framework.new.plugins
-            Arachni::Data.plugins.should receive(:merge_results)
+            expect(Arachni::Data.plugins).to receive(:merge_results)
             plugins.merge_results( [ distributable: { results: { stuff: 2 } } ] )
         end
     end

data/spec/arachni/ruby/array_spec.rb

@@ -10,38 +10,38 @@ describe Array do
         context 'when passed' do
             context 'nil' do
                 it 'returns false' do
-                    @arr.includes_tags?( nil ).should == false
+                    expect(@arr.includes_tags?( nil )).to eq(false)
                 end
             end
 
             context '[]' do
                 it 'returns false' do
-                    @arr.includes_tags?( [] ).should == false
+                    expect(@arr.includes_tags?( [] )).to eq(false)
                 end
             end
 
             context String do
                 context 'when includes the given tag (as either a String or a Symbol)' do
                     it 'returns true' do
-                        [ 1 ].includes_tags?( 1 ).should == true
-                        [ :tag ].includes_tags?( :tag ).should == true
-                        [ :tag ].includes_tags?( 'tag' ).should == true
-                        %w(tag).includes_tags?( 'tag' ).should == true
-                        %w(tag).includes_tags?( :tag ).should == true
-                        [ :tag, 'tag' ].includes_tags?( :tag ).should == true
-                        [ :tag, 'tag' ].includes_tags?( 'tag' ).should == true
+                        expect([ 1 ].includes_tags?( 1 )).to eq(true)
+                        expect([ :tag ].includes_tags?( :tag )).to eq(true)
+                        expect([ :tag ].includes_tags?( 'tag' )).to eq(true)
+                        expect(%w(tag).includes_tags?( 'tag' )).to eq(true)
+                        expect(%w(tag).includes_tags?( :tag )).to eq(true)
+                        expect([ :tag, 'tag' ].includes_tags?( :tag )).to eq(true)
+                        expect([ :tag, 'tag' ].includes_tags?( 'tag' )).to eq(true)
                     end
                 end
                 context 'when it does not includes the given tag (as either a String or a Symbol)' do
                     it 'returns false' do
-                        [ 1 ].includes_tags?( 2 ).should == false
-                        [ :tag ].includes_tags?( :tag1 ).should == false
-                        [ :tag ].includes_tags?( 'tag2' ).should == false
-                        %w(tag).includes_tags?( 'tag3' ).should == false
-                        %w(tag).includes_tags?( :tag5 ).should == false
-                        [ :tag, 'tag' ].includes_tags?( :ta5g ).should == false
-                        [ :tag, 'tag' ].includes_tags?( 'ta4g' ).should == false
-                        [ :t3ag, 'tag1' ].includes_tags?( 'tag' ).should == false
+                        expect([ 1 ].includes_tags?( 2 )).to eq(false)
+                        expect([ :tag ].includes_tags?( :tag1 )).to eq(false)
+                        expect([ :tag ].includes_tags?( 'tag2' )).to eq(false)
+                        expect(%w(tag).includes_tags?( 'tag3' )).to eq(false)
+                        expect(%w(tag).includes_tags?( :tag5 )).to eq(false)
+                        expect([ :tag, 'tag' ].includes_tags?( :ta5g )).to eq(false)
+                        expect([ :tag, 'tag' ].includes_tags?( 'ta4g' )).to eq(false)
+                        expect([ :t3ag, 'tag1' ].includes_tags?( 'tag' )).to eq(false)
                     end
                 end
             end
@@ -49,24 +49,24 @@ describe Array do
             context Array do
                 context 'when includes any of the given tags (as either a String or a Symbol)' do
                     it 'returns true' do
-                        [ 1, 2, 3 ].includes_tags?( [1] ).should == true
-                        [ :tag ].includes_tags?( [:tag] ).should == true
-                        [ :tag ].includes_tags?( ['tag', 12] ).should == true
-                        %w(tag).includes_tags?( ['tag', nil] ).should == true
-                        %w(tag).includes_tags?( [:tag] ).should == true
-                        [ :tag, 'tag' ].includes_tags?( [:tag] ).should == true
-                        [ :tag, 'tag' ].includes_tags?( ['tag', :blah] ).should == true
+                        expect([ 1, 2, 3 ].includes_tags?( [1] )).to eq(true)
+                        expect([ :tag ].includes_tags?( [:tag] )).to eq(true)
+                        expect([ :tag ].includes_tags?( ['tag', 12] )).to eq(true)
+                        expect(%w(tag).includes_tags?( ['tag', nil] )).to eq(true)
+                        expect(%w(tag).includes_tags?( [:tag] )).to eq(true)
+                        expect([ :tag, 'tag' ].includes_tags?( [:tag] )).to eq(true)
+                        expect([ :tag, 'tag' ].includes_tags?( ['tag', :blah] )).to eq(true)
                     end
                 end
                 context 'when it does not include any of the given tags (as either a String or a Symbol)' do
                     it 'returns true' do
-                        [ 1, 2, 3 ].includes_tags?( [4, 5] ).should == false
-                        [ :tag ].includes_tags?( [:ta3g] ).should == false
-                        [ :tag ].includes_tags?( ['ta3g', 12] ).should == false
-                        %w(tag).includes_tags?( ['ta3g', nil] ).should == false
-                        %w(tag).includes_tags?( [:t4ag] ).should == false
-                        [ :tag, 'tag' ].includes_tags?( [:t3ag] ).should == false
-                        [ :tag, 'tag' ].includes_tags?( ['t2ag', :b3lah] ).should == false
+                        expect([ 1, 2, 3 ].includes_tags?( [4, 5] )).to eq(false)
+                        expect([ :tag ].includes_tags?( [:ta3g] )).to eq(false)
+                        expect([ :tag ].includes_tags?( ['ta3g', 12] )).to eq(false)
+                        expect(%w(tag).includes_tags?( ['ta3g', nil] )).to eq(false)
+                        expect(%w(tag).includes_tags?( [:t4ag] )).to eq(false)
+                        expect([ :tag, 'tag' ].includes_tags?( [:t3ag] )).to eq(false)
+                        expect([ :tag, 'tag' ].includes_tags?( ['t2ag', :b3lah] )).to eq(false)
                     end
                 end
             end
@@ -79,33 +79,33 @@ describe Array do
                 "\xE2\x9C\x93",
                 [ "\xE2\x9C\x93" ]
             ].recode
-            recoded.first.should == "\u2713"
-            recoded.last.should == ["\u2713"]
+            expect(recoded.first).to eq("\u2713")
+            expect(recoded.last).to eq(["\u2713"])
         end
     end
 
     describe '#chunk' do
         it 'splits the array into chunks' do
             chunks = @arr.chunk( 5 )
-            chunks.size.should == 5
-            chunks.each { |c| c.size.should == 10 }
+            expect(chunks.size).to eq(5)
+            chunks.each { |c| expect(c.size).to eq(10) }
 
             chunks = @arr.chunk( 3 )
-            chunks.size.should == 3
+            expect(chunks.size).to eq(3)
 
-            chunks[0].size.should == 17
-            chunks[1].size.should == 17
-            chunks[2].size.should == 16
+            expect(chunks[0].size).to eq(17)
+            expect(chunks[1].size).to eq(17)
+            expect(chunks[2].size).to eq(16)
         end
 
         context 'when called without params' do
             it 'splits the array into 2 chunks' do
                 chunks = @arr.chunk
-                chunks.size.should == 2
+                expect(chunks.size).to eq(2)
 
                 24.times do |i|
-                    chunks.first[i].should == i
-                    chunks.last[i].should  == i + 25
+                    expect(chunks.first[i]).to eq(i)
+                    expect(chunks.last[i]).to  eq(i + 25)
                 end
             end
         end

data/spec/arachni/ruby/hash_spec.rb

@@ -25,38 +25,38 @@ describe Hash do
 
     describe '#my_stringify_keys' do
         it 'recursively converts keys to strings' do
-            with_symbols.my_stringify_keys.should == with_strings
+            expect(with_symbols.my_stringify_keys).to eq(with_strings)
         end
 
         context 'when the recursive is set to false' do
             it 'only converts the keys at depth 1' do
-                with_symbols.my_stringify_keys( false ).should == {
+                expect(with_symbols.my_stringify_keys( false )).to eq({
                     'stuff' => 'blah',
                     'more'  => {
                         stuff: {
                             blah: 'stuff'
                         }
                     }
-                }
+                })
             end
         end
     end
 
     describe '#my_symbolize_keys' do
         it 'recursively converts keys to symbols' do
-            with_strings.my_symbolize_keys.should == with_symbols
+            expect(with_strings.my_symbolize_keys).to eq(with_symbols)
         end
 
         context 'when the recursive is set to false' do
             it 'only converts the keys at depth 1' do
-                with_strings.my_symbolize_keys( false ).should == {
+                expect(with_strings.my_symbolize_keys( false )).to eq({
                     stuff: 'blah',
                     more:  {
                         'stuff' => {
                             'blah' => 'stuff'
                         }
                     }
-                }
+                })
             end
         end
     end
@@ -65,29 +65,29 @@ describe Hash do
         it 'converts keys and values to frozen strings' do
             converted = with_symbols.stringify_recursively_and_freeze
 
-            converted.should == with_strings
-            converted.keys.map(&:frozen?).uniq.should == [true]
-            converted.values.map(&:frozen?).uniq.should == [true]
+            expect(converted).to eq(with_strings)
+            expect(converted.keys.map(&:frozen?).uniq).to eq([true])
+            expect(converted.values.map(&:frozen?).uniq).to eq([true])
         end
 
         it 'returns a frozen hash' do
-            with_symbols.stringify_recursively_and_freeze.should be_frozen
+            expect(with_symbols.stringify_recursively_and_freeze).to be_frozen
         end
     end
 
     describe '#my_stringify' do
         it 'returns a Hash with keys and values recursively converted to strings' do
-            {
+            expect({
                 test:         'blah',
                 another_hash: {
                     stuff: 'test'
                 }
-            }.my_stringify.should == {
+            }.my_stringify).to eq({
                 'test'         => 'blah',
                 'another_hash' => {
                     'stuff' => 'test'
                 }
-            }
+            })
         end
     end
 
@@ -99,29 +99,31 @@ describe Hash do
                     blah3: "\xE2\x9C\x93"
                 }
             }.recode
-            recoded[:blah].should == "\u2713"
-            recoded[:blah2][:blah3].should == "\u2713"
+            expect(recoded[:blah]).to eq("\u2713")
+            expect(recoded[:blah2][:blah3]).to eq("\u2713")
         end
     end
 
     describe '#downcase' do
         it 'converts keys and values to lower-case strings' do
-            { Stuff: 'VaLue', 'BlAh' => 'VaLUe 2' }.downcase.should ==
+            expect({ Stuff: 'VaLue', 'BlAh' => 'VaLUe 2' }.downcase).to eq(
                 { 'stuff' => 'value', 'blah' => 'value 2' }
+            )
         end
     end
 
     describe '#find_symbol_keys_recursively' do
         it 'returns all symbol keys from self and children hashes' do
-            {
+            expect({
                 stuff: 'VaLue',
                 stuff2: {
                     stuff3: {
                         stuff4: 'Blah'
                     }
                 }
-            }.find_symbol_keys_recursively.sort.should ==
+            }.find_symbol_keys_recursively.sort).to eq(
                 [:stuff, :stuff2, :stuff3, :stuff4].sort
+            )
         end
     end
 end

data/spec/arachni/ruby/io_spec.rb

@@ -14,12 +14,12 @@ describe IO do
                 EOSTR
                 f.flush
 
-                f.tail( 4 ).should == [
+                expect(f.tail( 4 )).to eq([
                     '                    Test2',
                     '                    Test3',
                     '                    Test4',
                     '                    Test5'
-                ]
+                ])
             end
         end
     end

data/spec/arachni/ruby/object_spec.rb

@@ -15,7 +15,7 @@ describe Object do
             b = a.deep_clone
             a[0] << 3
 
-            b.should == [ [1,2] ]
+            expect(b).to eq([ [1,2] ])
         end
     end
 

data/spec/arachni/ruby/set_spec.rb

@@ -6,9 +6,9 @@ describe Set do
         it 'removes and returns an item from the set' do
             set = described_class.new
             set << 1
-            set.size.should == 1
-            set.shift.should == 1
-            set.size.should == 0
+            expect(set.size).to eq(1)
+            expect(set.shift).to eq(1)
+            expect(set.size).to eq(0)
         end
     end
 

data/spec/arachni/ruby/string_spec.rb

@@ -28,17 +28,17 @@ describe String do
 
     describe '#scan_in_groups' do
         it 'returns regexp matches in named groups' do
-            path.scan_in_groups( regex_with_names ).should == {
+            expect(path.scan_in_groups( regex_with_names )).to eq({
                 'category'   => 'book',
                 'book-id'    => '12',
                 'chapter-id' => '3',
                 'stuff-id'   => '4'
-            }
+            })
         end
 
         context 'when there are no matches' do
             it 'returns an empty hash' do
-                'test'.scan_in_groups( regex_with_names ).should == {}
+                expect('test'.scan_in_groups( regex_with_names )).to eq({})
             end
         end
 
@@ -51,10 +51,10 @@ describe String do
 
     describe '#sub_in_groups' do
         it 'substitutes the named matches' do
-            path.sub_in_groups(
+            expect(path.sub_in_groups(
                 regex_with_names,
                 grouped_substitutions
-            ).should == '/new-category/new-book-id/blahahaha/test/chapter-new-chapter-id/stuff-new-stuff-id/12'
+            )).to eq('/new-category/new-book-id/blahahaha/test/chapter-new-chapter-id/stuff-new-stuff-id/12')
         end
 
         context 'when using invalid group names' do
@@ -71,7 +71,7 @@ describe String do
     describe '#sub_in_groups!' do
         it 'substitutes the named matches in place' do
             path.sub_in_groups!( regex_with_names, grouped_substitutions )
-            path.should == '/new-category/new-book-id/blahahaha/test/chapter-new-chapter-id/stuff-new-stuff-id/12'
+            expect(path).to eq('/new-category/new-book-id/blahahaha/test/chapter-new-chapter-id/stuff-new-stuff-id/12')
         end
 
         context 'when using invalid group names' do
@@ -99,36 +99,36 @@ describe String do
                 Boo-Yah!
             END
 
-            str.rdiff( str2 ).should == "                This is the  test.\n" +
-                '                Not really sure what else to put here'
+            expect(str.rdiff( str2 )).to eq("                This is the  test.\n" +
+                '                Not really sure what else to put here')
         end
     end
 
     describe '#diff_ratio' do
         context 'when the strings are identical' do
             it 'returns 0.0' do
-                ''.diff_ratio( '' ).should == 0
-                'test'.diff_ratio( 'test' ).should == 0
-                'test this'.diff_ratio( 'test this' ).should == 0
+                expect(''.diff_ratio( '' )).to eq(0)
+                expect('test'.diff_ratio( 'test' )).to eq(0)
+                expect('test this'.diff_ratio( 'test this' )).to eq(0)
             end
         end
         context 'when the strings completely different' do
             it 'returns 1.0' do
-                ''.diff_ratio( 'toast' ).should == 1
-                'test'.diff_ratio( 'toast' ).should == 1
-                'test this'.diff_ratio( 'toast that' ).should == 1
+                expect(''.diff_ratio( 'toast' )).to eq(1)
+                expect('test'.diff_ratio( 'toast' )).to eq(1)
+                expect('test this'.diff_ratio( 'toast that' )).to eq(1)
             end
         end
         context 'when the strings share less than half of their words' do
             it 'returns < 0.5' do
-                'test this here now'.diff_ratio( 'test that here now' ).should > 0.0
-                'test this here now'.diff_ratio( 'test that here now' ).should < 0.5
+                expect('test this here now'.diff_ratio( 'test that here now' )).to be > 0.0
+                expect('test this here now'.diff_ratio( 'test that here now' )).to be < 0.5
             end
         end
         context 'when the strings share more than half of their words' do
             it 'returns > 0.5' do
-                'test this here now'.diff_ratio( 'test that here later' ).should > 0.0
-                'test this here now'.diff_ratio( 'test that here later' ).should > 0.5
+                expect('test this here now'.diff_ratio( 'test that here later' )).to be > 0.0
+                expect('test this here now'.diff_ratio( 'test that here later' )).to be > 0.5
             end
         end
     end
@@ -136,17 +136,17 @@ describe String do
     describe '#words' do
         context 'when strict is set to true' do
             it 'does not include boundaries' do
-                'blah.bloo<ha hoo'.words( true ).sort.should == %w(blah bloo ha hoo).sort
+                expect('blah.bloo<ha hoo'.words( true ).sort).to eq(%w(blah bloo ha hoo).sort)
             end
         end
         context 'when strict is set to false' do
             it 'includes boundaries' do
-                'blah.bloo<ha hoo'.words( false ).sort.should ==  [" ", ".", "<", "blah", "bloo", "ha", "hoo"] .sort
+                expect('blah.bloo<ha hoo'.words( false ).sort).to eq([" ", ".", "<", "blah", "bloo", "ha", "hoo"] .sort)
             end
         end
         context 'when strict is not specified' do
             it 'defaults to false' do
-                'blah.bloo<ha hoo'.words.sort.should == 'blah.bloo<ha hoo'.words( false ).sort
+                expect('blah.bloo<ha hoo'.words.sort).to eq('blah.bloo<ha hoo'.words( false ).sort)
             end
         end
     end
@@ -156,7 +156,7 @@ describe String do
 
         it 'removes invalid characters' do
             subject.recode!
-            subject.should == "abcあ�"
+            expect(subject).to eq("abcあ�")
         end
     end
 
@@ -164,23 +164,23 @@ describe String do
         subject { "abc\u3042\x81" }
 
         it 'returns a copy of the String without invalid characters' do
-            subject.recode.should == "abcあ�"
+            expect(subject.recode).to eq("abcあ�")
         end
     end
 
     describe '#persistent_hash' do
         it 'returns an Integer' do
-            'test'.persistent_hash.should be_kind_of Integer
+            expect('test'.persistent_hash).to be_kind_of Integer
         end
 
         context 'when two strings are equal' do
             it 'returns equal values' do
-                'test'.persistent_hash.should == 'test'.persistent_hash
+                expect('test'.persistent_hash).to eq('test'.persistent_hash)
             end
         end
         context 'when two strings are not equal' do
             it 'returns different values' do
-                'test'.persistent_hash.should_not == 'testa'.persistent_hash
+                expect('test'.persistent_hash).not_to eq('testa'.persistent_hash)
             end
         end
     end
@@ -189,12 +189,12 @@ describe String do
         context 'when the content is' do
             context 'binary' do
                 it 'returns true' do
-                    "\ff\ff\ff".binary?.should be_true
+                    expect("\ff\ff\ff".binary?).to be_truthy
                 end
             end
             context 'text' do
                 it 'returns false' do
-                    'test'.binary?.should be_false
+                    expect('test'.binary?).to be_falsey
                 end
             end
         end
@@ -202,13 +202,13 @@ describe String do
 
     describe '#longest_word' do
         it 'returns the longest word' do
-            'o tw longest'.longest_word.should == 'longest'
+            expect('o tw longest'.longest_word).to eq('longest')
         end
     end
 
     describe '#shortest_word' do
         it 'returns the longest word' do
-            'o tw longest'.shortest_word.should == 'o'
+            expect('o tw longest'.shortest_word).to eq('o')
         end
     end
 end