metasploit-model 0.24.1.pre.semantic.pre.versioning.pre.2.pre.0

data/spec/app/validators/ip_format_validator_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe IpFormatValidator do
+  subject(:ip_format_validator) do
+    described_class.new(
+        :attributes => attributes
+    )
+  end
+
+  let(:attribute) do
+    :address
+  end
+
+  let(:attributes) do
+    [
+        attribute
+    ]
+  end
+
+  context '#validate_each' do
+    subject(:validate_each) do
+      ip_format_validator.validate_each(record, attribute, value)
+    end
+
+    let(:error) do
+      'must be a valid IPv4 or IPv6 address'
+    end
+
+    let(:record) do
+      record_class.new
+    end
+
+    let(:record_class) do
+      # capture for Class.new scope
+      attribute = self.attribute
+
+      Class.new do
+        include ActiveModel::Validations
+
+        #
+        # Validations
+        #
+
+        validates attribute,
+                  :ip_format => true
+      end
+    end
+
+    context 'with value' do
+      context 'with IPv4 address' do
+        let(:value) do
+          '192.168.0.1'
+        end
+
+        it 'should not record any errors' do
+          validate_each
+
+          record.errors.should be_empty
+        end
+      end
+
+      context 'with IPv6 address' do
+        let(:value) do
+          '::1'
+        end
+
+        it 'should not record any errors' do
+          validate_each
+
+          record.errors.should be_empty
+        end
+      end
+
+      context 'with IPv4 range' do
+        let(:value) do
+          '127.0.0.1/8'
+        end
+
+        it 'should record error' do
+          validate_each
+
+          record.errors[attribute].should include("#{error} and not an IPv4 address range in CIDR or netmask notation")
+        end
+      end
+
+      context 'with IPv6 range' do
+        let(:value) do
+          '3ffe:505:2::1/48'
+        end
+
+        it 'should record error' do
+          validate_each
+
+          record.errors[attribute].should include("#{error} and not an IPv6 address range in CIDR or netmask notation")
+        end
+      end
+
+      context 'without IPv4 or IPv6 address' do
+        let(:value) do
+          'localhost'
+        end
+
+        it 'should record error' do
+          validate_each
+
+          record.errors[attribute].should include(error)
+        end
+      end
+
+    end
+
+    context 'without value' do
+      let(:value) do
+        nil
+      end
+
+      it 'should record error on attribute' do
+        validate_each
+
+        record.errors[attribute].should include(error)
+      end
+    end
+  end
+end

data/spec/app/validators/nil_validator_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe NilValidator do
+  subject(:nil_validator) do
+    described_class.new(
+        :attributes => attributes
+    )
+  end
+
+  let(:attribute) do
+    :nil_thing
+  end
+
+  let(:attributes) do
+    [
+        attribute
+    ]
+  end
+
+  context '#validate_each' do
+    subject(:validate_each) do
+      nil_validator.validate_each(record, attribute, value)
+    end
+
+    let(:record) do
+      record_class.new
+    end
+
+    let(:record_class) do
+      # capture attribute for Class.new scope
+      attribute = self.attribute
+
+      Class.new do
+        include ActiveModel::Validations
+
+        #
+        # Validations
+        #
+
+        validates attribute,
+                  :nil => true
+      end
+    end
+
+    context 'with value' do
+      let(:value) do
+        ''
+      end
+
+      it 'should record error on attribute' do
+        validate_each
+
+        record.errors[attribute].should include('must be nil')
+      end
+    end
+
+    context 'without value' do
+      let(:value) do
+        nil
+      end
+
+      it 'should not record any error' do
+        validate_each
+
+        record.errors.should be_empty
+      end
+    end
+  end
+end

data/spec/app/validators/parameters_validator_spec.rb

