chef-attribute-validator 0.1.0

data/test/fixtures/rules_empty.rb

@@ -0,0 +1,2 @@
+# Empty attributes file
+default['attribute-validator']['rules'] = {}

data/test/fixtures/rules_missing_path.rb

@@ -0,0 +1 @@
+default['attribute-validator']['rules']['test-missing-path']['enabled'] = true

data/test/fixtures/rules_no_check.rb

@@ -0,0 +1 @@
+default['attribute-validator']['rules']['test-no-check-rule']['path'] = '/*'

data/test/fixtures/rules_type_and_min_children.rb

@@ -0,0 +1,3 @@
+default['attribute-validator']['rules']['test-type-and-min-children-rule']['path'] = '/*'
+default['attribute-validator']['rules']['test-type-and-min-children-rule']['type'] = 'array'
+default['attribute-validator']['rules']['test-type-and-min-children-rule']['min_children'] = 1

data/test/fixtures/rules_type_check.rb

@@ -0,0 +1,2 @@
+default['attribute-validator']['rules']['test-type-rule']['path'] = '/*'
+default['attribute-validator']['rules']['test-type-rule']['type'] = 'string'

data/test/unit/attr_set_spec.rb

@@ -0,0 +1,55 @@
+require_relative './spec_helper'
+
+describe Chef::Attribute::Validator::AttributeSet do
+
+  let(:node) { CAVHelper.load_fixture_attributes('attr_set') }
+
+  describe "non-wildcard, non-array slashpath access" do
+    context "when the element exists" do
+      it "should be able to run /one" do
+        expect { Chef::Attribute::Validator::AttributeSet.new(node, '/one') }.not_to raise_error
+      end
+      let(:ats) { Chef::Attribute::Validator::AttributeSet.new(node, '/one') }
+      it "should be able to find /one" do
+        expect(ats.size).to eq 1
+        expect(ats.has_key?('/one')).to be_true
+        expect(ats['/one']).to eq 1
+      end
+    end
+
+    context "when the element does not exist" do
+      it "should be able to run /nope" do
+        expect { Chef::Attribute::Validator::AttributeSet.new(node, '/nope') }.not_to raise_error
+      end
+      let(:ats) { Chef::Attribute::Validator::AttributeSet.new(node, '/nope') }
+      it "should not be able to find /nope" do
+        expect(ats.size).to eq 0
+      end        
+    end
+  end
+
+  describe "non-wildcard, array slashpath access" do
+    context "when the element exists" do
+      it "should be able to run /cats/1" do
+        expect { Chef::Attribute::Validator::AttributeSet.new(node, '/cats/1') }.not_to raise_error
+      end
+      let(:ats) { Chef::Attribute::Validator::AttributeSet.new(node, '/cats/1') }
+      it "should be able to find /cats/1" do
+        expect(ats.size).to eq 1
+        expect(ats.has_key?('/cats/1')).to be_true
+        expect(ats['/cats/1']).to eq 'tabby'
+      end
+    end
+
+    context "when the element does not exist" do
+      it "should be able to run /cats/23" do
+        expect { Chef::Attribute::Validator::AttributeSet.new(node, '/cats/23') }.not_to raise_error
+      end
+      let(:ats) { Chef::Attribute::Validator::AttributeSet.new(node, '/cats/23') }
+      it "should not be able to find /cats/23" do
+        expect(ats.size).to eq 0
+      end        
+    end
+  end
+
+end

data/test/unit/check_child_count_spec.rb

