arachni 1.2.1 → 1.3

data/spec/arachni/support/cache/least_cost_replacement_spec.rb

@@ -10,12 +10,12 @@ describe Arachni::Support::Cache::LeastCostReplacement do
         subject.store( :k2, '2', :high )
         subject.store( :k3, '3', :medium )
         subject.store( :k4, '4', :low )
-        subject.size.should == 3
+        expect(subject.size).to eq(3)
 
-        subject[:k4].should be_true
-        subject[:k3].should be_nil
-        subject[:k2].should be_true
-        subject[:k].should be_true
+        expect(subject[:k4]).to be_truthy
+        expect(subject[:k3]).to be_nil
+        expect(subject[:k2]).to be_truthy
+        expect(subject[:k]).to be_truthy
 
         subject.clear
 
@@ -25,37 +25,37 @@ describe Arachni::Support::Cache::LeastCostReplacement do
         subject.store( :k2, '2', :low )
         subject.store( :k3, '3', :low )
         subject.store( :k4, '4', :low )
-        subject.size.should == 1
+        expect(subject.size).to eq(1)
 
-        subject[:k4].should be_true
-        subject[:k3].should be_nil
-        subject[:k2].should be_nil
-        subject[:k].should be_nil
+        expect(subject[:k4]).to be_truthy
+        expect(subject[:k3]).to be_nil
+        expect(subject[:k2]).to be_nil
+        expect(subject[:k]).to be_nil
     end
 
     describe '#store' do
         it 'stores an object by key' do
             v = 'val'
-            subject.store( :key, v, :low ).should == v
-            subject[:key].should == v
+            expect(subject.store( :key, v, :low )).to eq(v)
+            expect(subject[:key]).to eq(v)
         end
         it 'assigns cost to object' do
             v = 'val'
-            subject.store( :key, v, :low ).should == v
-            subject[:key].should == v
+            expect(subject.store( :key, v, :low )).to eq(v)
+            expect(subject[:key]).to eq(v)
         end
     end
 
     describe '#[]=' do
         it 'stores an object' do
             v = 'val'
-            (subject[:key] = v).should == v
-            subject[:key].should == v
+            expect(subject[:key] = v).to eq(v)
+            expect(subject[:key]).to eq(v)
         end
         it 'alias of #store' do
             v = 'val2'
-            subject.store( :key2, v ).should == v
-            subject[:key2].should == v
+            expect(subject.store( :key2, v )).to eq(v)
+            expect(subject[:key2]).to eq(v)
         end
     end
 end

data/spec/arachni/support/cache/least_recently_pushed_spec.rb

@@ -10,12 +10,12 @@ describe Arachni::Support::Cache::LeastRecentlyPushed do
         subject[:k2] = '2'
         subject[:k3] = '3'
         subject[:k4] = '4'
-        subject.size.should == 3
+        expect(subject.size).to eq(3)
 
-        subject[:k4].should be_true
-        subject[:k3].should be_true
-        subject[:k2].should be_true
-        subject[:k].should be_nil
+        expect(subject[:k4]).to be_truthy
+        expect(subject[:k3]).to be_truthy
+        expect(subject[:k2]).to be_truthy
+        expect(subject[:k]).to be_nil
 
         subject.clear
 
@@ -23,23 +23,23 @@ describe Arachni::Support::Cache::LeastRecentlyPushed do
         subject[:k]  = '1'
         subject[:k2] = '3'
         subject[:k3] = '4'
-        subject.size.should == 1
+        expect(subject.size).to eq(1)
 
-        subject[:k3].should be_true
-        subject[:k2].should be_nil
-        subject[:k].should be_nil
+        expect(subject[:k3]).to be_truthy
+        expect(subject[:k2]).to be_nil
+        expect(subject[:k]).to be_nil
     end
 
     describe '#[]=' do
         it 'stores an object' do
             v = 'val'
-            (subject[:key] = v).should == v
-            subject[:key].should == v
+            expect(subject[:key] = v).to eq(v)
+            expect(subject[:key]).to eq(v)
         end
         it 'alias of #store' do
             v = 'val2'
