puppet 0.24.9 → 0.25.0

data/spec/unit/property.rb

@@ -1,35 +1,289 @@
-#!/usr/bin/env ruby
+#!/usr/bin/env ruby"
 
 require File.dirname(__FILE__) + '/../spec_helper'
-
 require 'puppet/property'
 
 describe Puppet::Property do
-    describe "when setting the value" do
-        it "should just set the 'should' value" do
-            @class = Class.new(Puppet::Property)
-            @class.initvars
-            @property = @class.new :resource => mock('resource')
+    before do
+        @class = Class.new(Puppet::Property) do
+            @name = :foo
+        end
+        @class.initvars
+        @provider = mock 'provider'
+        @resource = stub 'resource', :provider => @provider
+        @resource.stub_everything
+        @property = @class.new :resource => @resource
+    end
+
+    it "should be able to look up the modified name for a given value" do
+        @class.newvalue(:foo)
+        @class.value_name("foo").should == :foo
+    end
+
+    it "should be able to look up the modified name for a given value matching a regex" do
+        @class.newvalue(%r{.})
+        @class.value_name("foo").should == %r{.}
+    end
+
+    it "should be able to look up a given value option" do
+        @class.newvalue(:foo, :event => :whatever)
+        @class.value_option(:foo, :event).should == :whatever
+    end
+
+    it "should be able to specify required features" do
+        @class.should respond_to(:required_features=)
+    end
+
+    it "should always convert required features into an array of symbols" do
+        @class.required_features = %w{one two}
+        @class.required_features.should == [:one, :two]
+    end
+
+    it "should be able to shadow metaparameters" do
+        @property.must respond_to(:shadow)
+    end
+
+    describe "when shadowing metaparameters" do
+        before do
+            @shadow_class = Class.new(Puppet::Property) do
+                @name = :alias
+            end
+            @shadow_class.initvars
+        end
+
+        it "should create an instance of the metaparameter at initialization" do
+            Puppet::Type.metaparamclass(:alias).expects(:new).with(:resource => @resource)
+
+            @shadow_class.new :resource => @resource
+        end
+
+        it "should munge values using the shadow's munge method" do
+            shadow = mock 'shadow'
+            Puppet::Type.metaparamclass(:alias).expects(:new).returns shadow
+
+            shadow.expects(:munge).with "foo"
+
+            property = @shadow_class.new :resource => @resource
+            property.munge("foo")
+        end
+    end
 
-            @property.expects(:should=).with("foo")
+    describe "when defining new values" do
+        it "should define a method for each value created with a block that's not a regex" do
+            @class.newvalue(:foo) { }
+            @property.must respond_to(:set_foo)
+        end
+    end
+
+    describe "when assigning the value" do
+        it "should just set the 'should' value" do
             @property.value = "foo"
+            @property.should.must == "foo"
+        end
+
+        it "should validate each value separately" do
+            @property.expects(:validate).with("one")
+            @property.expects(:validate).with("two")
+
+            @property.value = %w{one two}
+        end
+
+        it "should munge each value separately and use any result as the actual value" do
+            @property.expects(:munge).with("one").returns :one
+            @property.expects(:munge).with("two").returns :two
+
+            # Do this so we get the whole array back.
+            @class.array_matching = :all
+
+            @property.value = %w{one two}
+            @property.should.must == [:one, :two]
+        end
+
+        it "should return any set value" do
+            (@property.value = :one).should == :one
         end
     end
 
     describe "when returning the value" do
-        before do
-            @class = Class.new(Puppet::Property)
-            @class.initvars
-            @property = @class.new :resource => mock('resource')
+        it "should return nil if no value is set" do
+            @property.should.must be_nil
         end
 