@@ -0,0 +1,109 @@
+require_relative './spec_helper'
+
+# Verify that the 'type' check works correctly
+
+
+describe "'min_children' check" do
+
+  let(:node) { CAVHelper.load_fixture_attributes('check_child_count') }
+  let(:av) { Chef::Attribute::Validator.new(node) }
+
+  it "should be present in the Check registry" do
+    expect(Chef::Attribute::Validator::Check.list_check_types).to include('min_children')
+  end
+
+  it "should violate on nil" do
+    expect(av.validate_rule('min-nil')).not_to be_empty
+  end
+
+  it "should violate on string" do
+    expect(av.validate_rule('min-string')).not_to be_empty
+  end
+
+  context "when examining an array" do
+    it "should not violate when min is 0 and array is empty" do
+      expect(av.validate_rule('min-array-empty-zero')).to be_empty
+    end
+
+    it "should violate when min is 1 and array is empty" do
+      expect(av.validate_rule('min-array-empty-one')).not_to be_empty
+    end
+
+    it "should violate when min is 2 and array is 1" do
+      expect(av.validate_rule('min-array-one-two')).not_to be_empty
+    end    
+  end
+
+  context "when examining a hash" do
+    it "should not violate when min is 0 and hash is empty" do
+      expect(av.validate_rule('min-hash-empty-zero')).to be_empty
+    end
+
+    it "should violate when min is 1 and hash is empty" do
+      expect(av.validate_rule('min-hash-empty-one')).not_to be_empty
+    end
+
+    it "should violate when min is 2 and hash is 1" do
+      expect(av.validate_rule('min-hash-one-two')).not_to be_empty
+    end    
+  end
+
+end
+
+describe "'max_children' check" do
+
+  let(:node) { CAVHelper.load_fixture_attributes('check_child_count') }
+  let(:av) { Chef::Attribute::Validator.new(node) }
+
+  it "should be present in the Check registry" do
+    expect(Chef::Attribute::Validator::Check.list_check_types).to include('max_children')
+  end
+
+  it "should violate on nil" do
+    expect(av.validate_rule('max-nil')).not_to be_empty
+  end
+
+  it "should violate on string" do
+    expect(av.validate_rule('max-string')).not_to be_empty
+  end
+
+  context "when examining an array" do
+    it "should not violate when max is 0 and array is empty" do
+      expect(av.validate_rule('max-array-empty-zero')).to be_empty
+    end
+
+    it "should violate when max is 0 and array is 1" do
+      expect(av.validate_rule('max-array-zero-one')).not_to be_empty
+    end
+
+    it "should violate when max is 1 and array is 2" do
+      expect(av.validate_rule('max-array-one-two')).not_to be_empty
+    end    
+
+    it "should not violate when max is 2 and array is 2" do
+      expect(av.validate_rule('max-array-two-two')).to be_empty
+    end
+
+  end
+
+  context "when examining a hash" do
+    it "should not violate when max is 0 and hash is empty" do
+      expect(av.validate_rule('max-hash-empty-zero')).to be_empty
+    end
+
+    it "should violate when max is 0 and hash is one" do
+      expect(av.validate_rule('max-hash-zero-one')).not_to be_empty
+    end
+
+    it "should violate when max is 1 and hash is 2" do
+      expect(av.validate_rule('max-hash-one-two')).not_to be_empty
+    end    
+
+    it "should not violate when max is 2 and hash is 2" do
+      expect(av.validate_rule('max-hash-two-two')).to be_empty
+    end    
+
+  end
+
+
+end

data/test/unit/check_looks_like_spec.rb

