arachni 1.2.1 → 1.3

data/spec/arachni/option_groups/rpc_spec.rb

@@ -7,7 +7,7 @@ describe Arachni::OptionGroups::RPC do
     %w(server_socket server_address server_port ssl_ca server_ssl_private_key
         server_ssl_certificate client_ssl_private_key client_ssl_certificate
         client_max_retries).each do |method|
-        it { should respond_to method }
-        it { should respond_to "#{method}=" }
+        it { is_expected.to respond_to method }
+        it { is_expected.to respond_to "#{method}=" }
     end
 end

data/spec/arachni/option_groups/scope_spec.rb

@@ -9,8 +9,8 @@ describe Arachni::OptionGroups::Scope do
         exclude_path_patterns exclude_content_patterns include_subdomains https_only
         url_rewrites exclude_binaries
     ).each do |method|
-        it { should respond_to method }
-        it { should respond_to "#{method}=" }
+        it { is_expected.to respond_to method }
+        it { is_expected.to respond_to "#{method}=" }
     end
 
     describe '#url_rewrites' do
@@ -19,9 +19,9 @@ describe Arachni::OptionGroups::Scope do
                 '/article/(\d+)' => 'articles?id=\1'
             }
 
-            subject.url_rewrites.to_s.should == {
+            expect(subject.url_rewrites.to_s).to eq({
                 /\/article\/(\d+)/ => 'articles?id=\1'
-            }.to_s
+            }.to_s)
         end
     end
 
@@ -29,18 +29,18 @@ describe Arachni::OptionGroups::Scope do
         describe 'when #https_only has been enabled' do
             it 'returns true' do
                 subject.https_only = true
-                subject.https_only?.should be_true
+                expect(subject.https_only?).to be_truthy
             end
         end
         describe 'when #https_only has been disabled' do
             it 'returns false' do
                 subject.https_only = false
-                subject.https_only?.should be_false
+                expect(subject.https_only?).to be_falsey
             end
         end
         describe 'by default' do
             it 'returns false' do
-                subject.https_only?.should be_false
+                expect(subject.https_only?).to be_falsey
             end
         end
     end
@@ -49,18 +49,18 @@ describe Arachni::OptionGroups::Scope do
         describe 'when #auto_redundant_paths has been enabled' do
             it 'returns true' do
                 subject.auto_redundant_paths = 10
-                subject.auto_redundant?.should be_true
+                expect(subject.auto_redundant?).to be_truthy
             end
         end
         describe 'when #auto_redundant_paths has been disabled' do
             it 'returns false' do
                 subject.auto_redundant_paths = nil
-                subject.auto_redundant?.should be_false
+                expect(subject.auto_redundant?).to be_falsey
             end
         end
         describe 'by default' do
             it 'returns false' do
-                subject.auto_redundant?.should be_false
+                expect(subject.auto_redundant?).to be_falsey
             end
         end
     end
@@ -68,47 +68,47 @@ describe Arachni::OptionGroups::Scope do
     describe '#redundant_path_patterns=' do
         it 'converts its param to properly typed filters' do
             subject.redundant_path_patterns = { /pattern/ => '45', 'regexp' => 39 }
-            subject.redundant_path_patterns.should == {
+            expect(subject.redundant_path_patterns).to eq({
                 /pattern/ => 45,
                 /regexp/  => 39
-            }
+            })
         end
     end
 
     describe '#do_not_crawl' do
         it 'sets the page_limit to 0' do
             subject.do_not_crawl
-            subject.page_limit.should == 0
+            expect(subject.page_limit).to eq(0)
         end
     end
 
     describe '#crawl' do
         it 'sets the page_limit to < 0' do
             subject.crawl
-            subject.crawl?.should be_true
-            !subject.page_limit.should be_nil
+            expect(subject.crawl?).to be_truthy
+            !expect(subject.page_limit).to be_nil
         end
     end
 
     describe '#crawl?' do
         context 'by default' do
             it 'returns true' do
-                subject.crawl?.should be_true
+                expect(subject.crawl?).to be_truthy
             end
         end
         context 'when crawling is enabled' do
             it 'returns true' do
                 subject.do_not_crawl
-                subject.crawl?.should be_false
+                expect(subject.crawl?).to be_falsey
                 subject.crawl
