arachni 1.2.1 → 1.3

data/spec/arachni/check/base_spec.rb

@@ -21,34 +21,34 @@ describe Arachni::Check::Base do
 
     describe '#session' do
         it "returns #{Arachni::Framework}#session" do
-            subject.session.should == framework.session
+            expect(subject.session).to eq(framework.session)
         end
     end
 
     describe '#plugins' do
         it "returns #{Arachni::Framework}#plugins" do
-            subject.plugins.should == framework.plugins
+            expect(subject.plugins).to eq(framework.plugins)
         end
     end
 
     describe '#has_platforms?' do
         context 'when platforms are provided' do
             before do
-                described_class.stub(:info) { { platforms: [ :unix ] } }
+                allow(described_class).to receive(:info) { { platforms: [ :unix ] } }
             end
 
             it 'returns true' do
-                described_class.has_platforms?.should be_true
+                expect(described_class.has_platforms?).to be_truthy
             end
         end
 
         context 'when platforms are not provided' do
             before do
-                described_class.stub(:info) { { platforms: [] } }
+                allow(described_class).to receive(:info) { { platforms: [] } }
             end
 
             it 'returns false' do
-                described_class.has_platforms?.should be_false
+                expect(described_class.has_platforms?).to be_falsey
             end
         end
     end
@@ -56,21 +56,21 @@ describe Arachni::Check::Base do
     describe '#has_exempt_platforms?' do
         context 'when exempt platforms are provided' do
             before do
-                described_class.stub(:info) { { exempt_platforms: [ :unix ] } }
+                allow(described_class).to receive(:info) { { exempt_platforms: [ :unix ] } }
             end
 
             it 'returns true' do
-                described_class.has_exempt_platforms?.should be_true
+                expect(described_class.has_exempt_platforms?).to be_truthy
             end
         end
 
         context 'when exempt platforms are not provided' do
             before do
-                described_class.stub(:info) { { exempt_platforms: [] } }
+                allow(described_class).to receive(:info) { { exempt_platforms: [] } }
             end
 
             it 'returns false' do
-                described_class.has_exempt_platforms?.should be_false
+                expect(described_class.has_exempt_platforms?).to be_falsey
             end
         end
     end
@@ -78,118 +78,118 @@ describe Arachni::Check::Base do
     describe '#supports_platforms?' do
         context 'when empty platforms are given' do
             it 'returns true' do
-                described_class.supports_platforms?([]).should be_true
+                expect(described_class.supports_platforms?([])).to be_truthy
             end
         end
 
         context 'when no supported platforms are declared' do
             before do
-                described_class.stub(:info) { { platforms: [] } }
+                allow(described_class).to receive(:info) { { platforms: [] } }
             end
 
             it 'returns true' do
-                described_class.supports_platforms?([]).should be_true
+                expect(described_class.supports_platforms?([])).to be_truthy
             end
         end
 
         context 'when any of the given platforms are supported' do
             before do
-                described_class.stub(:info) { { platforms: [:php] } }
+                allow(described_class).to receive(:info) { { platforms: [:php] } }
             end
 
             it 'returns true' do
-                described_class.supports_platforms?([:unix, :php]).should be_true
+                expect(described_class.supports_platforms?([:unix, :php])).to be_truthy
             end
         end
 
         context 'when any of the given platforms are exempt' do
             before do
-                described_class.stub(:info) { { exempt_platforms: [:php] } }
+                allow(described_class).to receive(:info) { { exempt_platforms: [:php] } }
             end
 
             it 'returns false' do
-                described_class.supports_platforms?([:unix, :php]).should be_false
+                expect(described_class.supports_platforms?([:unix, :php])).to be_falsey
             end
         end
 
         context 'when a parent of any of the given platforms is supported' do
             before do
-                described_class.stub(:info) { { platforms: [:unix] } }
+                allow(described_class).to receive(:info) { { platforms: [:unix] } }
             end
 
             it 'returns true' do
