arachni 1.2.1 → 1.3

data/spec/arachni/reporter/base_spec.rb

@@ -13,23 +13,23 @@ describe Arachni::Reporter::Base do
 
     describe '#report' do
         it 'returns the provided report' do
-            @reporters.run( :with_outfile, report ).report.should == report
+            expect(@reporters.run( :with_outfile, report ).report).to eq(report)
         end
     end
 
     describe '#outfile' do
         it 'returns the outfile in options' do
             outfile = 'blahfile'
-            @reporters.run( :with_outfile, @framework.report,
+            expect(@reporters.run( :with_outfile, @framework.report,
                               'outfile' => outfile
-            ).outfile.should == outfile
+            ).outfile).to eq(outfile)
         end
 
         context 'when a directory is provided as an outfile option' do
             it 'returns the path of default outfile filename under that directory' do
-                @reporters.run( :with_outfile, @framework.report,
+                expect(@reporters.run( :with_outfile, @framework.report,
                                   'outfile' => '.'
-                ).outfile.start_with?( File.expand_path( "." ) ).should be_true
+                ).outfile.start_with?( File.expand_path( "." ) )).to be_truthy
             end
         end
     end
@@ -38,25 +38,25 @@ describe Arachni::Reporter::Base do
         context 'when the :skip_responses option is' do
             context true do
                 it 'returns true' do
-                    described_class.new(
+                    expect(described_class.new(
                         report,
                         skip_responses: true
-                    ).skip_responses?.should be_true
+                    ).skip_responses?).to be_truthy
                 end
             end
 
             context false do
                 it 'returns false' do
-                    described_class.new(
+                    expect(described_class.new(
                         report,
                         skip_responses: false
-                    ).skip_responses?.should be_false
+                    ).skip_responses?).to be_falsey
                 end
             end
 
             context 'not set' do
                 it 'returns false' do
-                    described_class.new( report, {} ).skip_responses?.should be_false
+                    expect(described_class.new( report, {} ).skip_responses?).to be_falsey
                 end
             end
         end
@@ -68,7 +68,7 @@ describe Arachni::Reporter::Base do
             store.plugins[:foobar] = { results: 'Blah!' }
 
             @reporters.run( 'with_formatters', store )
-            IO.read( 'with_formatters' ).should == { foobar: 'Blah!' }.to_s
+            expect(IO.read( 'with_formatters' )).to eq({ foobar: 'Blah!' }.to_s)
             File.delete( 'with_formatters' )
         end
     end
@@ -76,20 +76,20 @@ describe Arachni::Reporter::Base do
     describe '.has_outfile?' do
         context 'when the reporter has an outfile option' do
             it 'returns true' do
-                @reporters[:with_outfile].has_outfile?.should be_true
+                expect(@reporters[:with_outfile].has_outfile?).to be_truthy
             end
         end
         context 'when the reporter does not have an outfile option' do
             it 'returns false' do
-                @reporters[:without_outfile].has_outfile?.should be_false
+                expect(@reporters[:without_outfile].has_outfile?).to be_falsey
             end
         end
     end
 
     describe '#has_outfile?' do
         it "delegates to #{described_class}.has_outfile?" do
-            described_class.stub(:has_outfile?) { :stuff }
-            described_class.new( report, {} ).has_outfile?.should == :stuff
+            allow(described_class).to receive(:has_outfile?) { :stuff }
+            expect(described_class.new( report, {} ).has_outfile?).to eq(:stuff)
         end
     end
 

data/spec/arachni/reporter/manager_spec.rb

@@ -15,7 +15,7 @@ describe Arachni::Reporter::Manager do
         it 'runs a reporter by name' do
             @reporters.run( 'foo', report )
 
-            File.exist?( 'foo' ).should be_true
+            expect(File.exist?( 'foo' )).to be_truthy
         end
 
         context 'when options are given' do
@@ -23,7 +23,7 @@ describe Arachni::Reporter::Manager do
                 options = { 'outfile' => 'stuff' }
                 reporter = @reporters.run( :foo, report, options )
 
-                reporter.options.should == options.my_symbolize_keys(false)
+                expect(reporter.options).to eq(options.my_symbolize_keys(false))
             end
         end
 
@@ -56,8 +56,8 @@ describe Arachni::Reporter::Manager do
 
     describe '#reset' do
         it "delegates to #{described_class}.reset" do