-                subject.crawl?.should be_true
+                expect(subject.crawl?).to be_truthy
             end
         end
         context 'when crawling is disabled' do
             it 'returns false' do
-                subject.crawl?.should be_true
+                expect(subject.crawl?).to be_truthy
                 subject.do_not_crawl
-                subject.crawl?.should be_false
+                expect(subject.crawl?).to be_falsey
             end
         end
     end
@@ -117,22 +117,22 @@ describe Arachni::OptionGroups::Scope do
         context 'when #page_limit has' do
             context 'not been set' do
                 it 'returns false' do
-                    subject.page_limit_reached?( 44 ).should be_false
+                    expect(subject.page_limit_reached?( 44 )).to be_falsey
                 end
             end
 
             context 'not been reached' do
                 it 'returns false' do
                     subject.page_limit = 5
-                    subject.page_limit_reached?( 2 ).should be_false
+                    expect(subject.page_limit_reached?( 2 )).to be_falsey
                 end
             end
 
             context 'been reached' do
                 it 'returns true' do
                     subject.page_limit = 5
-                    subject.page_limit_reached?( 5 ).should be_true
-                    subject.page_limit_reached?( 6 ).should be_true
+                    expect(subject.page_limit_reached?( 5 )).to be_truthy
+                    expect(subject.page_limit_reached?( 6 )).to be_truthy
                 end
             end
         end
@@ -143,10 +143,10 @@ describe Arachni::OptionGroups::Scope do
             restrict_paths = %w(my_restrict_paths my_other_restrict_paths)
 
             subject.restrict_paths = restrict_paths.first
-            subject.restrict_paths.should == [restrict_paths.first]
+            expect(subject.restrict_paths).to eq([restrict_paths.first])
 
             subject.restrict_paths = restrict_paths
-            subject.restrict_paths.should == restrict_paths
+            expect(subject.restrict_paths).to eq(restrict_paths)
         end
     end
 
@@ -155,10 +155,10 @@ describe Arachni::OptionGroups::Scope do
             extend_paths = %w(my_extend_paths my_other_extend_paths)
 
             subject.extend_paths = extend_paths.first
-            subject.extend_paths.should == [extend_paths.first]
+            expect(subject.extend_paths).to eq([extend_paths.first])
 
             subject.extend_paths = extend_paths
-            subject.extend_paths.should == extend_paths
+            expect(subject.extend_paths).to eq(extend_paths)
         end
     end
 
@@ -167,13 +167,13 @@ describe Arachni::OptionGroups::Scope do
             include = %w(my_include my_other_include)
 
             subject.include_path_patterns = /test/
-            subject.include_path_patterns.should == [/test/]
+            expect(subject.include_path_patterns).to eq([/test/])
 
             subject.include_path_patterns = include.first
-            subject.include_path_patterns.should == [Regexp.new( include.first )]
+            expect(subject.include_path_patterns).to eq([Regexp.new( include.first )])
 
             subject.include_path_patterns = include
-            subject.include_path_patterns.should == include.map { |p| Regexp.new( p ) }
+            expect(subject.include_path_patterns).to eq(include.map { |p| Regexp.new( p ) })
         end
     end
 
@@ -182,13 +182,13 @@ describe Arachni::OptionGroups::Scope do
             exclude = %w(my_exclude my_other_exclude)
 
             subject.exclude_path_patterns= /test/
-            subject.exclude_path_patterns.should == [/test/]
+            expect(subject.exclude_path_patterns).to eq([/test/])
 
             subject.exclude_path_patterns= exclude.first
-            subject.exclude_path_patterns.should == [Regexp.new( exclude.first )]
+            expect(subject.exclude_path_patterns).to eq([Regexp.new( exclude.first )])
 
             subject.exclude_path_patterns= exclude
-            subject.exclude_path_patterns.should == exclude.map { |p| Regexp.new( p ) }
+            expect(subject.exclude_path_patterns).to eq(exclude.map { |p| Regexp.new( p ) })
         end
     end
 
@@ -197,13 +197,13 @@ describe Arachni::OptionGroups::Scope do
             exclude_pages = %w(my_ignore my_other_ignore)
 
             subject.exclude_content_patterns = /test/
-            subject.exclude_content_patterns.should == [/test/]
+            expect(subject.exclude_content_patterns).to eq([/test/])
 
             subject.exclude_content_patterns = exclude_pages.first