-                described_class.supports_platforms?([:linux]).should be_true
+                expect(described_class.supports_platforms?([:linux])).to be_truthy
             end
         end
 
         context 'when a parent of any of the given platforms is exempt' do
             before do
-                described_class.stub(:info) { { exempt_platforms: [:unix] } }
+                allow(described_class).to receive(:info) { { exempt_platforms: [:unix] } }
             end
 
             it 'returns false' do
-                described_class.supports_platforms?([:linux]).should be_false
+                expect(described_class.supports_platforms?([:linux])).to be_falsey
             end
         end
 
 
         context 'when a child of any of the given platforms is supported' do
             before do
-                described_class.stub(:info) { { platforms: [:linux] } }
+                allow(described_class).to receive(:info) { { platforms: [:linux] } }
             end
 
             it 'returns true' do
-                described_class.supports_platforms?([:unix]).should be_true
+                expect(described_class.supports_platforms?([:unix])).to be_truthy
             end
         end
 
         context 'when a child of any of the given platforms is exempt' do
             before do
-                described_class.stub(:info) { { exempt_platforms: [:linux] } }
+                allow(described_class).to receive(:info) { { exempt_platforms: [:linux] } }
             end
 
             it 'returns false' do
-                described_class.supports_platforms?([:unix]).should be_false
+                expect(described_class.supports_platforms?([:unix])).to be_falsey
             end
         end
 
         context 'when none of the given platforms are not provided' do
             before do
-                described_class.stub(:info) { { platforms: [:windows] } }
+                allow(described_class).to receive(:info) { { platforms: [:windows] } }
             end
 
             it 'returns false' do
-                described_class.supports_platforms?([:unix]).should be_false
+                expect(described_class.supports_platforms?([:unix])).to be_falsey
             end
         end
 
         context 'when none of the given platforms are exempt' do
             before do
-                described_class.stub(:info) { { exempt_platforms: [:windows] } }
+                allow(described_class).to receive(:info) { { exempt_platforms: [:windows] } }
             end
 
             it 'returns true' do
-                described_class.supports_platforms?([:unix]).should be_true
+                expect(described_class.supports_platforms?([:unix])).to be_truthy
             end
         end
 
         context 'when any of the given platforms are exempt' do
             before do
-                described_class.stub(:info) { { exempt_platforms: [:windows, :linux] } }
+                allow(described_class).to receive(:info) { { exempt_platforms: [:windows, :linux] } }
             end
 
             it 'returns false' do
-                described_class.supports_platforms?([:unix]).should be_false
+                expect(described_class.supports_platforms?([:unix])).to be_falsey
             end
         end
 
         context 'when a platforms of different type is exempt' do
             before do
-                described_class.stub(:info) { { exempt_platforms: [:windows] } }
+                allow(described_class).to receive(:info) { { exempt_platforms: [:windows] } }
             end
 
             it 'returns true' do
-                described_class.supports_platforms?([:ruby]).should be_true
+                expect(described_class.supports_platforms?([:ruby])).to be_truthy
             end
         end
 

data/spec/arachni/check/manager_spec.rb

@@ -20,8 +20,8 @@ describe Arachni::Check::Manager do
     describe '#load' do
         it 'loads all checks' do
             all = checks.load_all
-            all.size.should equal 3
-            all.sort.should == checks.keys.sort
+            expect(all.size).to equal 3
+            expect(all.sort).to eq(checks.keys.sort)
         end
     end
 
@@ -35,7 +35,7 @@ describe Arachni::Check::Manager do
                 checks = Arachni::Framework.new.checks
 
                 expect { checks[:with_invalid_platforms] }.to raise_error described_class::Error::InvalidPlatforms
-                checks.include?(:with_invalid_platforms).should be_false
+                expect(checks.include?(:with_invalid_platforms)).to be_falsey
             end
         end
     end