-            subject.store( :key2, v ).should == v
-            subject[:key2].should == v
+            expect(subject.store( :key2, v )).to eq(v)
+            expect(subject[:key2]).to eq(v)
         end
     end
 
@@ -47,13 +47,13 @@ describe Arachni::Support::Cache::LeastRecentlyPushed do
         it 'retrieves an object by key' do
             v = 'val2'
             subject[:key] = v
-            subject[:key].should == v
-            subject.empty?.should be_false
+            expect(subject[:key]).to eq(v)
+            expect(subject.empty?).to be_falsey
         end
 
         context 'when the key does not exist' do
             it 'returns nil' do
-                subject[:some_key].should be_nil
+                expect(subject[:some_key]).to be_nil
             end
         end
     end
@@ -63,14 +63,14 @@ describe Arachni::Support::Cache::LeastRecentlyPushed do
             it 'deletes a key and return its value' do
                 v = 'my_val'
                 subject[:my_key] = v
-                subject.delete( :my_key ).should == v
-                subject[:my_key].should be_nil
-                subject.include?( :my_key ).should be_false
+                expect(subject.delete( :my_key )).to eq(v)
+                expect(subject[:my_key]).to be_nil
+                expect(subject.include?( :my_key )).to be_falsey
             end
         end
         context 'when the key does not exist' do
             it 'returns nil' do
-                subject.delete( :my_key2 ).should be_nil
+                expect(subject.delete( :my_key2 )).to be_nil
             end
         end
     end
@@ -78,12 +78,12 @@ describe Arachni::Support::Cache::LeastRecentlyPushed do
     describe '#clear' do
         it 'empties the cache' do
             subject[:my_key2] = 'v'
-            subject.size.should > 0
-            subject.empty?.should be_false
+            expect(subject.size).to be > 0
+            expect(subject.empty?).to be_falsey
             subject.clear
 
-            subject.size.should == 0
-            subject.empty?.should be_true
+            expect(subject.size).to eq(0)
+            expect(subject.empty?).to be_truthy
         end
     end
 

data/spec/arachni/support/cache/least_recently_used_spec.rb

@@ -12,26 +12,26 @@ describe Arachni::Support::Cache::LeastRecentlyUsed do
         subject[:k3] = '3'
         subject[:k4] = '4'
 
-        subject.size.should == 3
+        expect(subject.size).to eq(3)
 
         ap subject
 
-        subject[:k].should be_true
-        subject[:k4].should be_true
-        subject[:k3].should be_true
-        subject[:k2].should be_nil
+        expect(subject[:k]).to be_truthy
+        expect(subject[:k4]).to be_truthy
+        expect(subject[:k3]).to be_truthy
+        expect(subject[:k2]).to be_nil
     end
 
     describe '#[]=' do
         it 'stores an object' do
             v = 'val'
-            (subject[:key] = v).should == v
-            subject[:key].should == v
+            expect(subject[:key] = v).to eq(v)
+            expect(subject[:key]).to eq(v)
         end
         it 'alias of #store' do
             v = 'val2'
-            subject.store( :key2, v ).should == v
-            subject[:key2].should == v
+            expect(subject.store( :key2, v )).to eq(v)
+            expect(subject[:key2]).to eq(v)
         end
     end
 
@@ -39,13 +39,13 @@ describe Arachni::Support::Cache::LeastRecentlyUsed do
         it 'retrieves an object by key' do
             v = 'val2'
             subject[:key] = v
-            subject[:key].should == v
-            subject.empty?.should be_false
+            expect(subject[:key]).to eq(v)
+            expect(subject.empty?).to be_falsey
         end
 
         context 'when the key does not exist' do
             it 'returns nil' do
-                subject[:some_key].should be_nil
+                expect(subject[:some_key]).to be_nil
             end
         end
     end
@@ -55,14 +55,14 @@ describe Arachni::Support::Cache::LeastRecentlyUsed do
             it 'deletes a key and return its value' do
                 v = 'my_val'
                 subject[:my_key] = v