-        it "should return nil if no value is set" do
-            @property.value.should be_nil
+        it "should return the first set 'should' value if :array_matching is set to :first" do
+            @class.array_matching = :first
+            @property.should = %w{one two}
+            @property.should.must == "one"
+        end
+
+        it "should return all set 'should' values as an array if :array_matching is set to :all" do
+            @class.array_matching = :all
+            @property.should = %w{one two}
+            @property.should.must == %w{one two}
+        end
+
+        it "should default to :first array_matching" do
+            @class.array_matching.should == :first
+        end
+
+        it "should unmunge the returned value if :array_matching is set to :first" do
+            @property.class.unmunge do |v| v.to_sym end
+            @class.array_matching = :first
+            @property.should = %w{one two}
+
+            @property.should.must == :one
+        end
+
+        it "should unmunge all the returned values if :array_matching is set to :all" do
+            @property.class.unmunge do |v| v.to_sym end
+            @class.array_matching = :all
+            @property.should = %w{one two}
+
+            @property.should.must == [:one, :two]
+        end
+    end
+
+    describe "when validating values" do
+        it "should do nothing if no values or regexes have been defined" do
+            lambda { @property.should = "foo" }.should_not raise_error
+        end
+
+        it "should fail if the value is not a defined value or alias and does not match a regex" do
+            @class.newvalue(:foo)
+
+            lambda { @property.should = "bar" }.should raise_error
+        end
+
+        it "should succeeed if the value is one of the defined values" do
+            @class.newvalue(:foo)
+
+            lambda { @property.should = :foo }.should_not raise_error
+        end
+
+        it "should succeeed if the value is one of the defined values even if the definition uses a symbol and the validation uses a string" do
+            @class.newvalue(:foo)
+
+            lambda { @property.should = "foo" }.should_not raise_error
+        end
+
+        it "should succeeed if the value is one of the defined values even if the definition uses a string and the validation uses a symbol" do
+            @class.newvalue("foo")
+
+            lambda { @property.should = :foo }.should_not raise_error
+        end
+
+        it "should succeed if the value is one of the defined aliases" do
+            @class.newvalue("foo")
+            @class.aliasvalue("bar", "foo")
+
+            lambda { @property.should = :bar }.should_not raise_error
+        end
+
+        it "should succeed if the value matches one of the regexes" do
+            @class.newvalue(/./)
+
+            lambda { @property.should = "bar" }.should_not raise_error
+        end
+
+        it "should validate that all required features are present" do
+            @class.newvalue(:foo, :required_features => [:a, :b])
+
+            @provider.expects(:satisfies?).with([:a, :b]).returns true
+
+            @property.should = :foo
+        end
+
+        it "should fail if required features are missing" do
+            @class.newvalue(:foo, :required_features => [:a, :b])
+
+            @provider.expects(:satisfies?).with([:a, :b]).returns false
+
+            lambda { @property.should = :foo }.should raise_error(Puppet::Error)
         end
 
-        it "should return any set 'should' value" do
+        it "should validate that all required features are present for regexes" do
+            value = @class.newvalue(/./, :required_features => [:a, :b])
+
+            @provider.expects(:satisfies?).with([:a, :b]).returns true
+
             @property.should = "foo"