@@ -0,0 +1,106 @@
+require_relative './spec_helper'
+
+# Verify that the 'looks_like' check works correctly
+
+
+describe "'looks_like' check" do
+
+  describe "check registry" do
+    it "should be present in the Check registry" do
+      expect(Chef::Attribute::Validator::Check.list_check_types).to include('looks_like')
+    end
+  end
+
+  describe "check_arg checks" do
+    it "should accept 'ip'" do
+      node = CAVHelper.load_fixture_attributes('check_looks_like_arg_ip')
+      expect { Chef::Attribute::Validator.new(node) }.not_to raise_error
+    end
+    it "should accept 'url'" do
+      node = CAVHelper.load_fixture_attributes('check_looks_like_arg_url')
+      expect { Chef::Attribute::Validator.new(node) }.not_to raise_error
+    end
+    it "should reject 'your mom'" do
+      node = CAVHelper.load_fixture_attributes('check_looks_like_arg_your_mom')
+      expect { Chef::Attribute::Validator.new(node) }.to raise_error
+    end
+    it "should reject a regex" do
+      node = CAVHelper.load_fixture_attributes('check_looks_like_arg_regex')
+      expect { Chef::Attribute::Validator.new(node) }.to raise_error
+    end
+  end
+
+  context "when the mode is 'ip'" do
+    let(:node) { CAVHelper.load_fixture_attributes('check_looks_like_ip') }
+    let(:av) { Chef::Attribute::Validator.new(node) }
+
+    it "should not violate on missing" do
+      expect(av.validate_rule('ip-missing')).to be_empty
+    end
+
+    it "should not violate on nil" do
+      expect(av.validate_rule('ip-nil')).to be_empty
+    end
+
+    it "should violate on 1234.123.1.1" do
+      expect(av.validate_rule('ip-malformed')).not_to be_empty
+    end
+
+    it "should violate on 300.300.300.1" do
+      expect(av.validate_rule('ip-deranged')).not_to be_empty
+    end
+
+    it "should violate on 123.123.123" do
+      expect(av.validate_rule('ip-3not4')).not_to be_empty
+    end
+
+    it "should not violate on 1.1.1.1" do
+      expect(av.validate_rule('ip-allones')).to be_empty
+    end
+
+    it "should not violate on 1.1.1.1/24" do
+      expect(av.validate_rule('ip-slash24')).to be_empty
+    end
+
+    it "should not violate on 255.255.255.255" do
+      expect(av.validate_rule('ip-merryxmas')).to be_empty
+    end
+
+    it "should not violate on ::" do
+      expect(av.validate_rule('ip-emptyv6')).to be_empty
+    end
+  end
+
+  context "when the mode is 'url'" do
+    let(:node) { CAVHelper.load_fixture_attributes('check_looks_like_url') }
+    let(:av) { Chef::Attribute::Validator.new(node) }
+
+    it "should not violate on missing" do
+      expect(av.validate_rule('url-missing')).to be_empty
+    end
+
+    it "should not violate on nil" do
+      expect(av.validate_rule('url-nil')).to be_empty
+    end
+
+    it "should not violate on 'http://wwwwwwww.jodi.org'" do
+      expect(av.validate_rule('url-http-basic')).to be_empty
+    end
+
+    it "should not violate on 'http://example.com/'" do
+      expect(av.validate_rule('url-http-trailing-slash')).to be_empty
+    end
+
+    it "should not violate on 'http://example.com:8080/'" do
+      expect(av.validate_rule('url-http-port')).to be_empty
+    end
+
+    it "should not violate on 'http://localhost'" do
+      expect(av.validate_rule('url-http-localhost')).to be_empty
+    end
+
+  end
+
+
+
+end

data/test/unit/check_regex_spec.rb

@@ -0,0 +1,62 @@
+require_relative './spec_helper'
+
+# Verify that the 'regex' check works correctly
+
+
+describe "'regex' check" do
+
+  describe "check registry" do
+    it "should be present in the Check registry" do
+      expect(Chef::Attribute::Validator::Check.list_check_types).to include('regex')
+    end
+  end
+
+  describe "check_arg checks" do
+    it "should accept a // literal regex" do
+      node = CAVHelper.load_fixture_attributes('check_regex_literal')
+      expect { Chef::Attribute::Validator.new(node) }.not_to raise_error
+    end
+    it "should accept a Regexp object" do
+      node = CAVHelper.load_fixture_attributes('check_regex_object')
+      expect { Chef::Attribute::Validator.new(node) }.not_to raise_error
+    end
+    it "should reject a string" do
+      node = CAVHelper.load_fixture_attributes('check_regex_string')
+      expect { Chef::Attribute::Validator.new(node) }.to raise_error
+    end
+    it "should reject a nil regex" do
+      node = CAVHelper.load_fixture_attributes('check_regex_nil')
+      expect { Chef::Attribute::Validator.new(node) }.to raise_error
+    end
+  end
+
+  describe "assorted regexes" do
+    let(:node) { CAVHelper.load_fixture_attributes('check_regex_assorted') }
+    let(:av) { Chef::Attribute::Validator.new(node) }
+
+    it "/^$/ should not violate on an empty string" do
+      expect(av.validate_rule('empty-empty')).to be_empty
+    end
+
+    it "/foo/ should not violate on foo" do
+      expect(av.validate_rule('foo-foo')).to be_empty
+    end
+
+    it "/foo/ should not violate on food" do
+      expect(av.validate_rule('foo-food')).to be_empty
+    end
+
+    it "/foo/ should violate on victuals" do
+      expect(av.validate_rule('foo-victuals')).not_to be_empty
+    end
+
+    it "/^(?!foo)/ should not violate on bar" do
+      expect(av.validate_rule('not-foo-bar')).to be_empty
+    end
+
+    it "/^(?!foo)/ should violate on foo" do
+      expect(av.validate_rule('not-foo-foo')).not_to be_empty
+    end      
+  end
+
+end