-            subject.exclude_content_patterns.should == [Regexp.new( exclude_pages.first )]
+            expect(subject.exclude_content_patterns).to eq([Regexp.new( exclude_pages.first )])
 
             subject.exclude_content_patterns = exclude_pages
-            subject.exclude_content_patterns.should == exclude_pages.map { |p| Regexp.new( p ) }
+            expect(subject.exclude_content_patterns).to eq(exclude_pages.map { |p| Regexp.new( p ) })
         end
     end
 
@@ -214,14 +214,14 @@ describe Arachni::OptionGroups::Scope do
             values = { /redundant_path_patterns/ => 1 }
             subject.redundant_path_patterns = values
 
-            data['redundant_path_patterns'].should == values.my_stringify
+            expect(data['redundant_path_patterns']).to eq(values.my_stringify)
         end
 
         it "converts 'url_rewrites' to strings" do
             values = { /url_rewrites/ => 'test' }
             subject.url_rewrites = values
 
-            data['url_rewrites'].should == values.my_stringify
+            expect(data['url_rewrites']).to eq(values.my_stringify)
         end
 
         %w(exclude_path_patterns exclude_content_patterns include_path_patterns).each do |k|
@@ -229,7 +229,7 @@ describe Arachni::OptionGroups::Scope do
                 values = [/#{k}/]
                 subject.send( "#{k}=", values )
 
-                data[k].should == [/#{k}/.to_s]
+                expect(data[k]).to eq([/#{k}/.to_s])
             end
         end
     end

data/spec/arachni/option_groups/session_spec.rb

@@ -12,14 +12,14 @@ describe Arachni::OptionGroups::Session do
     end
 
     %w(check_url check_pattern).each do |method|
-        it { should respond_to method }
-        it { should respond_to "#{method}=" }
+        it { is_expected.to respond_to method }
+        it { is_expected.to respond_to "#{method}=" }
     end
 
     describe '#validate' do
         context 'when valid' do
             it 'returns nil' do
-                valid.validate.should be_empty
+                expect(valid.validate).to be_empty
             end
         end
 
@@ -30,8 +30,9 @@ describe Arachni::OptionGroups::Session do
                         context attribute do
                             it 'returns errors' do
                                 valid.send( "#{attribute}=", nil )
-                                valid.validate.should ==
+                                expect(valid.validate).to eq(
                                     { attribute.to_sym => 'Option is missing.'}
+                                )
                             end
                         end
                     end
@@ -45,7 +46,7 @@ describe Arachni::OptionGroups::Session do
 
         it "converts 'check_pattern' to strings" do
             subject.check_pattern = /test/
-            data['check_pattern'].should == subject.check_pattern.to_s
+            expect(data['check_pattern']).to eq(subject.check_pattern.to_s)
         end
     end
 end

data/spec/arachni/option_groups/snapshot_spec.rb

@@ -5,14 +5,14 @@ describe Arachni::OptionGroups::Snapshot do
     subject { described_class.new }
 
     %w(save_path).each do |method|
-        it { should respond_to method }
-        it { should respond_to "#{method}=" }
+        it { is_expected.to respond_to method }
+        it { is_expected.to respond_to "#{method}=" }
     end
 
     describe '.save_path' do
         context "when #{Arachni::OptionGroups::Paths}.config['framework']['snapshots']" do
             it 'returns it' do
-                Arachni::OptionGroups::Paths.stub(:config) do
+                allow(Arachni::OptionGroups::Paths).to receive(:config) do
                     {
                         'framework' => {
                             'snapshots' => 'stuff/'
@@ -20,7 +20,7 @@ describe Arachni::OptionGroups::Snapshot do
                     }
                 end
 
-                subject.save_path.should == 'stuff/'
+                expect(subject.save_path).to eq('stuff/')
             end
         end
     end

data/spec/arachni/options_spec.rb

@@ -11,52 +11,53 @@ describe Arachni::Options do
 
     it 'proxies missing class methods to instance methods' do
         url = 'http://test.com/'
-        subject.url.should_not == url
+        expect(subject.url).not_to eq(url)
         subject.url = url
-        subject.url.should == url
+        expect(subject.url).to eq(url)
     end
 
     %w(checks platforms plugins authorized_by no_fingerprinting spawns).each do |method|
-        it { should respond_to method }
-        it { should respond_to "#{method}=" }
+        it { is_expected.to respond_to method }
+        it { is_expected.to respond_to "#{method}=" }
     end
 
     groups.each do |group|
         describe "##{group}" do
             it 'is an OptionGroup' do
-                subject.send( group ).should be_kind_of Arachni::OptionGroup
-                subject.send( group ).class.to_s.downcase.should ==
+                expect(subject.send( group )).to be_kind_of Arachni::OptionGroup
+                expect(subject.send( group ).class.to_s.downcase).to eq(
                     "arachni::optiongroups::#{group}"
+                )
             end
         end
     end
 
     describe '#spawns' do
         it 'defaults to 0' do
-            subject.spawns.should == 0
+            expect(subject.spawns).to eq(0)
         end
 
         it 'converts its argument to Integer' do
             subject.spawns = '5'
-            subject.spawns.should == 5
+            expect(subject.spawns).to eq(5)
         end
     end
 
     describe '#do_not_fingerprint' do
         it 'disables fingerprinting' do
-            subject.no_fingerprinting.should be_false
+            expect(subject.no_fingerprinting).to be_falsey
             subject.do_not_fingerprint
-            subject.no_fingerprinting.should be_true
+            expect(subject.no_fingerprinting).to be_truthy
         end
     end
 
     describe '#fingerprint' do
         it 'enables fingerprinting' do
             subject.do_not_fingerprint
-            subject.no_fingerprinting.should be_true
+            expect(subject.no_fingerprinting).to be_truthy
 
             subject.fingerprint
-            subject.no_fingerprinting.should be_false
+            expect(subject.no_fingerprinting).to be_falsey
         end
     end
 
@@ -64,14 +65,14 @@ describe Arachni::Options do
         context 'when fingerprinting is enabled' do
             it 'returns true' do
                 subject.no_fingerprinting = false
-                subject.fingerprint?.should be_true
+                expect(subject.fingerprint?).to be_truthy
             end
         end
 
         context 'when fingerprinting is disabled' do
             it 'returns false' do
                 subject.no_fingerprinting = true
-                subject.fingerprint?.should be_false
+                expect(subject.fingerprint?).to be_falsey
             end
         end
     end
@@ -79,18 +80,18 @@ describe Arachni::Options do
     describe '#validate' do
         context 'when valid' do
             it 'returns nil' do
-                subject.validate.should be_empty
+                expect(subject.validate).to be_empty
             end
         end
 
         context 'when invalid' do
             it 'returns errors by group' do
                 subject.session.check_pattern = /test/
-                subject.validate.should == {
+                expect(subject.validate).to eq({
                     session: {
                         check_url: "Option is missing."
                     }
-                }
+                })
             end
         end
     end
@@ -98,17 +99,17 @@ describe Arachni::Options do
     describe '#url=' do
         it 'normalizes its argument' do
             subject.url = 'http://test.com/my path'
-            subject.url.should == @utils.normalize_url( subject.url )
+            expect(subject.url).to eq(@utils.normalize_url( subject.url ))
         end
 
         it 'accepts the HTTP scheme' do
             subject.url = 'http://test.com'
-            subject.url.should == 'http://test.com/'
+            expect(subject.url).to eq('http://test.com/')
         end
 
         it 'accepts the HTTPS scheme' do
             subject.url = 'https://test.com'
-            subject.url.should == 'https://test.com/'
+            expect(subject.url).to eq('https://test.com/')
         end
 
         context 'when passed reserved host' do
@@ -158,7 +159,7 @@ describe Arachni::Options do
             context 'and an HTTPS url is provided' do
                 it 'accepts the HTTPS scheme' do
                     subject.url = 'https://test.com'
-                    subject.url.should == 'https://test.com/'
+                    expect(subject.url).to eq('https://test.com/')
                 end
             end
 
@@ -177,7 +178,7 @@ describe Arachni::Options do
             opts = { url: 'http://blah2.com' }
 
             subject.update( opts )
-            subject.url.to_s.should == @utils.normalize_url( opts[:url] )
+            expect(subject.url.to_s).to eq(@utils.normalize_url( opts[:url] ))
         end
 
         context 'when key refers to an OptionGroup' do
@@ -195,10 +196,10 @@ describe Arachni::Options do
 
                 subject.update( opts )
 
-                subject.scope.exclude_path_patterns.should == [/exclude me2/]
-                subject.scope.include_path_patterns.should == [/include me2/]
-                subject.scope.redundant_path_patterns.should == { /redundant/ => 4 }
-                subject.datastore.to_h.should == opts[:datastore]
+                expect(subject.scope.exclude_path_patterns).to eq([/exclude me2/])
+                expect(subject.scope.include_path_patterns).to eq([/include me2/])
+                expect(subject.scope.redundant_path_patterns).to eq({ /redundant/ => 4 })
+                expect(subject.datastore.to_h).to eq(opts[:datastore])
             end
         end
     end
@@ -215,7 +216,7 @@ describe Arachni::Options do
             rescue
                 raised = true
             end
-            raised.should be_false
+            expect(raised).to be_falsey
         end
 
         it 'returns the file location'do
@@ -229,7 +230,7 @@ describe Arachni::Options do
             rescue
                 raised = true
             end
-            raised.should be_false
+            expect(raised).to be_falsey
         end
     end
 
@@ -241,8 +242,8 @@ describe Arachni::Options do
             subject.save( f )
 
             options = subject.load( f )
-            options.should == subject
-            options.scope.restrict_paths.should == ['test']
+            expect(options).to eq(subject)
+            expect(options.scope.restrict_paths).to eq(['test'])
 
             raised = false
             begin
@@ -250,7 +251,7 @@ describe Arachni::Options do
             rescue
                 raised = true
             end
-            raised.should be_false
+            expect(raised).to be_falsey
         end
     end
 
@@ -259,18 +260,18 @@ describe Arachni::Options do
         ignore = [:instance, :rpc, :dispatcher, :paths, :spawns, :snapshot, :output]
 
         it 'converts self to a serializable hash' do
-            data.should be_kind_of Hash
+            expect(data).to be_kind_of Hash
 
-            Arachni::RPC::Serializer.load(
+            expect(Arachni::RPC::Serializer.load(
                 Arachni::RPC::Serializer.dump( data )
-            ).should == data
+            )).to eq(data)
         end
 
         (groups - ignore).each do |k|
             k = k.to_s
 
             it "includes the '#{k}' group" do
-                data[k].should == subject.send(k).to_rpc_data
+                expect(data[k]).to eq(subject.send(k).to_rpc_data)
             end
         end
 
@@ -278,7 +279,7 @@ describe Arachni::Options do
             k = k.to_s
 
             it "does not include the '#{k}' group" do
-                subject.to_rpc_data.should_not include k
+                expect(subject.to_rpc_data).not_to include k
             end
         end
     end
@@ -290,7 +291,7 @@ describe Arachni::Options do
             subject.datastore.stuff      = 'test2'
 
             h = subject.to_hash
-            h.should be_kind_of Hash
+            expect(h).to be_kind_of Hash
 
             h.each do |k, v|
                 next if k == :instance
@@ -298,13 +299,13 @@ describe Arachni::Options do
 
                 case v
                     when nil
-                        v.should be_nil
+                        expect(v).to be_nil
 
                     when Array
-                        subject_value.should == v
+                        expect(subject_value).to eq(v)
 
                     else
-                        (subject_value.respond_to?( :to_h ) ? subject_value.to_h : v).should == v
+                        expect(subject_value.respond_to?( :to_h ) ? subject_value.to_h : v).to eq(v)
                 end
             end
         end
@@ -312,7 +313,7 @@ describe Arachni::Options do
 
     describe '#to_h' do
         it 'aliased to to_hash' do
-            subject.to_hash.should == subject.to_h
+            expect(subject.to_hash).to eq(subject.to_h)
         end
     end
 
@@ -324,8 +325,8 @@ describe Arachni::Options do
                 }
             )
 
-            normalized[:http][:request_timeout].should == 90_000
-            subject.http.request_timeout.should_not == 90_000
+            expect(normalized[:http][:request_timeout]).to eq(90_000)
+            expect(subject.http.request_timeout).not_to eq(90_000)
         end
     end
 
@@ -335,8 +336,8 @@ describe Arachni::Options do
                 http: { request_timeout: 90_000 }
             )
 
-            normalized['http']['request_timeout'].should == 90_000
-            subject.http.request_timeout.should_not == 90_000
+            expect(normalized['http']['request_timeout']).to eq(90_000)
+            expect(subject.http.request_timeout).not_to eq(90_000)
         end
     end