@@ -46,36 +46,36 @@ describe Arachni::Check::Manager do
             checks.load :test2
             checks.load :test3
             checks.load :test
-            checks.schedule.should == [checks[:test], checks[:test2], checks[:test3]]
+            expect(checks.schedule).to eq([checks[:test], checks[:test2], checks[:test3]])
 
             checks.clear
 
             checks.load :test2
-            checks.schedule.should == [checks[:test2]]
+            expect(checks.schedule).to eq([checks[:test2]])
 
             checks.clear
 
             checks.load :test
-            checks.schedule.should == [checks[:test]]
+            expect(checks.schedule).to eq([checks[:test]])
 
             checks.clear
 
             checks.load :test, :test3
-            checks.schedule.should == [checks[:test], checks[:test3]]
+            expect(checks.schedule).to eq([checks[:test], checks[:test3]])
         end
     end
 
     describe '#with_platforms' do
         it 'returns checks which target specific platforms' do
             checks.load_all
-            checks.with_platforms.keys.should == ['test2']
+            expect(checks.with_platforms.keys).to eq(['test2'])
         end
     end
 
     describe '#without_platforms' do
         it 'returns checks which do not target specific platforms' do
             checks.load_all
-            checks.without_platforms.keys.sort.should == %w(test test3).sort
+            expect(checks.without_platforms.keys.sort).to eq(%w(test test3).sort)
         end
     end
 
@@ -83,8 +83,8 @@ describe Arachni::Check::Manager do
         it 'runs all checks' do
             checks.load_all
             checks.run( page )
-            issues.size.should equal 1
-            issues.first.name.should == checks['test'].info[:issue][:name]
+            expect(issues.size).to equal 1
+            expect(issues.first.name).to eq(checks['test'].info[:issue][:name])
         end
     end
 
@@ -92,14 +92,14 @@ describe Arachni::Check::Manager do
         it 'runs a single check' do
             checks.load :test
             checks.run_one( checks.values.first, page )
-            issues.size.should equal 1
-            issues.first.name.should == checks['test'].info[:issue][:name]
+            expect(issues.size).to equal 1
+            expect(issues.first.name).to eq(checks['test'].info[:issue][:name])
         end
 
         context 'when the check was ran' do
             it 'returns true' do
                 checks.load :test
-                checks.run_one( checks.values.first, page ).should be_true
+                expect(checks.run_one( checks.values.first, page )).to be_truthy
             end
         end
 
@@ -109,7 +109,7 @@ describe Arachni::Check::Manager do
 
                 allow(Arachni::Checks::Test).to receive(:check?).and_return(false)
 
-                checks.run_one( checks.values.first, page ).should be_false
+                expect(checks.run_one( checks.values.first, page )).to be_falsey
             end
         end
     end

data/spec/arachni/component/base_spec.rb

@@ -18,46 +18,46 @@ describe Arachni::Component::Base do
     let(:info) { Subject.info }
 
     it "includes #{Arachni::Component::Output}" do
-        subject.should include Arachni::Component::Output
+        expect(subject).to include Arachni::Component::Output
     end
 
     it "includes #{Arachni::Component::Utilities}" do
-        subject.should include Arachni::Component::Utilities
+        expect(subject).to include Arachni::Component::Utilities
     end
 
     describe '.shortname=' do
         it 'sets the .shortname' do
             subject.shortname = :blah
-            subject.shortname.should == :blah
+            expect(subject.shortname).to eq(:blah)
         end
 
         it 'sets the #shortname' do
             subject.shortname = :blah
-            subject.new.shortname.should == :blah
+            expect(subject.new.shortname).to eq(:blah)
         end
     end
 
     describe '.fullname' do
         it 'returns the name' do
-            subject.fullname.should == info[:name]
+            expect(subject.fullname).to eq(info[:name])
         end
     end
 
     describe '.description' do
         it 'returns the description' do