-            described_class.stub(:reset) { :stuff }
-            @reporters.reset.should == :stuff
+            allow(described_class).to receive(:reset) { :stuff }
+            expect(@reporters.reset).to eq(:stuff)
         end
     end
 

data/spec/arachni/reporter/options_spec.rb

@@ -9,11 +9,11 @@ describe Arachni::Reporter::Options do
 
     describe '#outfile' do
         it 'returns an :outfile reporter option' do
-            subject.outfile.name.should == :outfile
+            expect(subject.outfile.name).to eq(:outfile)
         end
 
         it 'has a default value' do
-            subject.outfile.default.should be_true
+            expect(subject.outfile.default).to be_truthy
         end
 
         context 'when given an extension' do
@@ -26,22 +26,22 @@ describe Arachni::Reporter::Options do
         context 'when given a description' do
             it 'assigns it to the option' do
                 description = 'My description'
-                subject.outfile( '', description ).description.should == description
+                expect(subject.outfile( '', description ).description).to eq(description)
             end
         end
     end
 
     describe '#skip_responses' do
         it 'returns a :skip_responses reporter option' do
-            subject.skip_responses.name.should == :skip_responses
+            expect(subject.skip_responses.name).to eq(:skip_responses)
         end
 
         it "defaults to 'false'" do
-            subject.skip_responses.default.should == false
+            expect(subject.skip_responses.default).to eq(false)
         end
 
         it 'has a description' do
-            subject.skip_responses.description.should be_true
+            expect(subject.skip_responses.description).to be_truthy
         end
     end
 

data/spec/arachni/rpc/client/base_spec.rb

@@ -54,7 +54,7 @@ describe Arachni::RPC::Client::Base do
             it 'connects to a server' do
                 Server.new( options ) do |server|
                     client = described_class.new( options, server.url )
-                    client.call( "foo.bar" ).should == true
+                    expect(client.call( "foo.bar" )).to eq(true)
                 end
             end
         end
@@ -64,7 +64,7 @@ describe Arachni::RPC::Client::Base do
                 it 'connects successfully' do
                     Server.new( ssl_options ) do |server|
                         client = described_class.new( ssl_options, server.url )
-                        client.call( "foo.bar" ).should be_true
+                        expect(client.call( "foo.bar" )).to be_truthy
                     end
                 end
             end
@@ -83,7 +83,7 @@ describe Arachni::RPC::Client::Base do
                             raised = true
                         end
 
-                        raised.should be_true
+                        expect(raised).to be_truthy
                     end
                 end
             end
@@ -106,7 +106,7 @@ describe Arachni::RPC::Client::Base do
                             raised = true
                         end
 
-                        raised.should be_true
+                        expect(raised).to be_truthy
                     end
                 end
             end
@@ -121,7 +121,7 @@ describe Arachni::RPC::Client::Base do
 
                     Server.new( opts, token ) do |server|
                         client = described_class.new( opts, server.url, token )
-                        client.call( "foo.bar" ).should be_true
+                        expect(client.call( "foo.bar" )).to be_truthy
                     end
                 end
             end
@@ -140,7 +140,7 @@ describe Arachni::RPC::Client::Base do
                             raised = true
                         end
 
-                        raised.should be_true
+                        expect(raised).to be_truthy
                     end
                 end
             end

data/spec/arachni/rpc/client/dispatcher_spec.rb

@@ -13,12 +13,12 @@ describe Arachni::RPC::Client::Dispatcher do
 
     it 'maps the remote handlers to local objects' do
         args = [ 'stuff', 'here', { 'blah' => true } ]
-        @dispatcher.echo.echo( *args ).should == args
+        expect(@dispatcher.echo.echo( *args )).to eq(args)
     end
 
     describe '#node' do
         it 'provides access to the node data' do
-            @dispatcher.node.info.is_a?( Hash ).should be_true
+            expect(@dispatcher.node.info.is_a?( Hash )).to be_truthy
         end
     end
 

data/spec/arachni/rpc/client/instance_spec.rb

@@ -12,7 +12,7 @@ describe Arachni::RPC::Client::Instance do
         context 'which requires a token' do
             context 'with a valid token' do
                 it 'connects successfully' do
-                    @instance.service.alive?.should be_true
+                    expect(@instance.service.alive?).to be_truthy
                 end
             end
 
@@ -35,8 +35,8 @@ describe Arachni::RPC::Client::Instance do
         describe '#set' do
             it 'allows batch assigning using a hash' do
                 val = @foo_url + '3'
