metasploit_data_models 0.24.4 → 0.24.5

data/spec/app/models/metasploit_data_models/search/visitor/where_spec.rb

@@ -1,4 +1,6 @@
-RSpec.describe MetasploitDataModels::Search::Visitor::Where, type: :model do
+require 'spec_helper'
+
+describe MetasploitDataModels::Search::Visitor::Where do
   subject(:visitor) do
     described_class.new
   end
@@ -10,7 +12,7 @@ RSpec.describe MetasploitDataModels::Search::Visitor::Where, type: :model do
       visitor.attribute_visitor
     end
 
-    it { is_expected.to be_a MetasploitDataModels::Search::Visitor::Attribute }
+    it { should be_a MetasploitDataModels::Search::Visitor::Attribute }
   end
 
   context '#method_visitor' do
@@ -18,7 +20,7 @@ RSpec.describe MetasploitDataModels::Search::Visitor::Where, type: :model do
       visitor.method_visitor
     end
 
-    it { is_expected.to be_a MetasploitDataModels::Search::Visitor::Method }
+    it { should be_a MetasploitDataModels::Search::Visitor::Method }
   end
 
   context '#visit' do
@@ -82,16 +84,16 @@ RSpec.describe MetasploitDataModels::Search::Visitor::Where, type: :model do
       end
 
       it 'should visit operation.operator with attribute_visitor' do
-        expect(visitor.attribute_visitor).to receive(:visit).with(operator).and_call_original
+        visitor.attribute_visitor.should_receive(:visit).with(operator).and_call_original
 
         visit
       end
 
       it 'should call matches on Arel::Attributes::Attribute from attribute_visitor' do
         attribute = double('Visited Operator')
-        allow(visitor.attribute_visitor).to receive(:visit).with(operator).and_return(attribute)
+        visitor.attribute_visitor.stub(:visit).with(operator).and_return(attribute)
 
-        expect(attribute).to receive(:matches).with("%#{value}%")
+        attribute.should_receive(:matches).with("%#{value}%")
 
         visit
       end
@@ -163,7 +165,7 @@ RSpec.describe MetasploitDataModels::Search::Visitor::Where, type: :model do
             end
 
             it 'should match module_instances.name with ILIKE' do
-              expect(visit.to_sql).to eq("\"hosts\".\"name\" ILIKE '%#{name}%'")
+              visit.to_sql.should == "\"hosts\".\"name\" ILIKE '%#{name}%'"
             end
           end
 
@@ -177,7 +179,7 @@ RSpec.describe MetasploitDataModels::Search::Visitor::Where, type: :model do
             end
 
             it 'should match module_actions.name with ILIKE' do
-              expect(visit.to_sql).to eq("\"services\".\"name\" ILIKE '%#{name}%'")
+              visit.to_sql.should == "\"services\".\"name\" ILIKE '%#{name}%'"
             end
           end
         end

data/spec/app/validators/parameters_validator_spec.rb

@@ -1,4 +1,6 @@
-RSpec.describe ParametersValidator do
+require 'spec_helper'
+
+describe ParametersValidator do
   subject(:parameters_validator) do
     described_class.new(
         :attributes => attributes
@@ -27,7 +29,7 @@ RSpec.describe ParametersValidator do
 
   context 'CONSTANTS' do
     it 'should define TYPE_SIGNATURE_SENTENCE' do
-      expect(described_class::TYPE_SIGNATURE_SENTENCE).to eq(type_signature_sentence)
+      described_class::TYPE_SIGNATURE_SENTENCE.should == type_signature_sentence
     end
   end
 
@@ -46,7 +48,7 @@ RSpec.describe ParametersValidator do
     end
 
     it 'should include prefix' do
-      expect(error_at).to include(prefix)
+      error_at.should include(prefix)
     end
 
     it 'should include location_clause in same sentence as prefix' do
@@ -56,11 +58,11 @@ RSpec.describe ParametersValidator do
           :index => index
       )
 