-            subject.description.should == info[:description]
+            expect(subject.description).to eq(info[:description])
         end
     end
 
     describe '.author' do
         it 'returns the author' do
-            subject.author.should == info[:author]
+            expect(subject.author).to eq(info[:author])
         end
     end
 
     describe '.version' do
         it 'returns the version' do
-            subject.version.should == info[:version]
+            expect(subject.version).to eq(info[:version])
         end
     end
 

data/spec/arachni/component/manager_spec.rb

@@ -12,26 +12,26 @@ describe Arachni::Component::Manager do
 
     describe '#lib' do
         it 'returns the component library' do
-            @components.lib.should == @lib
+            expect(@components.lib).to eq(@lib)
         end
     end
 
     describe '#namespace' do
         it 'returns the namespace under which all components are defined' do
-            @components.namespace.should == @namespace
+            expect(@components.namespace).to eq(@namespace)
         end
     end
 
     describe '#available' do
         it 'returns all available components' do
-            @components.available.sort.should == available
+            expect(@components.available.sort).to eq(available)
         end
     end
 
     describe '#load_all' do
         it 'loads all components' do
             @components.load_all
-            @components.loaded.sort.should == @components.available.sort
+            expect(@components.loaded.sort).to eq(@components.available.sort)
         end
     end
 
@@ -41,21 +41,21 @@ describe Arachni::Component::Manager do
             context String do
                 it 'loads the component by name' do
                     @components.load( 'wait' )
-                    @components.loaded.should == %w(wait)
+                    expect(@components.loaded).to eq(%w(wait))
                 end
             end
 
             context Symbol do
                 it 'loads the component by name' do
                     @components.load( :wait )
-                    @components.loaded.should == %w(wait)
+                    expect(@components.loaded).to eq(%w(wait))
                 end
             end
 
             context Array do
                 it 'loads the components by name' do
                     @components.load( %w(bad distributable) )
-                    @components.loaded.sort.should == %w(bad distributable).sort
+                    expect(@components.loaded.sort).to eq(%w(bad distributable).sort)
                 end
             end
 
@@ -63,21 +63,21 @@ describe Arachni::Component::Manager do
                 context String do
                     it 'loads components by name' do
                         @components.load( 'wait', 'bad' )
-                        @components.loaded.sort.should == %w(bad wait).sort
+                        expect(@components.loaded.sort).to eq(%w(bad wait).sort)
                     end
                 end
 
                 context Symbol do
                     it 'loads components by name' do
                         @components.load :wait, :distributable
-                        @components.loaded.sort.should == %w(wait distributable).sort
+                        expect(@components.loaded.sort).to eq(%w(wait distributable).sort)
                     end
                 end
 
                 context Array do
                     it 'loads components by name' do
                         @components.load( :wait, %w(bad distributable) )
-                        @components.loaded.sort.should == %w(bad distributable wait).sort
+                        expect(@components.loaded.sort).to eq(%w(bad distributable wait).sort)
                     end
                 end
             end
@@ -86,14 +86,14 @@ describe Arachni::Component::Manager do
                 context 'alone' do
                     it 'loads all components' do
                         @components.load( '*' )
-                        @components.loaded.sort.should == @components.available.sort
+                        expect(@components.loaded.sort).to eq(@components.available.sort)
                     end
                 end
 
                 context 'with a category name' do
                     it 'loads all of its components' do
                         @components.load( 'plugins/*' )
-                        @components.loaded.sort.should == @components.available.sort
+                        expect(@components.loaded.sort).to eq(@components.available.sort)
                     end
                 end
 
@@ -103,7 +103,7 @@ describe Arachni::Component::Manager do
                 context 'alone' do
                     it 'loads nothing' do
                         @components.load( '-' )
-                        @components.loaded.sort.should be_empty
+                        expect(@components.loaded.sort).to be_empty
                     end
                 end
                 context 'with a name' do