-                @rpc_opts.set( url: val ).should be_true
-                @rpc_opts.url.to_s.should == val
+                expect(@rpc_opts.set( url: val )).to be_truthy
+                expect(@rpc_opts.url.to_s).to eq(val)
             end
         end
     end
@@ -44,21 +44,21 @@ describe Arachni::RPC::Client::Instance do
     describe '#framework' do
         before { @framework = @instance.framework }
         it 'provides access to framework methods' do
-            @framework.status.should be_true
+            expect(@framework.status).to be_truthy
         end
     end
 
     describe '#checks' do
         before { @checks = @instance.checks }
         it 'provides access to checks manager methods' do
-            @checks.available.should be_true
+            expect(@checks.available).to be_truthy
         end
     end
 
     describe '#plugins' do
         before { @plugins = @instance.plugins }
         it 'provides access to plugin manager methods' do
-            @plugins.available.should be_true
+            expect(@plugins.available).to be_truthy
         end
     end
 

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

@@ -13,7 +13,7 @@ describe Arachni::RPC::Server::ActiveOptions do
 
     describe '#set' do
         it 'sets options by hash' do
-            @instance.service.cookies.should be_empty
+            expect(@instance.service.cookies).to be_empty
 
             opts = {
                 'url'   =>  'http://blah.com',
@@ -35,23 +35,26 @@ describe Arachni::RPC::Server::ActiveOptions do
             @instance.options.set( opts )
             h = @instance.options.to_h
 
-            h['url'].to_s.should == @utils.normalize_url( opts['url'] )
-            h['scope']['exclude_path_patterns'].should ==
+            expect(h['url'].to_s).to eq(@utils.normalize_url( opts['url'] ))
+            expect(h['scope']['exclude_path_patterns']).to eq(
                 opts['scope']['exclude_path_patterns'].map { |s| Regexp.new(s).to_s }
-            h['scope']['include_path_patterns'].should ==
+            )
+            expect(h['scope']['include_path_patterns']).to eq(
                 opts['scope']['include_path_patterns'].map { |s| Regexp.new(s).to_s }
-            h['scope']['redundant_path_patterns'].should ==
+            )
+            expect(h['scope']['redundant_path_patterns']).to eq(
                 opts['scope']['redundant_path_patterns'].
                     inject({}) { |hh, (k, v)| hh[Regexp.new(k).to_s] = v.to_s; hh }
+            )
 
-            h['datastore'].should == opts['datastore']
+            expect(h['datastore']).to eq(opts['datastore'])
 
-            @instance.service.cookies.map { |c| Arachni::Cookie.from_rpc_data c }.should == [
+            expect(@instance.service.cookies.map { |c| Arachni::Cookie.from_rpc_data c }).to eq([
                 Arachni::Cookie.new( url: opts['url'], inputs: { 'name'  => 'value' } ),
                 Arachni::Cookie.new( url: opts['url'], inputs: { 'name2'  => 'value2' } ),
                 Arachni::Cookie.new( url: opts['url'], inputs: { 'name3'  => 'value3' } ),
                 Arachni::Cookie.new( url: opts['url'], inputs: { 'name4'  => 'value4' } )
-            ]
+            ])
         end
     end
 end

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

@@ -29,14 +29,14 @@ describe Arachni::RPC::Server::Base do
             raised = true
         end
 
-        server.ready?.should be_true
-        raised.should be_false
+        expect(server.ready?).to be_truthy
+        expect(raised).to be_falsey
     end
 
     describe '#ready?' do
         context 'when the server is not ready' do
             it 'returns false' do
-                @server.ready?.should be_false
+                expect(@server.ready?).to be_falsey
             end
         end
 
@@ -53,8 +53,8 @@ describe Arachni::RPC::Server::Base do
                     raised = true
                 end
 
-                @server.ready?.should be_true
-                raised.should be_false
+                expect(@server.ready?).to be_truthy
+                expect(raised).to be_falsey
             end
         end
     end

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

@@ -4,23 +4,23 @@ require Arachni::Options.paths.lib + 'rpc/server/framework'
 describe Arachni::RPC::Server::Check::Manager do
     describe '#available' do
         it 'returns an array of available checks' do
-            instance_spawn.checks.available.should be_any
+            expect(instance_spawn.checks.available).to be_any
         end
     end
 
     describe '#loaded' do
         context 'when there are loaded checks' do
             it 'returns an empty array' do
-                instance_spawn.checks.loaded.should be_empty
+                expect(instance_spawn.checks.loaded).to be_empty
             end
         end
         context 'when there are loaded checks' do
             it 'returns an array of loaded checks' do
                 checks = instance_spawn.checks
 
-                checks.loaded.should be_empty
+                expect(checks.loaded).to be_empty
                 checks.load '*'
-                checks.loaded.should be_any
+                expect(checks.loaded).to be_any
             end
         end
     end
@@ -29,9 +29,9 @@ describe Arachni::RPC::Server::Check::Manager do
         it 'loads checks by name' do
             checks = instance_spawn.checks
 
-            checks.loaded.should be_empty
+            expect(checks.loaded).to be_empty
             checks.load 'test'
-            checks.loaded.should == ['test']
+            expect(checks.loaded).to eq(['test'])
         end
     end
 
@@ -39,9 +39,9 @@ describe Arachni::RPC::Server::Check::Manager do
         it 'loads all checks' do
             checks = instance_spawn.checks
 
-            checks.loaded.should be_empty
+            expect(checks.loaded).to be_empty
             checks.load_all
-            checks.loaded.should == checks.available
+            expect(checks.loaded).to eq(checks.available)
         end
     end
 

data/spec/arachni/rpc/server/dispatcher/node_spec.rb

@@ -44,13 +44,13 @@ describe Arachni::RPC::Server::Dispatcher::Node do
                 options.dispatcher.neighbour = nil
                 sleep 4
 
-                c.grid_member?.should be_true
+                expect(c.grid_member?).to be_truthy
             end
         end
 
         context 'when the dispatcher is not a grid member' do
             it 'should return false' do
-                @node.grid_member?.should be_false
+                expect(@node.grid_member?).to be_falsey
             end
         end
     end
@@ -71,13 +71,13 @@ describe Arachni::RPC::Server::Dispatcher::Node do
             n.add_neighbour( '127.0.0.1:' + port.to_s )
 
             sleep 4
-            n.neighbours.should be_empty
+            expect(n.neighbours).to be_empty
 
             c = @get_node.call( port )
 
             sleep 4
-            n.neighbours.should == [c.url]
-            c.neighbours.should == [n.url]
+            expect(n.neighbours).to eq([c.url])
+            expect(c.neighbours).to eq([n.url])
 
             options.dispatcher.neighbour = nil
         end
@@ -99,14 +99,14 @@ describe Arachni::RPC::Server::Dispatcher::Node do
             n.add_neighbour( c.url )
             sleep 1
 
-            c.neighbours.should == [n.url]
-            n.neighbours.should == [c.url]
+            expect(c.neighbours).to eq([n.url])
+            expect(n.neighbours).to eq([c.url])
 
             n.shutdown rescue Arachni::RPC::Exceptions::ConnectionError
 
             sleep 4
 
-            c.neighbours.should be_empty
+            expect(c.neighbours).to be_empty
         end
     end
 
@@ -117,22 +117,22 @@ describe Arachni::RPC::Server::Dispatcher::Node do
             options.dispatcher.neighbour = n.url
             c = @get_node.call
             sleep 4
-            c.neighbours.should == [n.url]
-            n.neighbours.should == [c.url]
+            expect(c.neighbours).to eq([n.url])
+            expect(n.neighbours).to eq([c.url])
 
             d = @get_node.call
             sleep 4
-            d.neighbours.sort.should == [n.url, c.url].sort
-            c.neighbours.sort.should == [n.url, d.url].sort
-            n.neighbours.sort.should == [c.url, d.url].sort
+            expect(d.neighbours.sort).to eq([n.url, c.url].sort)
+            expect(c.neighbours.sort).to eq([n.url, d.url].sort)
+            expect(n.neighbours.sort).to eq([c.url, d.url].sort)
 
             options.dispatcher.neighbour = d.url
             e = @get_node.call
             sleep 4
-            e.neighbours.sort.should == [n.url, c.url, d.url].sort
-            d.neighbours.sort.should == [n.url, c.url, e.url].sort
-            c.neighbours.sort.should == [n.url, d.url, e.url].sort
-            n.neighbours.sort.should == [c.url, d.url, e.url].sort
+            expect(e.neighbours.sort).to eq([n.url, c.url, d.url].sort)
+            expect(d.neighbours.sort).to eq([n.url, c.url, e.url].sort)
+            expect(c.neighbours.sort).to eq([n.url, d.url, e.url].sort)
+            expect(n.neighbours.sort).to eq([c.url, d.url, e.url].sort)
 
             options.dispatcher.neighbour = nil
         end
@@ -145,8 +145,8 @@ describe Arachni::RPC::Server::Dispatcher::Node do
         it 'adds a neighbour' do
             @node.add_neighbour( @n.url )
             sleep 0.5
-            @node.neighbours.should == [@n.url]
-            @n.neighbours.should == [@node.url]
+            expect(@node.neighbours).to eq([@n.url])
+            expect(@n.neighbours).to eq([@node.url])
         end
         context 'when propagate is set to true' do
             it 'announces the new neighbour to the existing neighbours' do
@@ -154,32 +154,32 @@ describe Arachni::RPC::Server::Dispatcher::Node do
                 @node.add_neighbour( n.url, true )
                 sleep 0.5
 
-                @node.neighbours.sort.should == [@n.url, n.url].sort
-                @n.neighbours.sort.should == [@node.url, n.url].sort
+                expect(@node.neighbours.sort).to eq([@n.url, n.url].sort)
+                expect(@n.neighbours.sort).to eq([@node.url, n.url].sort)
 
                 c = @get_node.call
                 n.add_neighbour( c.url, true )
                 sleep 0.5
 
-                @node.neighbours.sort.should == [@n.url, n.url, c.url].sort
-                @n.neighbours.sort.should == [@node.url, n.url, c.url].sort
-                c.neighbours.sort.should == [@node.url, n.url, @n.url].sort
+                expect(@node.neighbours.sort).to eq([@n.url, n.url, c.url].sort)
+                expect(@n.neighbours.sort).to eq([@node.url, n.url, c.url].sort)
+                expect(c.neighbours.sort).to eq([@node.url, n.url, @n.url].sort)
 
                 d = @get_node.call
                 d.add_neighbour( c.url, true )
                 sleep 0.5
 
-                @node.neighbours.sort.should == [d.url, @n.url, n.url, c.url].sort
-                @n.neighbours.sort.should == [d.url, @node.url, n.url, c.url].sort
-                c.neighbours.sort.should == [d.url, @node.url, n.url, @n.url].sort
-                d.neighbours.sort.should == [c.url, @node.url, n.url, @n.url].sort
+                expect(@node.neighbours.sort).to eq([d.url, @n.url, n.url, c.url].sort)
+                expect(@n.neighbours.sort).to eq([d.url, @node.url, n.url, c.url].sort)
+                expect(c.neighbours.sort).to eq([d.url, @node.url, n.url, @n.url].sort)
+                expect(d.neighbours.sort).to eq([c.url, @node.url, n.url, @n.url].sort)
             end
         end
     end
 
     describe '#neighbours' do
         it 'returns an array of neighbours' do
-            @node.neighbours.is_a?( Array ).should be_true
+            expect(@node.neighbours.is_a?( Array )).to be_truthy
         end
     end
 
@@ -188,7 +188,7 @@ describe Arachni::RPC::Server::Dispatcher::Node do
             @node.neighbours_with_info.size == @node.neighbours.size
             keys = @node.info.keys.sort
             @node.neighbours_with_info.each do |i|
-                i.keys.sort.should == keys
+                expect(i.keys.sort).to eq(keys)
             end
         end
     end
@@ -203,24 +203,24 @@ describe Arachni::RPC::Server::Dispatcher::Node do
             n = @get_node.call
             info = n.info
 
-            info['url'].should == n.url
-            info['pipe_id'].should == options.dispatcher.node_pipe_id
-            info['weight'].should == options.dispatcher.node_weight
-            info['nickname'].should == options.dispatcher.node_nickname
-            info['cost'].should == options.dispatcher.node_cost
+            expect(info['url']).to eq(n.url)
+            expect(info['pipe_id']).to eq(options.dispatcher.node_pipe_id)
+            expect(info['weight']).to eq(options.dispatcher.node_weight)
+            expect(info['nickname']).to eq(options.dispatcher.node_nickname)
+            expect(info['cost']).to eq(options.dispatcher.node_cost)
         end
 
         context 'when Options#dispatcher_external_address has been set' do
             it 'advertises that address' do
                 options.dispatcher.external_address = '9.9.9.9'
-                @get_node.call.info['url'].should start_with options.dispatcher.external_address
+                expect(@get_node.call.info['url']).to start_with options.dispatcher.external_address
             end
         end
     end
 
     describe '#alive?' do
         it 'returns true' do
-            @get_node.call.alive?.should be_true
+            expect(@get_node.call.alive?).to be_truthy
         end
     end
 end