-            @property.value.should == "foo"
+        end
+    end
+
+    describe "when munging values" do
+        it "should do nothing if no values or regexes have been defined" do
+            @property.munge("foo").should == "foo"
+        end
+
+        it "should return return any matching defined values" do
+            @class.newvalue(:foo)
+            @property.munge("foo").should == :foo
+        end
+
+        it "should return any matching aliases" do
+            @class.newvalue(:foo)
+            @class.aliasvalue(:bar, :foo)
+            @property.munge("bar").should == :foo
+        end
+
+        it "should return the value if it matches a regex" do
+            @class.newvalue(/./)
+            @property.munge("bar").should == "bar"
+        end
+
+        it "should return the value if no other option is matched" do
+            @class.newvalue(:foo)
+            @property.munge("bar").should == "bar"
+        end
+    end
+
+    describe "when syncing the 'should' value" do
+        it "should set the value" do
+            @class.newvalue(:foo)
+            @property.should = :foo
+            @property.expects(:set).with(:foo)
+            @property.sync
+        end
+    end
+
+    describe "when setting a value" do
+        it "should catch exceptions and raise Puppet::Error" do
+            @class.newvalue(:foo) { raise "eh" }
+            lambda { @property.set(:foo) }.should raise_error(Puppet::Error)
+        end
+
+        describe "that was defined without a block" do
+            it "should call the settor on the provider" do
+                @class.newvalue(:bar)
+                @provider.expects(:foo=).with :bar
+                @property.set(:bar)
+            end
+
+            it "should return any specified event" do
+                @class.newvalue(:bar, :event => :whatever)
+                @property.should = :bar
+                @provider.expects(:foo=).with :bar
+                @property.set(:bar).should == :whatever
+            end
+        end
+
+        describe "that was defined with a block" do
+            it "should call the method created for the value if the value is not a regex" do
+                @class.newvalue(:bar) {}
+                @property.expects(:set_bar)
+                @property.set(:bar)
+            end
+
+            it "should call the provided block if the value is a regex" do
+                @class.newvalue(/./) { self.test }
+                @property.expects(:test)
+                @property.set("foo")
+            end
+
+            it "should return any specified event" do
+                @class.newvalue(:bar, :event => :myevent) {}
+                @property.expects(:set_bar)
+                @property.set(:bar).should == :myevent
+            end
         end
     end
 end

data/spec/unit/property/list.rb

@@ -118,14 +118,14 @@ describe list_class do
             end
         end
 
-        describe "when calling insync?" do
+       describe "when calling insync?" do
             it "should return true unless @should is defined and not nil" do
-                @property.insync?("foo") == true
+                @property.must be_insync("foo")
             end
 
             it "should return true unless the passed in values is not nil" do
                 @property.should = "foo"
-                @property.insync?(nil) == true
+                @property.must be_insync(nil)
             end
 
             it "should call prepare_is_for_comparison with value passed in and should" do
@@ -135,16 +135,22 @@ describe list_class do
                 @property.insync?("bar")
             end
 
-            it "should return true if prepared value == should value" do
+            it "should return true if 'is' value is array of comma delimited should values" do
                 @property.should = "bar,foo"
                 @property.expects(:inclusive?).returns(true)
-                @property.insync?(["bar","foo"]).must == true
+                @property.must be_insync(["bar","foo"])
+            end
+
+            it "should return true if 'is' value is :absent and should value is empty string" do
+                @property.should = ""
+                @property.expects(:inclusive?).returns(true)
+                @property.must be_insync([])
             end
 
             it "should return false if prepared value != should value" do
                 @property.should = "bar,baz,foo"
                 @property.expects(:inclusive?).returns(true)
-                @property.insync?(["bar","foo"]).must == false
+                @property.must_not be_insync(["bar","foo"])
             end
         end
 

data/spec/unit/provider.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Puppet::Provider do
+    it "should have a specifity class method" do
+        Puppet::Provider.should respond_to(:specificity)
+    end
+
+    it "should consider two defaults to be higher specificity than one default" do
+        one = Class.new(Puppet::Provider)
+        one.initvars
+        one.defaultfor :operatingsystem => "solaris"
+
+        two = Class.new(Puppet::Provider)
+        two.initvars
+        two.defaultfor :operatingsystem => "solaris", :operatingsystemrelease => "5.10"
+
+        two.specificity.should > one.specificity
+    end
+
+    it "should consider a subclass more specific than its parent class" do
+        one = Class.new(Puppet::Provider)
+        one.initvars
+
+        two = Class.new(one)
+        two.initvars
+
+        two.specificity.should > one.specificity
+    end
+end

data/spec/unit/provider/augeas/augeas.rb

@@ -5,16 +5,16 @@ require File.dirname(__FILE__) + '/../../../spec_helper'
 provider_class = Puppet::Type.type(:augeas).provider(:augeas)
 
 describe provider_class do
-        
+
     describe "command parsing" do
         before do
-            @resource = stub("resource")          
+            @resource = stub("resource")
             @provider = provider_class.new(@resource)
         end
-        
+
         it "should break apart a single line into three tokens and clean up the context" do