@@ -111,7 +111,7 @@ describe Arachni::Component::Manager do
                         @components.load( %w(* -wait) )
                         loaded = @components.available
                         loaded.delete( 'wait' )
-                        @components.loaded.sort.should == loaded.sort
+                        expect(@components.loaded.sort).to eq(loaded.sort)
                     end
                 end
                 context 'with a partial name and a wildcard' do
@@ -120,7 +120,7 @@ describe Arachni::Component::Manager do
                         loaded = @components.available
                         loaded.delete( 'wait' )
                         loaded.delete( 'distributable' )
-                        @components.loaded.sort.should == loaded.sort
+                        expect(@components.loaded.sort).to eq(loaded.sort)
                     end
                 end
             end
@@ -141,79 +141,79 @@ describe Arachni::Component::Manager do
         context 'when passed' do
             context 'nil' do
                 it 'returns an empty array' do
-                    @components.empty?.should be_true
-                    @components.load_by_tags( nil ).should == []
+                    expect(@components.empty?).to be_truthy
+                    expect(@components.load_by_tags( nil )).to eq([])
                 end
             end
 
             context '[]' do
                 it 'returns an empty array' do
-                    @components.empty?.should be_true
-                    @components.load_by_tags( [] ).should == []
+                    expect(@components.empty?).to be_truthy
+                    expect(@components.load_by_tags( [] )).to eq([])
                 end
             end
 
             context String do
                 it 'loads components whose tags include the given tag (as either a String or a Symbol)' do
-                    @components.empty?.should be_true
+                    expect(@components.empty?).to be_truthy
 
-                    @components.load_by_tags( 'wait_string' ).should == %w(wait)
+                    expect(@components.load_by_tags( 'wait_string' )).to eq(%w(wait))
                     @components.delete( 'wait' )
-                    @components.empty?.should be_true
+                    expect(@components.empty?).to be_truthy
 
-                    @components.load_by_tags( 'wait_sym' ).should == %w(wait)
+                    expect(@components.load_by_tags( 'wait_sym' )).to eq(%w(wait))
                     @components.delete( 'wait' )
-                    @components.empty?.should be_true
+                    expect(@components.empty?).to be_truthy
 
-                    @components.load_by_tags( 'distributable_string' ).should == %w(distributable)
+                    expect(@components.load_by_tags( 'distributable_string' )).to eq(%w(distributable))
                     @components.delete( 'distributable' )
-                    @components.empty?.should be_true
+                    expect(@components.empty?).to be_truthy
 
-                    @components.load_by_tags( 'distributable_sym' ).should == %w(distributable)
+                    expect(@components.load_by_tags( 'distributable_sym' )).to eq(%w(distributable))
                     @components.delete( 'distributable' )
-                    @components.empty?.should be_true
+                    expect(@components.empty?).to be_truthy
 
                 end
             end
 
             context Symbol do
                 it 'loads components whose tags include the given tag (as either a String or a Symbol)' do
-                    @components.empty?.should be_true
+                    expect(@components.empty?).to be_truthy
 
-                    @components.load_by_tags( :wait_string ).should == %w(wait)
+                    expect(@components.load_by_tags( :wait_string )).to eq(%w(wait))
                     @components.delete( 'wait' )
-                    @components.empty?.should be_true
+                    expect(@components.empty?).to be_truthy
 
-                    @components.load_by_tags( :wait_sym ).should == %w(wait)
+                    expect(@components.load_by_tags( :wait_sym )).to eq(%w(wait))
                     @components.delete( 'wait' )
-                    @components.empty?.should be_true
+                    expect(@components.empty?).to be_truthy
 
-                    @components.load_by_tags( :distributable_string ).should == %w(distributable)
+                    expect(@components.load_by_tags( :distributable_string )).to eq(%w(distributable))
                     @components.delete( 'distributable' )
-                    @components.empty?.should be_true
+                    expect(@components.empty?).to be_truthy
 