-                subject.delete( :my_key ).should == v
-                subject[:my_key].should be_nil
-                subject.include?( :my_key ).should be_false
+                expect(subject.delete( :my_key )).to eq(v)
+                expect(subject[:my_key]).to be_nil
+                expect(subject.include?( :my_key )).to be_falsey
             end
         end
         context 'when the key does not exist' do
             it 'returns nil' do
-                subject.delete( :my_key2 ).should be_nil
+                expect(subject.delete( :my_key2 )).to be_nil
             end
         end
     end
@@ -70,12 +70,12 @@ describe Arachni::Support::Cache::LeastRecentlyUsed do
     describe '#clear' do
         it 'empties the cache' do
             subject[:my_key2] = 'v'
-            subject.size.should > 0
-            subject.empty?.should be_false
+            expect(subject.size).to be > 0
+            expect(subject.empty?).to be_falsey
             subject.clear
 
-            subject.size.should == 0
-            subject.empty?.should be_true
+            expect(subject.size).to eq(0)
+            expect(subject.empty?).to be_truthy
         end
     end
 

data/spec/arachni/support/cache/preference_spec.rb

@@ -13,9 +13,9 @@ describe Arachni::Support::Cache::Preference do
         subject[k[1]] = '2'
         subject[k[2]] = '3'
         subject[k[3]] = '4'
-        subject.size.should == 3
+        expect(subject.size).to eq(3)
 
-        k.map { |key| subject[key] }.count( nil ).should == 1
+        expect(k.map { |key| subject[key] }.count( nil )).to eq(1)
 
         subject.clear
     end
@@ -29,9 +29,9 @@ describe Arachni::Support::Cache::Preference do
         subject[k[0]]  = '1'
         subject[k[1]] = '3'
         subject[k[2]] = '4'
-        subject.size.should == 2
+        expect(subject.size).to eq(2)
 
-        k[0...3].map { |key| subject[key] }.count( nil ).should == 1
+        expect(k[0...3].map { |key| subject[key] }.count( nil )).to eq(1)
     end
 
 end

data/spec/arachni/support/cache/random_replacement_spec.rb

@@ -11,9 +11,9 @@ describe Arachni::Support::Cache::RandomReplacement do
         subject[k[1]] = '2'
         subject[k[2]] = '3'
         subject[k[3]] = '4'
-        subject.size.should == 3
+        expect(subject.size).to eq(3)
 
-        k.map { |key| subject[key] }.count( nil ).should == 1
+        expect(k.map { |key| subject[key] }.count( nil )).to eq(1)
 
         subject.clear
 
@@ -21,21 +21,21 @@ describe Arachni::Support::Cache::RandomReplacement do
         subject[k[0]]  = '1'
         subject[k[1]] = '3'
         subject[k[2]] = '4'
-        subject.size.should == 1
+        expect(subject.size).to eq(1)
 
-        k[0...3].map { |key| subject[key] }.count( nil ).should == 2
+        expect(k[0...3].map { |key| subject[key] }.count( nil )).to eq(2)
     end
 
     describe '#[]=' do
         it 'stores an object' do
             v = 'val'
-            (subject[:key] = v).should == v
-            subject[:key].should == v
+            expect(subject[:key] = v).to eq(v)
+            expect(subject[:key]).to eq(v)
         end
         it 'alias of #store' do
             v = 'val2'
-            subject.store( :key2, v ).should == v
-            subject[:key2].should == v
+            expect(subject.store( :key2, v )).to eq(v)
+            expect(subject[:key2]).to eq(v)
         end
     end
 

data/spec/arachni/support/crypto/rsa_aes_cbc_spec.rb

@@ -23,7 +23,7 @@ describe Arachni::Support::Crypto::RSA_AES_CBC do
     end
 
     it 'generates matching encrypted and decrypted data' do
-        @crypto.decrypt( @crypto.encrypt( SEED ) ).should == SEED
+        expect(@crypto.decrypt( @crypto.encrypt( SEED ) )).to eq(SEED)
     end
 
 end

data/spec/arachni/support/database/hash_spec.rb

@@ -17,134 +17,135 @@ describe Arachni::Support::Database::Hash do
     it 'implements #empty?' do
         h = described_class.new
 
-        h.empty?.should == {}.empty?
+        expect(h.empty?).to eq({}.empty?)
 
         nh = { :k => 'v' }
         h[:k] = 'v'
 