-            @resource.stubs(:[]).returns("/context")          
-            tokens = @provider.parse_commands("set Jar/Jar Binks")      
+            @resource.stubs(:[]).returns("/context")
+            tokens = @provider.parse_commands("set Jar/Jar Binks")
             tokens.size.should == 1
             tokens[0].size.should == 3
             tokens[0][0].should == "set"
@@ -23,8 +23,21 @@ describe provider_class do
         end
 
         it "should break apart a multiple line into six tokens" do
-            @resource.stubs(:[]).returns("")              
-            tokens = @provider.parse_commands("set /Jar/Jar Binks\nrm anakin")           
+            @resource.stubs(:[]).returns("")
+            tokens = @provider.parse_commands("set /Jar/Jar Binks\nrm anakin")
+            tokens.size.should == 2
+            tokens[0].size.should == 3
+            tokens[1].size.should == 2
+            tokens[0][0].should == "set"
+            tokens[0][1].should == "/Jar/Jar"
+            tokens[0][2].should == "Binks"
+            tokens[1][0].should == "rm"
+            tokens[1][1].should == "anakin"
+        end
+
+        it "should strip whitespace and ignore blank lines" do
+            @resource.stubs(:[]).returns("")
+            tokens = @provider.parse_commands("  set /Jar/Jar Binks \t\n  \n\n  rm anakin ")
             tokens.size.should == 2
             tokens[0].size.should == 3
             tokens[1].size.should == 2
@@ -36,7 +49,7 @@ describe provider_class do
         end
 
         it "should handle arrays" do
-            @resource.stubs(:[]).returns("/foo/")            
+            @resource.stubs(:[]).returns("/foo/")
             commands = ["set /Jar/Jar Binks", "rm anakin"]
             tokens = @provider.parse_commands(commands)
             tokens.size.should == 2
@@ -61,7 +74,7 @@ describe provider_class do
         #end
 
         it "should accept spaces in the value and single ticks" do
-            @resource.stubs(:[]).returns("/foo/")           
+            @resource.stubs(:[]).returns("/foo/")
             tokens = @provider.parse_commands("set JarJar 'Binks is my copilot'")
             tokens.size.should == 1
             tokens[0].size.should == 3
@@ -71,7 +84,7 @@ describe provider_class do
         end
 
         it "should accept spaces in the value and double ticks" do
-            @resource.stubs(:[]).returns("/foo/") 
+            @resource.stubs(:[]).returns("/foo/")
             tokens = @provider.parse_commands('set /JarJar "Binks is my copilot"')
             tokens.size.should == 1
             tokens[0].size.should == 3
@@ -81,7 +94,7 @@ describe provider_class do
         end
 
         it "should accept mixed ticks" do
-            @resource.stubs(:[]).returns("/foo/") 
+            @resource.stubs(:[]).returns("/foo/")
             tokens = @provider.parse_commands('set JarJar "Some \'Test\'"')
             tokens.size.should == 1
             tokens[0].size.should == 3
@@ -90,35 +103,49 @@ describe provider_class do
             tokens[0][2].should == "Some \'Test\'"
         end
 
-        it "should handle complex rm calls" do
-            @resource.stubs(:[]).returns("/foo/") 
+        it "should handle predicates with literals" do
+            @resource.stubs(:[]).returns("/foo/")
             tokens = @provider.parse_commands("rm */*[module='pam_console.so']")
             tokens.should == [["rm", "/foo/*/*[module='pam_console.so']"]]
         end
 
-        it "should handle insert with xpath queries" do
-            @resource.stubs(:[]).returns("/foo/") 
+        it "should handle whitespace in predicates" do
+            @resource.stubs(:[]).returns("/foo/")
             tokens = @provider.parse_commands("ins 42 before /files/etc/hosts/*/ipaddr[ . = '127.0.0.1' ]")
-            tokens.should == [["ins", "42", "before","/files/etc/hosts/*/ipaddr[ . = '127.0.0.1' ]"]]        
+            tokens.should == [["ins", "42", "before","/files/etc/hosts/*/ipaddr[ . = '127.0.0.1' ]"]]
         end
 
