chef-attribute-validator 0.1.0

data/lib/chef-attribute-validator/checks/max_children.rb

@@ -0,0 +1,37 @@
+class Chef
+  class Attribute
+    class Validator
+      class Check
+        class MaxChildren < Check
+
+          register_check('max_children', MaxChildren)
+
+          def validate_check_arg
+            unless check_arg.kind_of?(::Fixnum)
+              raise "Bad 'max_children' check argument '#{check_arg}' for rule '#{rule_name}' - expected an integer."
+            end
+          end
+
+          def check(attrset)
+            violations = []
+
+            # So if you say there must be at most one child, and the attributes don't even exist, is that a violation?
+            # I say no; if you care if the attributes exist, use required.
+            attrset.each do |path, value|
+              if value.kind_of?(Array) || value.kind_of?(Mash)
+                if value.size > check_arg
+                  violations.push Chef::Attribute::Validator::Violation.new(rule_name, path, "Attribute should have at most #{check_arg} child values, but has #{value.size}")
+                end
+              else
+                violations.push Chef::Attribute::Validator::Violation.new(rule_name, path, "Attribute should have at most #{check_arg} child values, but is of the wrong type - should be hash or array.")
+              end
+            end
+            violations
+
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/chef-attribute-validator/checks/min_children.rb

@@ -0,0 +1,37 @@
+class Chef
+  class Attribute
+    class Validator
+      class Check
+        class MinChildren < Check
+
+          register_check('min_children', MinChildren)
+
+          def validate_check_arg
+            unless check_arg.kind_of?(::Fixnum)
+              raise "Bad 'min_children' check argument '#{check_arg}' for rule '#{rule_name}' - expected an integer."
+            end
+          end
+
+          def check(attrset)
+            violations = []
+
+            # So if you say there must be at least one child, and the attributes don't even exist, is that a violation?
+            # I say no; if you can if the attributes exist, use required.
+            attrset.each do |path, value|
+              if value.kind_of?(Array) || value.kind_of?(Mash)
+                if value.size < check_arg
+                  violations.push Chef::Attribute::Validator::Violation.new(rule_name, path, "Attribute should have at least #{check_arg} child values, but has only #{value.size}")
+                end
+              else
+                violations.push Chef::Attribute::Validator::Violation.new(rule_name, path, "Attribute should have at least #{check_arg} child values, but is of the wrong type - should be hash or array.")
+              end
+            end
+            violations
+
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/chef-attribute-validator/checks/regex.rb

@@ -0,0 +1,31 @@
+class Chef
+  class Attribute
+    class Validator
+      class Check
+        class Regex < Check
+
+          register_check('regex', Regex)
+
+          def validate_check_arg
+            unless check_arg.kind_of?(Regexp)
+              raise "Bad 'regex' check argument '#{check_arg}' for rule '#{rule_name}' - expected a Regexp"
+            end
+          end
+
+          def check(attrset)
+            violations = []
+            attrset.each do |path, value|
+              if val_scalar?(value)
+                unless check_arg.match(value)
+                  violations.push Chef::Attribute::Validator::Violation.new(rule_name, path, "Attribute's value is '#{value}', which does not match regex '#{check_arg}'")
+                end
+              end
+            end
+            violations
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/chef-attribute-validator/checks/required.rb

@@ -0,0 +1,42 @@
+class Chef
+  class Attribute
+    class Validator
+      class Check
+        class Required < Check
+
+          register_check('required', Required)
+
+          def validate_check_arg
+            unless check_arg.kind_of?(TrueClass) || check_arg.kind_of?(FalseClass)
+              raise "Bad 'required' check argument '#{check_arg}' for rule '#{rule_name}' - expected one of true,false"
+            end
+          end
+    
+          def check(attrset)
+            violations = []
+            if check_arg # If we are not required, we're effectively a no-op
+              if attrset.empty?
+                violations.push Chef::Attribute::Validator::Violation.new(rule_name, path_spec, "No attributes exist for path '#{path_spec}', but this rule says it is required.")
+              else
+                attrset.each do |path, value|
+                  if val_scalar?(value)
+                    if value.nil? 
+                      violations.push Chef::Attribute::Validator::Violation.new(rule_name, path, "Attributes value is nil, but is required.")
+                    elsif value == ""
+                      violations.push Chef::Attribute::Validator::Violation.new(rule_name, path, "Attributes value is '', but is required.")
+                    end
+                  else
+                    if value.size == 0
+                      violations.push Chef::Attribute::Validator::Violation.new(rule_name, path, "Attribute has no children, but is required.")       
+                    end
+                  end
+                end
+              end
+            end
+            violations
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef-attribute-validator/checks/type.rb