-        h.empty?.should == nh.empty?
+        expect(h.empty?).to eq(nh.empty?)
         h.clear
     end
 
     # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-5B-5D-3D
     it 'implements #[]=( k, v ) (and store( k, v ))' do
         @seeds.each do |k, v|
-            (@hash[k] = v).should == v
+            expect(@hash[k] = v).to eq(v)
         end
     end
 
     # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-5B-5D
     it 'implements #[]' do
         @seeds.each do |k, v|
-            @hash[k].should == v
+            expect(@hash[k]).to eq(v)
         end
 
-        @hash[@non_existent].should == @seeds[@non_existent]
+        expect(@hash[@non_existent]).to eq(@seeds[@non_existent])
     end
 
     # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-assoc
     it 'implements #assoc( k )' do
         @seeds.each do |k, v|
-            @hash.assoc( k ).should == @seeds.assoc( k )
+            expect(@hash.assoc( k )).to eq(@seeds.assoc( k ))
         end
 
-        @hash.assoc( @non_existent ).should == @seeds.assoc( @non_existent )
+        expect(@hash.assoc( @non_existent )).to eq(@seeds.assoc( @non_existent ))
     end
 
     # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-rassoc
     it 'implements #rassoc( k )' do
         @seeds.each do |k, v|
-            @hash.rassoc( v ).should == @seeds.rassoc( v )
+            expect(@hash.rassoc( v )).to eq(@seeds.rassoc( v ))
         end
 
-        @hash.rassoc( @non_existent ).should == @seeds.rassoc( @non_existent )
+        expect(@hash.rassoc( @non_existent )).to eq(@seeds.rassoc( @non_existent ))
     end
 
     # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-delete
     it 'implements #delete( k, &block )' do
-        @hash.delete( @non_existent ).should == @seeds.delete( @non_existent )
+        expect(@hash.delete( @non_existent )).to eq(@seeds.delete( @non_existent ))
         @seeds[@non_existent] = @hash[@non_existent] = 'foo'
-        @hash.delete( @non_existent ).should == @seeds.delete( @non_existent )
+        expect(@hash.delete( @non_existent )).to eq(@seeds.delete( @non_existent ))
 
-        @hash.delete( @non_existent ) { |k| k }.should ==
+        expect(@hash.delete( @non_existent ) { |k| k }).to eq(
             @seeds.delete( @non_existent ) { |k| k }
+        )
     end
 
     # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-shift
     it 'implements #shift' do
-        @hash.shift.should == @seeds.shift
+        expect(@hash.shift).to eq(@seeds.shift)
     end
 
     # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-each
     it 'implements #each() (and #each_pair())' do
         @hash.each do |k, v|
-            @seeds[k].should == v
+            expect(@seeds[k]).to eq(v)
         end
 
         # they must both return enumerators
-        @hash.each.class.should == @seeds.each.class
+        expect(@hash.each.class).to eq(@seeds.each.class)
 
         @hash.each_pair do |k, v|
-            @seeds[k].should == v
+            expect(@seeds[k]).to eq(v)
         end
 
         # they must both return enumerators
-        @hash.each_pair.class.should == @seeds.each_pair.class
+        expect(@hash.each_pair.class).to eq(@seeds.each_pair.class)
     end
 
     # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-each_key
     it 'implements #each_key' do
         @hash.each_key do |k|
-            @seeds[k].should == @hash[k]
+            expect(@seeds[k]).to eq(@hash[k])
         end
 
         # they must both return enumerators
-        @hash.each_key.class.should == @seeds.each_key.class
+        expect(@hash.each_key.class).to eq(@seeds.each_key.class)
     end
 
     # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-each_value
     it 'implements #each_value' do
         @hash.each_value do |v|
-            @seeds[ @seeds.key( v )].should == v
+            expect(@seeds[ @seeds.key( v )]).to eq(v)
         end
 
         # they must both return enumerators
-        @hash.each_value.class.should == @seeds.each_value.class
+        expect(@hash.each_value.class).to eq(@seeds.each_value.class)
     end
 
     # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-keys
     it 'implements #keys' do
