metasploit_data_models 1.0.0.pre.rails.pre.4.0b → 1.0.0

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

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

data/spec/app/validators/parameters_validator_spec.rb

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

data/spec/app/validators/password_is_strong_validator_spec.rb

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