@@ -0,0 +1,48 @@
+class Chef
+  class Attribute
+    class Validator
+      class Check
+        class Type < Check
+
+          register_check('type', Type)
+
+          def validate_check_arg            
+            expected = [
+                        'string',
+                        'number',
+                        'boolean',
+                        'hash',
+                        'array',
+                       ]
+       
+            unless expected.include?(check_arg)
+              raise "Bad 'type' check argument '#{checkarg}' for rule '#{rule_name}' - expected one of #{expected.join(',')}"
+            end
+          end
+
+          def check(attrset)
+            violations = []
+
+            klasses = {
+              'string'  => [ String ],
+              'number'  => [ Integer, Float ],
+              'boolean' => [ TrueClass, FalseClass ],
+              'array'   => [ Array ],
+              'hash'    => [ Mash ],
+              'nil'     => [ NilClass ],
+            }
+
+            attrset.each do |path, value|
+              unless klasses[check_arg].any? {|k| value.kind_of?(k) }
+                violations.push Chef::Attribute::Validator::Violation.new(rule_name, path, "Attribute's value is '#{value}', which does not appear to be the right type - expected '#{check_arg}'")
+              end
+            end
+
+            violations
+          end
+          
+        end
+      end
+    end
+  end
+end

data/lib/chef-attribute-validator/rule.rb

@@ -0,0 +1,54 @@
+require_relative './attribute_set.rb'
+require_relative './check.rb'
+
+class Chef
+  class Attribute
+    class Validator
+      class Rule
+        attr_accessor :name
+        attr_accessor :path
+        attr_accessor :checks
+        attr_accessor :enabled
+          
+        def initialize (a_name, a_def)
+          @name = a_name
+          @path = a_def['path']
+
+          unless path
+            raise "Missing 'path' attribute for attribute validation rule '#{name}'"
+          end
+
+          @enabled = true
+          if a_def.has_key?('enabled')
+            @enabled = a_def['enabled']
+          end
+          
+          @checks = {}
+          a_def.keys.reject { |ck| %w(path enabled).include? ck }.sort.each do |check_name|
+            checks[check_name] = Check.make(check_name, self, a_def[check_name])
+          end
+        end
+
+        def apply(node)
+          violations = []
+          if enabled
+            attrset = Chef::Attribute::Validator::AttributeSet.new(node, path)
+            checks.each do |check_name, check_obj|
+              violations += check_obj.check(attrset)
+            end
+          end
+          violations
+        end
+
+        def check_count
+          checks.keys.size
+        end
+        
+        def has_check?(check_name)
+          checks.has_key?(check_name)      
+        end
+
+      end
+    end
+  end
+end

data/lib/chef-attribute-validator/version.rb

@@ -0,0 +1,7 @@
+class Chef
+  class Attribute
+    class Validator
+      VERSION = "0.1.0"
+    end
+  end
+end

data/lib/chef-attribute-validator/violation.rb

@@ -0,0 +1,17 @@
+class Chef
+  class Attribute
+    class Validator
+      class Violation
+        attr_reader :rule_name
+        attr_reader :path
+        attr_reader :message
+
+        def initialize(a_rule_name, a_path, a_message)
+          @rule_name = a_rule_name
+          @path = a_path
+          @message = a_message
+        end
+      end
+    end
+  end
+end

data/test/fixtures/attr_set.rb

@@ -0,0 +1,10 @@
+default['one'] = 1
+default['two'] = 2
+default['deeper']['one'] = 1
+default['deeper']['deeper_yet']['one'] = 1
+default['cats'] = ['maine coon', 'tabby', 'siamese']
+default['rats'] = ['Nicodemus', 'Ratatouille']
+default['array_buildup'] = []
+default['array_buildup'] = [ 'a' ]
+default['array_buildup'] = [ 'b' ]
+

data/test/fixtures/check_child_count.rb