-        @hash.keys.should == @seeds.keys
+        expect(@hash.keys).to eq(@seeds.keys)
     end
 
     # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-key
     it 'implement #key' do
         @hash.each_key do |k|
-            @seeds.key( k ).should == @hash.key( k )
+            expect(@seeds.key( k )).to eq(@hash.key( k ))
         end
 
-        @hash.key( @non_existent ).should == @seeds.key( @non_existent )
+        expect(@hash.key( @non_existent )).to eq(@seeds.key( @non_existent ))
     end
 
     # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-values
     it 'implements #values' do
-        @hash.values.should == @seeds.values
+        expect(@hash.values).to eq(@seeds.values)
     end
 
     # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-include?
     it 'implements #include? (and #member?, #key?, #has_key?)' do
         @hash.each_key {
             |k|
-            @seeds.include?( k ).should == @hash.include?( k )
-            @seeds.member?( k ).should == @hash.member?( k )
-            @seeds.key?( k ).should == @hash.key?( k )
-            @seeds.has_key?( k ).should == @hash.has_key?( k )
+            expect(@seeds.include?( k )).to eq(@hash.include?( k ))
+            expect(@seeds.member?( k )).to eq(@hash.member?( k ))
+            expect(@seeds.key?( k )).to eq(@hash.key?( k ))
+            expect(@seeds.has_key?( k )).to eq(@hash.has_key?( k ))
         }
 
-        @hash.include?( @non_existent ).should == @seeds.include?( @non_existent )
-        @hash.member?( @non_existent ).should == @seeds.member?( @non_existent )
-        @hash.key?( @non_existent ).should == @seeds.key?( @non_existent )
-        @hash.has_key?( @non_existent ).should == @seeds.has_key?( @non_existent )
+        expect(@hash.include?( @non_existent )).to eq(@seeds.include?( @non_existent ))
+        expect(@hash.member?( @non_existent )).to eq(@seeds.member?( @non_existent ))
+        expect(@hash.key?( @non_existent )).to eq(@seeds.key?( @non_existent ))
+        expect(@hash.has_key?( @non_existent )).to eq(@seeds.has_key?( @non_existent ))
     end
 
     # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-merge
@@ -152,8 +153,8 @@ describe Arachni::Support::Database::Hash do
         mh = { :another_key => 'another value' }
 
         nh = @hash.merge( mh )
-        nh.keys.should == @seeds.merge( mh ).keys
-        nh.values.should == @seeds.merge( mh ).values
+        expect(nh.keys).to eq(@seeds.merge( mh ).keys)
+        expect(nh.values).to eq(@seeds.merge( mh ).values)
     end
 
     # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-merge!
@@ -167,36 +168,36 @@ describe Arachni::Support::Database::Hash do
         @hash.update( mh2 )
         @seeds.update( mh2 )
 
-        @hash.keys.should == @seeds.keys
-        @hash.values.should == @seeds.values
+        expect(@hash.keys).to eq(@seeds.keys)
+        expect(@hash.values).to eq(@seeds.values)
     end
 
     # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-to_hash
     it 'implements #to_hash' do
-        @hash.to_hash.should == @seeds.to_hash
+        expect(@hash.to_hash).to eq(@seeds.to_hash)
     end
 
     # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-to_a
     it 'implements #to_a' do
-        @hash.to_a.should == @seeds.to_a
+        expect(@hash.to_a).to eq(@seeds.to_a)
     end
 
     # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-size
     it 'implements #size' do
-        @hash.size.should == @seeds.size
+        expect(@hash.size).to eq(@seeds.size)
     end
 
     # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-3D-3D
     it 'implements #== (and #eql?)' do
-        (@hash == @hash.merge( {} )).should == true
-        (@hash == @seeds).should == true
+        expect(@hash == @hash.merge( {} )).to eq(true)
+        expect(@hash == @seeds).to eq(true)
     end
 
     # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-clear
     it 'implements #clear' do
         @hash.clear
         @seeds.clear
-        @hash.size.should == @seeds.size
+        expect(@hash.size).to eq(@seeds.size)
     end
 
     after :all do