-        it "should handle set with xpath queries" do
-            @resource.stubs(:[]).returns("/foo/") 
-            tokens = @provider.parse_commands("set /files/etc/*/*[ipaddr = '127.0.0.1'] \"foo bar\"")
-            tokens.should == [["set", "/files/etc/*/*[ipaddr = '127.0.0.1']", "foo bar"]]        
+        it "should handle multiple predicates" do
+            @resource.stubs(:[]).returns("/foo/")
+            tokens = @provider.parse_commands("clear pam.d/*/*[module = 'system-auth'][type = 'account']")
+            tokens.should == [["clear", "/foo/pam.d/*/*[module = 'system-auth'][type = 'account']"]]
         end
 
-        it "should handle clear with xpath queries" do
-            @resource.stubs(:[]).returns("/foo/") 
-            tokens = @provider.parse_commands("clear pam.d/*/*[module = 'system-auth'][type = 'account']")
-            tokens.should == [["clear", "/foo/pam.d/*/*[module = 'system-auth'][type = 'account']"]]       
+        it "should handle nested predicates" do
+            @resource.stubs(:[]).returns("/foo/")
+            args = ["clear", "/foo/pam.d/*/*[module[ ../type = 'type] = 'system-auth'][type[last()] = 'account']"]
+            tokens = @provider.parse_commands(args.join(" "))
+            tokens.should == [ args ]
         end
 
-        it "should handle some odd test" do
-            @resource.stubs(:[]).returns("/foo/") 
+        it "should handle escaped doublequotes in doublequoted string" do
+            @resource.stubs(:[]).returns("/foo/")
             tokens = @provider.parse_commands("set /foo \"''\\\"''\"")
-            tokens.should == [[ "set", "/foo", "''\\\"''" ]]       
-        end    
+            tokens.should == [[ "set", "/foo", "''\\\"''" ]]
+        end
+
+        it "should allow escaped spaces and brackets in paths" do
+            @resource.stubs(:[]).returns("/foo/")
+            args = [ "set", "/white\\ space/\\[section", "value" ]
+            tokens = @provider.parse_commands(args.join(" \t "))
+            tokens.should == [ args ]
+        end
+
+        it "should remove trailing slashes" do
+            @resource.stubs(:[]).returns("/foo/")
+            tokens = @provider.parse_commands("set foo/ bar")
+            tokens.should == [[ "set", "/foo/foo", "bar" ]]
+        end
     end
 
     describe "get filters" do
@@ -178,24 +205,24 @@ describe provider_class do
         end
 
         it "should return true for an array match" do
-            command = ["match", "fake value", "eq ['set', 'of', 'values']"]
+            command = ["match", "fake value", "== ['set', 'of', 'values']"]
             @provider.process_match(command).should == true
         end
 
         it "should return false for an array non match" do
-            command = ["match", "fake value", "eq ['this', 'should', 'not', 'match']"]
+            command = ["match", "fake value", "== ['this', 'should', 'not', 'match']"]
             @provider.process_match(command).should == false
         end
 
         it "should return false for an array match with noteq" do
-            command = ["match", "fake value", "noteq ['set', 'of', 'values']"]
+            command = ["match", "fake value", "!= ['set', 'of', 'values']"]
             @provider.process_match(command).should == false
         end
 
         it "should return true for an array non match with noteq" do
-            command = ["match", "fake value", "noteq ['this', 'should', 'not', 'match']"]
+            command = ["match", "fake value", "!= ['this', 'should', 'not', 'match']"]
             @provider.process_match(command).should == true
-        end        
+        end
     end
 
     describe "need to run" do
@@ -205,6 +232,7 @@ describe provider_class do
             augeas_stub = stub("augeas", :match => ["set", "of", "values"])
             augeas_stub.stubs("close")
             provider = provider_class.new(resource)
+            provider.aug= augeas_stub
             provider.stubs(:get_augeas_version).returns("0.3.5")
             provider.need_to_run?.should == true
         end