-                    @components.load_by_tags( :distributable_sym ).should == %w(distributable)
+                    expect(@components.load_by_tags( :distributable_sym )).to eq(%w(distributable))
                     @components.delete( 'distributable' )
-                    @components.empty?.should be_true
+                    expect(@components.empty?).to be_truthy
                 end
             end
 
             context Array do
                 it 'loads components which include any of the given tags (as either Strings or a Symbols)' do
-                    @components.empty?.should be_true
+                    expect(@components.empty?).to be_truthy
 
                     expected = %w(wait distributable).sort
-                    @components.load_by_tags( [ :wait_string, 'distributable_string' ] ).sort.should == expected
+                    expect(@components.load_by_tags( [ :wait_string, 'distributable_string' ] ).sort).to eq(expected)
                     @components.clear
-                    @components.empty?.should be_true
+                    expect(@components.empty?).to be_truthy
 
-                    @components.load_by_tags( [ 'wait_string', :distributable_string ] ).sort.should == expected
+                    expect(@components.load_by_tags( [ 'wait_string', :distributable_string ] ).sort).to eq(expected)
                     @components.clear
-                    @components.empty?.should be_true
+                    expect(@components.empty?).to be_truthy
 
-                    @components.load_by_tags( [ 'wait_sym', :distributable_sym ] ).sort.should == expected
+                    expect(@components.load_by_tags( [ 'wait_sym', :distributable_sym ] ).sort).to eq(expected)
                     @components.clear
-                    @components.empty?.should be_true
+                    expect(@components.empty?).to be_truthy
                 end
 
             end
@@ -225,33 +225,34 @@ describe Arachni::Component::Manager do
 
             context String do
                 it 'returns an array including the component\'s name' do
-                    @components.parse( 'wait' ).should == %w(wait)
+                    expect(@components.parse( 'wait' )).to eq(%w(wait))
                 end
             end
 
             context Symbol do
                 it 'returns an array including the component\'s name' do
-                    @components.parse( :wait ).should == %w(wait)
+                    expect(@components.parse( :wait )).to eq(%w(wait))
                 end
             end
 
             context Array do
                 it 'loads the component by name' do
-                    @components.parse( %w(bad distributable) ).sort.should ==
+                    expect(@components.parse( %w(bad distributable) ).sort).to eq(
                         %w(bad distributable).sort
+                    )
                 end
             end
 
             context 'wildcard (*)' do
                 context 'alone' do
                     it 'returns all components' do
-                        @components.parse( '*' ).sort.should == @components.available.sort
+                        expect(@components.parse( '*' ).sort).to eq(@components.available.sort)
                     end
                 end
 
                 context 'with a category name' do
                     it 'returns all of its components' do
-                        @components.parse( 'plugins/*' ).sort.should == @components.available.sort
+                        expect(@components.parse( 'plugins/*' ).sort).to eq(@components.available.sort)
                     end
                 end
 
@@ -260,7 +261,7 @@ describe Arachni::Component::Manager do
             context 'exclusion filter (-)' do
                 context 'alone' do
                     it 'returns nothing' do
-                        @components.parse( '-' ).sort.should be_empty
+                        expect(@components.parse( '-' ).sort).to be_empty
                     end
                 end
                 context 'with a name' do
@@ -268,7 +269,7 @@ describe Arachni::Component::Manager do
                         @components.parse( %w(* -wait) )
                         loaded = @components.available
                         loaded.delete( 'wait' )
-                        loaded.sort.should == loaded.sort
+                        expect(loaded.sort).to eq(loaded.sort)
                     end
                 end
                 context 'with a partial name and a wildcard' do
@@ -277,7 +278,7 @@ describe Arachni::Component::Manager do
                         loaded = @components.available
                         loaded.delete( 'wait' )
                         loaded.delete( 'distributable' )
-                        parsed.sort.should == loaded.sort
+                        expect(parsed.sort).to eq(loaded.sort)
                     end
                 end
             end