-      expect(error_at).to include("#{prefix} #{location_clause}.")
+      error_at.should include("#{prefix} #{location_clause}.")
     end
 
     it 'should include TYPE_SIGNATURE_SENTENCE' do
-      expect(error_at).to include(type_signature_sentence)
+      error_at.should include(type_signature_sentence)
     end
   end
 
@@ -79,9 +81,9 @@ RSpec.describe ParametersValidator do
     end
 
     it 'should include extreme in prefix' do
-      expect(parameters_validator).to receive(:error_at) do |*args|
+      parameters_validator.should_receive(:error_at) do |*args|
         options = args.first
-        expect(options[:prefix]).to include(extreme.to_s)
+        options[:prefix].should include(extreme.to_s)
       end
 
       length_error_at
@@ -98,11 +100,11 @@ RSpec.describe ParametersValidator do
     end
 
     it 'should include numerical index' do
-      expect(location_clause).to include("at index #{index}")
+      location_clause.should include("at index #{index}")
     end
 
     it 'should include inspect of element' do
-      expect(location_clause).to include(element.inspect)
+      location_clause.should include(element.inspect)
     end
   end
 
@@ -142,7 +144,7 @@ RSpec.describe ParametersValidator do
             end
 
             it 'should call #length_error_at with :extreme => :few' do