@@ -0,0 +1,104 @@
+rules = default['attribute-validator']['rules']
+
+default['nil'] = nil
+default['string'] = "pants"
+
+default['array']['empty'] = []
+default['array']['one'] = [ 'mellow gold' ]
+default['array']['two'] = [ 'mellow gold', 'odelay' ]
+default['array']['fifty'] = ['a'] * 50
+
+default['hash']['empty'] = {}
+default['hash']['one'] = { 'a' => 1 }
+default['hash']['two'] = { 'a' => 1, 'b' => 2 }
+
+rules['min-nil'] = {
+  'path' => '/nil',
+  'min_children' => 1
+}
+
+rules['min-string'] = {
+  'path' => '/string',
+  'min_children' => 1
+}
+
+rules['min-array-empty-zero'] = {
+  'path' => '/array/empty',
+  'min_children' => 0
+}
+
+rules['min-array-empty-one'] = {
+  'path' => '/array/empty',
+  'min_children' => 1
+}
+
+rules['min-array-one-two'] = {
+  'path' => '/array/one',
+  'min_children' => 2
+}
+
+rules['min-hash-empty-zero'] = {
+  'path' => '/hash/empty',
+  'min_children' => 0
+}
+
+rules['min-hash-empty-one'] = {
+  'path' => '/hash/empty',
+  'min_children' => 1
+}
+
+rules['min-hash-one-two'] = {
+  'path' => '/hash/one',
+  'min_children' => 2
+}
+
+rules['max-nil'] = {
+  'path' => '/nil',
+  'max_children' => 1
+}
+
+rules['max-string'] = {
+  'path' => '/string',
+  'max_children' => 1
+}
+
+rules['max-array-empty-zero'] = {
+  'path' => '/array/empty',
+  'max_children' => 0
+}
+
+rules['max-array-zero-one'] = {
+  'path' => '/array/one',
+  'max_children' => 0
+}
+
+rules['max-array-one-two'] = {
+  'path' => '/array/two',
+  'max_children' => 1
+}
+
+rules['max-array-two-two'] = {
+  'path' => '/array/two',
+  'max_children' => 2
+}
+
+rules['max-hash-empty-zero'] = {
+  'path' => '/hash/empty',
+  'max_children' => 0
+}
+
+rules['max-hash-zero-one'] = {
+  'path' => '/hash/one',
+  'max_children' => 0
+}
+
+rules['max-hash-one-two'] = {
+  'path' => '/hash/two',
+  'max_children' => 1
+}
+
+rules['max-hash-two-two'] = {
+  'path' => '/hash/two',
+  'max_children' => 2
+}
+

data/test/fixtures/check_looks_like_arg_ip.rb

@@ -0,0 +1,6 @@
+rules = default['attribute-validator']['rules']
+rules['check-looks-like-arg-ip'] = {
+  'path' =>  '/nil',
+  'looks_like' => 'ip',
+}
+

data/test/fixtures/check_looks_like_arg_regex.rb

@@ -0,0 +1,6 @@
+rules = default['attribute-validator']['rules']
+rules['check-looks-like-arg-regex'] = {
+  'path' =>  '/nil',
+  'looks_like' => /foo/,
+}
+

data/test/fixtures/check_looks_like_arg_url.rb

@@ -0,0 +1,6 @@
+rules = default['attribute-validator']['rules']
+rules['check-looks-like-arg-url'] = {
+  'path' =>  '/nil',
+  'looks_like' => 'url',
+}
+

data/test/fixtures/check_looks_like_arg_your_mom.rb

@@ -0,0 +1,6 @@
+rules = default['attribute-validator']['rules']
+rules['check-looks-like-arg-your-mom'] = {
+  'path' =>  '/nil',
+  'looks_like' => 'your mom',
+}
+

data/test/fixtures/check_looks_like_ip.rb

@@ -0,0 +1,57 @@
+
+default['nil'] = nil
+default['malformed'] = '1234.123.123.123'
+default['merryxmas'] = '255.255.255.255'
+default['deranged'] = '300.300.300.1'
+default['3not4'] = '123.123.123'
+default['allones'] = '1.1.1.1'
+default['slash24'] = '1.1.1.1/24'
+
+default['v6']['empty'] = '::'
+
+rules = default['attribute-validator']['rules']
+rules['ip-nil'] = {
+  'path' =>  '/nil',
+  'looks_like' => 'ip',
+}
+
+rules['ip-missing'] = {
+  'path' =>  '/nope',
+  'looks_like' => 'ip',
+}
+
+rules['ip-malformed'] = {
+  'path' =>  '/malformed',
+  'looks_like' => 'ip',
+}
+
+rules['ip-merryxmas'] = {
+  'path' =>  '/merryxmas',
+  'looks_like' => 'ip',
+}
+
+rules['ip-deranged'] = {
+  'path' =>  '/deranged',
+  'looks_like' => 'ip',
+}
+
+rules['ip-3not4'] = {
+  'path' =>  '/3not4',
+  'looks_like' => 'ip',
+}
+
+rules['ip-allones'] = {
+  'path' =>  '/allones',
+  'looks_like' => 'ip',
+}
+
+rules['ip-slash24'] = {
+  'path' =>  '/slash24',
+  'looks_like' => 'ip',
+}
+
+
+rules['ip-emptyv6'] = {
+  'path' =>  '/v6/empty',
+  'looks_like' => 'ip',
+}