@@ -289,19 +290,19 @@ describe Arachni::Component::Manager do
             c = 'with_options'
 
             @components.load( c )
-            @components.prepare_options( c, @components[c],
+            expect(@components.prepare_options( c, @components[c],
                 { 'req_opt' => 'my value' }
-            ).should == {
+            )).to eq({
                 req_opt:     'my value',
                 default_opt: 'value'
-            }
+            })
 
             opts = {
                 'req_opt'     => 'req_opt value',
                 'opt_opt'     => 'opt_opt value',
                 'default_opt' => 'value2'
             }
-            @components.prepare_options( c, @components[c], opts ).should == opts.my_symbolize_keys
+            expect(@components.prepare_options( c, @components[c], opts )).to eq(opts.my_symbolize_keys)
         end
 
         context 'with missing options' do
@@ -347,16 +348,16 @@ describe Arachni::Component::Manager do
         context 'when passed a' do
             context String do
                 it 'should load and return the component' do
-                    @components.loaded.should be_empty
-                    @components['wait'].name.should == 'Arachni::Plugins::Wait'
-                    @components.loaded.should == %w(wait)
+                    expect(@components.loaded).to be_empty
+                    expect(@components['wait'].name).to eq('Arachni::Plugins::Wait')
+                    expect(@components.loaded).to eq(%w(wait))
                 end
             end
             context Symbol do
                 it 'should load and return the component' do
-                    @components.loaded.should be_empty
-                    @components[:wait].name.should == 'Arachni::Plugins::Wait'
-                    @components.loaded.should == %w(wait)
+                    expect(@components.loaded).to be_empty
+                    expect(@components[:wait].name).to eq('Arachni::Plugins::Wait')
+                    expect(@components.loaded).to eq(%w(wait))
                 end
             end
         end
@@ -367,36 +368,36 @@ describe Arachni::Component::Manager do
             context String do
                 context 'when the component has been loaded' do
                     it 'returns true' do
-                        @components.loaded.should be_empty
-                        @components['wait'].name.should == 'Arachni::Plugins::Wait'
-                        @components.loaded.should == %w(wait)
-                        @components.loaded?( 'wait' ).should be_true
-                        @components.include?( 'wait' ).should be_true
+                        expect(@components.loaded).to be_empty
+                        expect(@components['wait'].name).to eq('Arachni::Plugins::Wait')
+                        expect(@components.loaded).to eq(%w(wait))
+                        expect(@components.loaded?( 'wait' )).to be_truthy
+                        expect(@components.include?( 'wait' )).to be_truthy
                     end
                 end
                 context 'when the component has not been loaded' do
                     it 'returns false' do
-                        @components.loaded.should be_empty
-                        @components.loaded?( 'wait' ).should be_false
-                        @components.include?( 'wait' ).should be_false
+                        expect(@components.loaded).to be_empty
+                        expect(@components.loaded?( 'wait' )).to be_falsey
+                        expect(@components.include?( 'wait' )).to be_falsey
                     end
                 end
             end
             context Symbol do
                 context 'when the component has been loaded' do
                     it 'returns true' do
-                        @components.loaded.should be_empty
-                        @components[:wait].name.should == 'Arachni::Plugins::Wait'
-                        @components.loaded.should == %w(wait)
-                        @components.loaded?( :wait ).should be_true
-                        @components.include?( :wait ).should be_true
+                        expect(@components.loaded).to be_empty
+                        expect(@components[:wait].name).to eq('Arachni::Plugins::Wait')
+                        expect(@components.loaded).to eq(%w(wait))
+                        expect(@components.loaded?( :wait )).to be_truthy
+                        expect(@components.include?( :wait )).to be_truthy
                     end
                 end
                 context 'when the component has not been loaded' do
                     it 'returns false' do