-              expect(parameters_validator).to receive(:length_error_at).with(
+              parameters_validator.should_receive(:length_error_at).with(
                   hash_including(
                       :extreme => :few
                   )
@@ -154,7 +156,7 @@ RSpec.describe ParametersValidator do
             it 'should record error' do
               validate_each
 
-              expect(errors).not_to be_empty
+              errors.should_not be_empty
             end
           end
 
@@ -164,7 +166,7 @@ RSpec.describe ParametersValidator do
             end
 
             it 'should call #length_error_at with :extreme => :many' do
-              expect(parameters_validator).to receive(:length_error_at).with(
+              parameters_validator.should_receive(:length_error_at).with(
                   hash_including(
                       :extreme => :many
                   )
@@ -176,7 +178,7 @@ RSpec.describe ParametersValidator do
             it 'should record error' do
               validate_each
 
-              expect(errors).not_to be_empty
+              errors.should_not be_empty
             end
           end
 
@@ -201,7 +203,7 @@ RSpec.describe ParametersValidator do
                   end
 
                   it 'should call error_at with blank parameter name prefix' do
-                    expect(parameters_validator).to receive(:error_at).with(
+                    parameters_validator.should_receive(:error_at).with(
                         hash_including(
                           :prefix => 'has blank parameter name'
                         )
@@ -213,7 +215,7 @@ RSpec.describe ParametersValidator do
                   it 'should record error' do
                     validate_each
 
-                    expect(errors).not_to be_empty
+                    errors.should_not be_empty
                   end
                 end
 
@@ -225,7 +227,7 @@ RSpec.describe ParametersValidator do
                   it 'should not record error' do
                     validate_each
 
-                    expect(errors).to be_blank
+                    errors.should be_blank
                   end
                 end
               end
@@ -236,7 +238,7 @@ RSpec.describe ParametersValidator do
                 end
 
                 it 'should call error_at with non-String prefix' do
-                  expect(parameters_validator).to receive(:error_at).with(
+                  parameters_validator.should_receive(:error_at).with(
                       hash_including(
                           :prefix => "has non-String parameter name (#{parameter_name.inspect})"
                       )
@@ -248,7 +250,7 @@ RSpec.describe ParametersValidator do
                 it 'should record error' do
                   validate_each
 
-                  expect(errors).not_to be_empty
+                  errors.should_not be_empty
                 end
               end
             end
@@ -262,7 +264,7 @@ RSpec.describe ParametersValidator do
                 it 'should not record error' do
                   validate_each
 
-                  expect(errors).to be_blank
+                  errors.should be_blank
                 end
               end
 
@@ -272,7 +274,7 @@ RSpec.describe ParametersValidator do
                 end
 
                 it 'should call error_at with non-String prefix' do
-                  expect(parameters_validator).to receive(:error_at).with(
+                  parameters_validator.should_receive(:error_at).with(
                       hash_including(
                           :prefix => "has non-String parameter value (#{parameter_value.inspect})"
                       )
@@ -284,7 +286,7 @@ RSpec.describe ParametersValidator do
                 it 'should record error' do
                   validate_each
 
-                  expect(errors).not_to be_empty
+                  errors.should_not be_empty
                 end
               end
             end
@@ -297,7 +299,7 @@ RSpec.describe ParametersValidator do
           end
 
           it 'should use #error_at with has non-Array for prefix' do
-            expect(parameters_validator).to receive(:error_at).with(
+            parameters_validator.should_receive(:error_at).with(
                 hash_including(
                     :prefix => 'has non-Array'
                 )
@@ -309,7 +311,7 @@ RSpec.describe ParametersValidator do
           it 'should record error' do
             validate_each
 
-            expect(errors).not_to be_empty
+            errors.should_not be_empty
           end
         end
       end
@@ -325,16 +327,14 @@ RSpec.describe ParametersValidator do
       end
 
       it 'should error that attribute is not an array' do
-        expect(
-            errors.any? { |error|
-              error.include? 'is not an Array.'
-            }
-        ).to eq(true)
+        errors.any? { |error|
+          error.include? 'is not an Array.'
+        }.should be_true
       end
 
       it 'should include TYPE_SIGNATURE_SENTENCE' do
         errors.each do |error|
-          expect(error).to include(type_signature_sentence)
+          error.should include(type_signature_sentence)
         end
       end
     end

data/spec/app/validators/password_is_strong_validator_spec.rb

@@ -1,4 +1,6 @@
-RSpec.describe PasswordIsStrongValidator do
+require 'spec_helper'
+
+describe PasswordIsStrongValidator do
 
   subject(:password_validator) do
     described_class.new(
@@ -18,23 +20,23 @@ RSpec.describe PasswordIsStrongValidator do
   context '#contains_repetition?' do
 
     it 'should return true for aaaa' do
-      expect(password_validator.send(:contains_repetition?, 'aaaa')).to eq(true)
+      password_validator.send(:contains_repetition?, 'aaaa').should be_true
     end
 
     it 'should return true for ababab' do
-      expect(password_validator.send(:contains_repetition?, 'ababab')).to eq(true)
+      password_validator.send(:contains_repetition?, 'ababab').should be_true
     end
 
     it 'should return true for abcabcabc' do
-      expect(password_validator.send(:contains_repetition?, 'abcabcabc')).to eq(true)
+      password_validator.send(:contains_repetition?, 'abcabcabc').should be_true
     end
 
     it 'should return true for abcdabcd' do
-      expect(password_validator.send(:contains_repetition?, 'abcdabcd')).to eq(true)
+      password_validator.send(:contains_repetition?, 'abcdabcd').should be_true
     end
 
     it 'should return false for abcd1234abcd' do
-      expect(password_validator.send(:contains_repetition?, 'abcd1234abcd')).to eq(false)
+      password_validator.send(:contains_repetition?, 'abcd1234abcd').should be_false
     end
 
   end
@@ -110,7 +112,7 @@ RSpec.describe PasswordIsStrongValidator do
       ]
 
     it 'should return all the expected mutations of a password' do
-      expect(password_validator.send(:mutate_pass, 'metasploit')).to eq(variants)
+      password_validator.send(:mutate_pass, 'metasploit').should == variants
     end
 
   end
@@ -121,81 +123,81 @@ RSpec.describe PasswordIsStrongValidator do
     PasswordIsStrongValidator::COMMON_PASSWORDS.each do |password|
 
       it "should return true for #{password}"  do
-        expect(password_validator.send(:is_common_password?, password)).to eq(true)
+        password_validator.send(:is_common_password?, password).should be_true
       end
 
       it "should return true for #{password}!"  do
-        expect(password_validator.send(:is_common_password?, "#{password}!")).to eq(true)
+        password_validator.send(:is_common_password?, "#{password}!").should be_true
       end
 
       it "should return true for #{password}1"  do
-        expect(password_validator.send(:is_common_password?, "#{password}1")).to eq(true)
+        password_validator.send(:is_common_password?, "#{password}1").should be_true
       end
 
       it "should return true for #{password}9"  do
-        expect(password_validator.send(:is_common_password?, "#{password}1")).to eq(true)
+        password_validator.send(:is_common_password?, "#{password}1").should be_true
       end
 
       it "should return true for #{password}99"  do
-        expect(password_validator.send(:is_common_password?, "#{password}12")).to eq(true)
+        password_validator.send(:is_common_password?, "#{password}12").should be_true
       end
 
       it "should return true for #{password}123"  do
-        expect(password_validator.send(:is_common_password?, "#{password}123")).to eq(true)
+        password_validator.send(:is_common_password?, "#{password}123").should be_true
       end
 
       it "should return true for #{password}123!" do
-        expect(password_validator.send(:is_common_password?, "#{password}123!")).to eq(true)
+        password_validator.send(:is_common_password?, "#{password}123!").should be_true
       end
 
     end
 
     it "should return true for r00t" do
-      expect(password_validator.send(:is_common_password?, "r00t")).to eq(true)
+      password_validator.send(:is_common_password?, "r00t").should be_true
     end
 
     it "should return true for m3t@spl0it" do
-      expect(password_validator.send(:is_common_password?, "m3t@spl0it")).to eq(true)
+      password_validator.send(:is_common_password?, "m3t@spl0it").should be_true
     end
 
     it "should return true for m3t@spl0it123!" do
-      expect(password_validator.send(:is_common_password?, "m3t@spl0it123!")).to eq(true)
+      password_validator.send(:is_common_password?, "m3t@spl0it123!").should be_true
     end
   end
 
   context '#contains_username' do
 
     it 'should return true if username and password are the same' do
-      expect(password_validator.send(:contains_username?, 'admin', 'admin')).to eq(true)
+      password_validator.send(:contains_username?, 'admin', 'admin').should be_true
     end
 
     it 'should return true if the password contains the username as part of it' do
-      expect(password_validator.send(:contains_username?, 'admin', '123admin123')).to eq(true)
+      password_validator.send(:contains_username?, 'admin', '123admin123').should be_true
     end
 
     it 'should return false otherwise' do
-      expect(password_validator.send(:contains_username?, 'admin', 'foobar')).to eq(false)
+      password_validator.send(:contains_username?, 'admin', 'foobar').should be_false
     end
   end
 
   context '#is_simple?' do
 
     it "should return true if no number" do
-      expect(password_validator.send(:is_simple?, "b@carat")).to eq(true)
+      password_validator.send(:is_simple?, "b@carat").should be_true
     end
 
     it "should return true if no special char" do
-      expect(password_validator.send(:is_simple?, "bacarat4")).to eq(true)
+      password_validator.send(:is_simple?, "bacarat4").should be_true
     end
 
     it "should return true if no letters" do
-      expect(password_validator.send(:is_simple?, "1337")).to eq(true)
+      password_validator.send(:is_simple?, "1337").should be_true
     end
 
     PasswordIsStrongValidator::SPECIAL_CHARS.each_char do |char|
 
       it "should return false with a #{char}" do
-        expect(password_validator.send(:is_simple?, "bacarat4#{char}")).to eq(false)
+        password_validator.send(:is_simple?, "bacarat4#{char}").should be_false
       end
     end
   end
@@ -210,23 +212,13 @@ RSpec.describe PasswordIsStrongValidator do
       password_validator.validate_each(record, attribute, value)
     end
 
-    let(:record) {
-      record_class.new.tap { |instance|
-        instance.username = 'admin'
+    let(:record) do
+      Object.new.tap { |object|
+        object.extend ActiveModel::Validations
+        object.class.module_eval { attr_accessor :username }
+        object.username = 'admin'
       }
-    }
-
-    let(:record_class) {
-      Class.new do
-        include ActiveModel::Validations
-
-        #
-        # Attributes
-        #
-
-        attr_accessor :username
-      end
-    }
+    end
 
 
     context 'with a password with no special char' do
@@ -234,12 +226,12 @@ RSpec.describe PasswordIsStrongValidator do
 
       it 'should record an error' do
         validate_each
-        expect(errors).not_to be_empty
+        errors.should_not be_empty
       end
 
       it 'should have an error of "must contain letters, numbers, and at least one special character"' do
         validate_each
-        expect(errors.include?("must contain letters, numbers, and at least one special character")).to eq(true)
+        errors.include?("must contain letters, numbers, and at least one special character").should be_true
       end
     end
 
@@ -248,12 +240,12 @@ RSpec.describe PasswordIsStrongValidator do
 
       it 'should record an error' do
         validate_each
-        expect(errors).not_to be_empty
+        errors.should_not be_empty
       end
 
       it 'should have an error of "must contain letters, numbers, and at least one special character"' do
         validate_each
-        expect(errors.include?("must contain letters, numbers, and at least one special character")).to eq(true)
+        errors.include?("must contain letters, numbers, and at least one special character").should be_true
       end
     end
 
@@ -262,12 +254,12 @@ RSpec.describe PasswordIsStrongValidator do
 
       it 'should record an error' do
         validate_each
-        expect(errors).not_to be_empty
+        errors.should_not be_empty
       end
 
       it 'should have an error of "must contain letters, numbers, and at least one special character"' do
         validate_each
-        expect(errors.include?("must contain letters, numbers, and at least one special character")).to eq(true)
+        errors.include?("must contain letters, numbers, and at least one special character").should be_true
       end
     end
 
@@ -276,12 +268,12 @@ RSpec.describe PasswordIsStrongValidator do
 
       it 'should record an error' do
         validate_each
-        expect(errors).not_to be_empty
+        errors.should_not be_empty
       end
 
       it 'should have an error of "must not contain the username"' do
         validate_each
-        expect(errors.include?("must not contain the username")).to eq(true)
+        errors.include?("must not contain the username").should be_true
       end
     end
 
@@ -290,12 +282,12 @@ RSpec.describe PasswordIsStrongValidator do
 
       it 'should record an error' do
         validate_each
-        expect(errors).not_to be_empty
+        errors.should_not be_empty
       end
 
       it 'should have an error of "must not be a common password"' do
         validate_each
-        expect(errors.include?("must not be a common password")).to eq(true)
+        errors.include?("must not be a common password").should be_true
       end
     end
 
@@ -304,12 +296,12 @@ RSpec.describe PasswordIsStrongValidator do
 
       it 'should record an error' do
         validate_each
-        expect(errors).not_to be_empty
+        errors.should_not be_empty
       end
 
       it 'should have an error of "must not be a common password"' do
         validate_each
-        expect(errors.include?("must not be a common password")).to eq(true)
+        errors.include?("must not be a common password").should be_true
       end
     end
 
@@ -318,12 +310,12 @@ RSpec.describe PasswordIsStrongValidator do
 
       it 'should record an error' do
         validate_each
-        expect(errors).not_to be_empty
+        errors.should_not be_empty
       end
 
       it 'should have an error of "must not be a predictable sequence of characters"' do
         validate_each
-        expect(errors.include?("must not be a predictable sequence of characters")).to eq(true)
+        errors.include?("must not be a predictable sequence of characters").should be_true
       end
     end