@@ -0,0 +1,342 @@
+require 'spec_helper'
+
+describe ParametersValidator do
+  subject(:parameters_validator) do
+    described_class.new(
+        :attributes => attributes
+    )
+  end
+
+  let(:attribute) do
+    :params
+  end
+
+  let(:attributes) do
+    attribute
+  end
+
+  let(:element) do
+    []
+  end
+
+  let(:index) do
+    rand(100)
+  end
+
+  let(:type_signature_sentence) do
+    'Valid parameters are an Array<Array(String, String)>.'
+  end
+
+  context 'CONSTANTS' do
+    it 'should define TYPE_SIGNATURE_SENTENCE' do
+      described_class::TYPE_SIGNATURE_SENTENCE.should == type_signature_sentence
+    end
+  end
+
+  context '#error_at' do
+    subject(:error_at) do
+      parameters_validator.send(
+          :error_at,
+          :element => element,
+          :index => index,
+          :prefix => prefix
+      )
+    end
+
+    let(:prefix) do
+      'has a prefix'
+    end
+
+    it 'should include prefix' do
+      error_at.should include(prefix)
+    end
+
+    it 'should include location_clause in same sentence as prefix' do
+      location_clause = parameters_validator.send(
+          :location_clause,
+          :element => element,
+          :index => index
+      )
+
+      error_at.should include("#{prefix} #{location_clause}.")
+    end
+
+    it 'should include TYPE_SIGNATURE_SENTENCE' do
+      error_at.should include(type_signature_sentence)
+    end
+  end
+
+  context '#length_error_at' do
+    subject(:length_error_at) do
+      parameters_validator.send(
+          :length_error_at,
+          :element => element,
+          :extreme => extreme,
+          :index => index
+      )
+    end
+
+    let(:extreme) do
+      [:few, :many].sample
+    end
+
+    it 'should include extreme in prefix' do
+      parameters_validator.should_receive(:error_at) do |*args|
+        options = args.first
+        options[:prefix].should include(extreme.to_s)
+      end
+
+      length_error_at
+    end
+  end
+
+  context '#location_clause' do
+    subject(:location_clause) do
+      parameters_validator.send(
+          :location_clause,
+          :element => element,
+          :index => index
+      )
+    end
+
+    it 'should include numerical index' do
+      location_clause.should include("at index #{index}")
+    end
+
+    it 'should include inspect of element' do
+      location_clause.should include(element.inspect)
+    end
+  end
+
+  context '#validate_each' do
+    subject(:errors) do
+      record.errors[attribute]
+    end
+
+    def validate_each
+      parameters_validator.validate_each(record, attribute, value)
+    end
+
+    let(:record) do
+      Object.new.tap { |object|
+        object.extend ActiveModel::Validations
+      }
+    end
+
+    context 'with Array' do
+      let(:value) do
+        []
+      end
+
+      context 'element' do
+        let(:value) do
+          [element]
+        end
+
+        context 'with Array' do
+          let(:element) do
+            []
+          end
+
+          context 'with length < 2' do
+            let(:element) do
+              []
+            end
+
+            it 'should call #length_error_at with :extreme => :few' do
+              parameters_validator.should_receive(:length_error_at).with(
+                  hash_including(
+                      :extreme => :few
+                  )
+              )
+
+              validate_each
+            end
+
+            it 'should record error' do
+              validate_each
+
+              errors.should_not be_empty
+            end
+          end
+
+          context 'with length > 2' do
+            let(:element) do
+              ['', '', '']
+            end
+
+            it 'should call #length_error_at with :extreme => :many' do
+              parameters_validator.should_receive(:length_error_at).with(
+                  hash_including(
+                      :extreme => :many
+                  )
+              )
+
+              validate_each
+            end
+
+            it 'should record error' do
+              validate_each
+
+              errors.should_not be_empty
+            end
+          end
+
+          context 'with length == 2' do
+            let(:element) do
+              [parameter_name, parameter_value]
+            end
+
+            let(:parameter_name) do
+              'parameter_name'
+            end
+
+            let(:parameter_value) do
+              'parameter_value'
+            end
+
+            context 'parameter name' do
+              context 'with String' do
+                context 'with blank' do
+                  let(:parameter_name) do
+                    ''
+                  end
+
+                  it 'should call error_at with blank parameter name prefix' do
+                    parameters_validator.should_receive(:error_at).with(
+                        hash_including(
+                          :prefix => 'has blank parameter name'
+                        )
+                    )
+
+                    validate_each
+                  end
+
+                  it 'should record error' do
+                    validate_each
+
+                    errors.should_not be_empty
+                  end
+                end
+
+                context 'without blank' do
+                  let(:parameter_name) do
+                    'parameter_name'
+                  end
+
+                  it 'should not record error' do
+                    validate_each
+
+                    errors.should be_blank
+                  end
+                end
+              end
+
+              context 'without String' do
+                let(:parameter_name) do
+                  :parameter_name
+                end
+
+                it 'should call error_at with non-String prefix' do
+                  parameters_validator.should_receive(:error_at).with(
+                      hash_including(
+                          :prefix => "has non-String parameter name (#{parameter_name.inspect})"
+                      )
+                  )
+
+                  validate_each
+                end
+
+                it 'should record error' do
+                  validate_each
+
+                  errors.should_not be_empty
+                end
+              end
+            end
+
+            context 'parameter value' do
+              context 'with String' do
+                let(:parameter_value) do
+                  'parameter_value'
+                end
+
+                it 'should not record error' do
+                  validate_each
+
+                  errors.should be_blank
+                end
+              end
+
+              context 'without String' do
+                let(:parameter_value) do
+                  0
+                end
+
+                it 'should call error_at with non-String prefix' do
+                  parameters_validator.should_receive(:error_at).with(
+                      hash_including(
+                          :prefix => "has non-String parameter value (#{parameter_value.inspect})"
+                      )
+                  )
+
+                  validate_each
+                end
+
+                it 'should record error' do
+                  validate_each
+
+                  errors.should_not be_empty
+                end
+              end
+            end
+          end
+        end
+
+        context 'without Array' do
+          let(:element) do
+            {}
+          end
+
+          it 'should use #error_at with has non-Array for prefix' do
+            parameters_validator.should_receive(:error_at).with(
+                hash_including(
+                    :prefix => 'has non-Array'
+                )
+            )
+
+            validate_each
+          end
+
+          it 'should record error' do
+            validate_each
+
+            errors.should_not be_empty
+          end
+        end
+      end
+    end
+
+    context 'without Array' do
+      let(:value) do
+        ''
+      end
+
+      before(:each) do
+        validate_each
+      end
+
+      it 'should error that attribute is not an array' do
+        errors.any? { |error|
+          error.include? 'is not an Array.'
+        }.should be_true
+      end
+
+      it 'should include TYPE_SIGNATURE_SENTENCE' do
+        errors.each do |error|
+          error.should include(type_signature_sentence)
+        end
+      end
+    end
+  end
+end