-                        @components.loaded.should be_empty
-                        @components.loaded?( :wait ).should be_false
-                        @components.include?( :wait ).should be_false
+                        expect(@components.loaded).to be_empty
+                        expect(@components.loaded?( :wait )).to be_falsey
+                        expect(@components.include?( :wait )).to be_falsey
                     end
                 end
             end
@@ -405,86 +406,86 @@ describe Arachni::Component::Manager do
 
     describe '#delete' do
         it 'removes a component' do
-            @components.loaded.should be_empty
+            expect(@components.loaded).to be_empty
 
             @components.load( 'wait' )
             klass = @components['wait']
 
             sym = klass.name.split( ':' ).last.to_sym
-            @components.namespace.constants.include?( sym ).should be_true
-            @components.loaded.should be_any
+            expect(@components.namespace.constants.include?( sym )).to be_truthy
+            expect(@components.loaded).to be_any
 
             @components.delete( 'wait' )
-            @components.loaded.should be_empty
+            expect(@components.loaded).to be_empty
 
             sym = klass.name.split( ':' ).last.to_sym
-            @components.namespace.constants.include?( sym ).should be_false
+            expect(@components.namespace.constants.include?( sym )).to be_falsey
         end
         it 'unloads a component' do
-            @components.loaded.should be_empty
+            expect(@components.loaded).to be_empty
 
             @components.load( 'wait' )
             klass = @components['wait']
 
             sym = klass.name.split( ':' ).last.to_sym
-            @components.namespace.constants.include?( sym ).should be_true
-            @components.loaded.should be_any
+            expect(@components.namespace.constants.include?( sym )).to be_truthy
+            expect(@components.loaded).to be_any
 
             @components.delete( 'wait' )
-            @components.loaded.should be_empty
+            expect(@components.loaded).to be_empty
 
             sym = klass.name.split( ':' ).last.to_sym
-            @components.namespace.constants.include?( sym ).should be_false
+            expect(@components.namespace.constants.include?( sym )).to be_falsey
         end
     end
 
     describe '#loaded' do
         it 'returns all loaded components' do
             @components.load( '*' )
-            @components.loaded.sort.should == available
+            expect(@components.loaded.sort).to eq(available)
         end
     end
 
     describe '#name_to_path' do
         it 'returns a component\'s path from its name' do
             path = @components.name_to_path( 'wait' )
-            File.exists?( path ).should be_true
-            File.basename( path ).should == 'wait.rb'
+            expect(File.exists?( path )).to be_truthy
+            expect(File.basename( path )).to eq('wait.rb')
         end
     end
 
     describe '#path_to_name' do
         it 'returns a component\'s name from its path' do
             path = @components.name_to_path( 'wait' )
-            @components.path_to_name( path ).should == 'wait'
+            expect(@components.path_to_name( path )).to eq('wait')
         end
     end
 
     describe '#paths' do
         it 'returns all component paths' do
             paths = @components.paths
-            paths.each { |p| File.exists?( p ).should be_true }
-            paths.size.should == @components.available.size
+            paths.each { |p| expect(File.exists?( p )).to be_truthy }
+            expect(paths.size).to eq(@components.available.size)
         end
     end
 
     describe '#clear' do
         it 'unloads all components' do
-            @components.loaded.should be_empty
+            expect(@components.loaded).to be_empty
             @components.load( '*' )
-            @components.loaded.sort.should == @components.available.sort
+            expect(@components.loaded.sort).to eq(@components.available.sort)
 
             symbols = @components.values.map do |klass|
                 sym = klass.name.split( ':' ).last.to_sym
-                @components.namespace.constants.include?( sym ).should be_true
+                expect(@components.namespace.constants.include?( sym )).to be_truthy
                 sym
             end
 
             @components.clear
             symbols.each do |sym|
-                @components.namespace.constants.include?( sym ).should be_false
+                expect(@components.namespace.constants.include?( sym )).to be_falsey
             end
-            @components.loaded.should be_empty
+            expect(@components.loaded).to be_empty
         end
     end
 end