data/test/unit/check_required_spec.rb

@@ -0,0 +1,106 @@
+require_relative './spec_helper'
+
+# Verify that the 'required' check works correctly
+
+describe "'required' check" do
+
+  describe "check registry" do
+    it "should be present in the Check registry" do
+      expect(Chef::Attribute::Validator::Check.list_check_types).to include('required')
+    end
+  end
+
+  describe "check_arg checks" do
+    it "should accept true" do
+      node = CAVHelper.load_fixture_attributes('check_required_true')
+      expect { Chef::Attribute::Validator.new(node) }.not_to raise_error
+    end
+    it "should accept false" do
+      node = CAVHelper.load_fixture_attributes('check_required_false')
+      expect { Chef::Attribute::Validator.new(node) }.not_to raise_error
+    end
+    it "should reject 0" do
+      node = CAVHelper.load_fixture_attributes('check_required_zero')
+      expect { Chef::Attribute::Validator.new(node) }.to raise_error
+    end
+  end
+
+  context "when required, but the attribute is missing" do
+    let(:node) { CAVHelper.load_fixture_attributes('check_required_assorted') }
+    let(:av) { Chef::Attribute::Validator.new(node) }
+
+    it "should violate when the attribute is missing, shallow" do
+      expect(av.validate_rule('missing-shallow')).not_to be_empty
+    end
+
+    it "should violate when the attribute is missing, deep" do
+      expect(av.validate_rule('missing-deep')).not_to be_empty
+    end
+  end
+
+  context "when required, but the value is missing" do
+    let(:node) { CAVHelper.load_fixture_attributes('check_required_assorted') }
+    let(:av) { Chef::Attribute::Validator.new(node) }
+
+    it "should violate when the value is nil" do
+      expect(av.validate_rule('value-nil')).not_to be_empty
+    end
+
+    it "should violate when the value is an empty string" do
+      expect(av.validate_rule('value-empty-string')).not_to be_empty
+    end
+
+    it "should violate when the value is an empty array" do
+      expect(av.validate_rule('value-empty-array')).not_to be_empty
+    end
+
+    it "should violate when the value is an empty hash" do
+      expect(av.validate_rule('value-empty-hash')).not_to be_empty
+    end
+  end
+
+  context "when required, and a value is present" do
+    let(:node) { CAVHelper.load_fixture_attributes('check_required_assorted') }
+    let(:av) { Chef::Attribute::Validator.new(node) }
+
+    it "should not violate when the value is a string " do
+      expect(av.validate_rule('value-present-string')).to be_empty
+    end
+
+    it "should not violate when the value is false " do
+      expect(av.validate_rule('value-present-false')).to be_empty
+    end
+
+    it "should not violate when the value is zero " do
+      expect(av.validate_rule('value-present-zero')).to be_empty
+    end
+
+    it "should not violate when the value is a non-empty array " do
+      expect(av.validate_rule('value-present-array')).to be_empty
+    end
+
+    it "should not violate when the value is a non-empty hash" do
+      expect(av.validate_rule('value-present-hash')).to be_empty
+    end
+  end
+
+  context "when not required, but the value is present" do
+    let(:node) { CAVHelper.load_fixture_attributes('check_required_assorted') }
+    let(:av) { Chef::Attribute::Validator.new(node) }
+    
+    it "should not violate when the value is a string" do
+      expect(av.validate_rule('optional-present-string')).to be_empty
+    end
+  end
+
+  context "when not required, but the attribute is missing" do
+    let(:node) { CAVHelper.load_fixture_attributes('check_required_assorted') }
+    let(:av) { Chef::Attribute::Validator.new(node) }
+    
+    it "should not violate when the attribute is missing" do
+      expect(av.validate_rule('optional-missing')).to be_empty
+    end
+  end
+  
+
+end