puppet 0.25.4 → 0.25.5

data/spec/unit/parser/ast/casestatement.rb

@@ -28,16 +28,6 @@ describe Puppet::Parser::AST::CaseStatement do
             @casestmt.evaluate(@scope)
         end
 
-        it "should downcase the evaluated test value if allowed" do
-            Puppet.stubs(:[]).with(:casesensitive).returns(false)
-            value = stub 'test'
-            @test.stubs(:safeevaluate).with(@scope).returns(value)
-
-            value.expects(:downcase)
-
-            @casestmt.evaluate(@scope)
-        end
-
         it "should scan each option" do
             @options.expects(:each).multiple_yields(@option1, @option2)
 
@@ -121,19 +111,21 @@ describe Puppet::Parser::AST::CaseStatement do
             end
 
             it "should unset scope ephemeral variables after option evaluation" do
+                @scope.stubs(:ephemeral_level).returns(:level)
                 @opval1.stubs(:evaluate_match).with { |*arg| arg[0] == "value" and arg[1] == @scope }.returns(true)
                 @option1.stubs(:safeevaluate).with(@scope).returns(:result)
 
-                @scope.expects(:unset_ephemeral_var)
+                @scope.expects(:unset_ephemeral_var).with(:level)
 
                 @casestmt.evaluate(@scope)
             end
 
             it "should not leak ephemeral variables even if evaluation fails" do
+                @scope.stubs(:ephemeral_level).returns(:level)
                 @opval1.stubs(:evaluate_match).with { |*arg| arg[0] == "value" and arg[1] == @scope }.returns(true)
                 @option1.stubs(:safeevaluate).with(@scope).raises
 
-                @scope.expects(:unset_ephemeral_var)
+                @scope.expects(:unset_ephemeral_var).with(:level)
 
                 lambda { @casestmt.evaluate(@scope) }.should raise_error
             end

data/spec/unit/parser/ast/ifstatement.rb

@@ -64,10 +64,11 @@ describe Puppet::Parser::AST::IfStatement do
         end
 
         it "should reset ephemeral statements after evaluation" do
+            @scope.expects(:ephemeral_level).returns(:level)
             Puppet::Parser::Scope.stubs(:true?).returns(true)
 
             @stmt.expects(:safeevaluate).with(@scope)
-            @scope.expects(:unset_ephemeral_var)
+            @scope.expects(:unset_ephemeral_var).with(:level)
 
             @ifstmt.evaluate(@scope)
         end

data/spec/unit/parser/ast/leaf.rb

@@ -33,6 +33,13 @@ describe Puppet::Parser::AST::Leaf do
 
             @leaf.evaluate_match("value", @scope, :insensitive => true)
         end
+
+        it "should downcase the parameter value if wanted" do
+            parameter = stub 'parameter'
+            parameter.expects(:downcase).returns("value")
+
+            @leaf.evaluate_match(parameter, @scope, :insensitive => true)
+        end
     end
 
     describe "when converting to string" do
@@ -123,6 +130,12 @@ describe Puppet::Parser::AST::Regex do
             @regex.evaluate_match("value", @scope)
         end
 
+        it "should not downcase the paramater value" do
+            @value.expects(:match).with("VaLuE")
+
+            @regex.evaluate_match("VaLuE", @scope)
+        end
+
         it "should set ephemeral scope vars if there is a match" do
             @scope.expects(:ephemeral_from).with(true, nil, nil)
 
@@ -220,8 +233,8 @@ describe Puppet::Parser::AST::HostName do
     end
 
     it "should return a string usable as a tag when calling to_classname" do
-        host = Puppet::Parser::AST::HostName.new( :value => Puppet::Parser::AST::Regex.new(:value => "/.+.reductivelabs\.com/") )
-        host.to_classname.should == "reductivelabs.com"
+        host = Puppet::Parser::AST::HostName.new( :value => Puppet::Parser::AST::Regex.new(:value => "/.+.puppetlabs\.com/") )
+        host.to_classname.should == "puppetlabs.com"
     end
 
     it "should delegate 'match' to the underlying value if it is an HostName" do

data/spec/unit/parser/ast/selector.rb

@@ -40,16 +40,6 @@ describe Puppet::Parser::AST::Selector do
             @selector.evaluate(@scope)
         end
 
-        it "should downcase the evaluated param value if allowed" do
-            Puppet.stubs(:[]).with(:casesensitive).returns(false)
-            value = stub 'param'
-            @param.stubs(:safeevaluate).with(@scope).returns(value)
-
-            value.expects(:downcase)
-
-            @selector.evaluate(@scope)
-        end
-
         it "should scan each option" do
             @values.expects(:each).multiple_yields(@value1, @value2)
 
@@ -128,19 +118,21 @@ describe Puppet::Parser::AST::Selector do
             end
 
             it "should unset scope ephemeral variables after option evaluation" do
+                @scope.stubs(:ephemeral_level).returns(:level)
                 @param1.stubs(:evaluate_match).with { |*arg| arg[0] == "value" and arg[1] == @scope }.returns(true)
                 @value1.stubs(:safeevaluate).with(@scope).returns(:result)
 
-                @scope.expects(:unset_ephemeral_var)
+                @scope.expects(:unset_ephemeral_var).with(:level)
 
                 @selector.evaluate(@scope)
             end
 
             it "should not leak ephemeral variables even if evaluation fails" do
+                @scope.stubs(:ephemeral_level).returns(:level)
                 @param1.stubs(:evaluate_match).with { |*arg| arg[0] == "value" and arg[1] == @scope }.returns(true)
                 @value1.stubs(:safeevaluate).with(@scope).raises
 
-                @scope.expects(:unset_ephemeral_var)
+                @scope.expects(:unset_ephemeral_var).with(:level)
 
                 lambda { @selector.evaluate(@scope) }.should raise_error
             end

data/spec/unit/parser/functions/generate.rb

@@ -0,0 +1,41 @@
+#! /usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe "the generate function" do
+
+    before :each do
+        @scope = Puppet::Parser::Scope.new()
+    end
+
+    it "should exist" do
+        Puppet::Parser::Functions.function("generate").should == "function_generate"
+    end
+
+    it "should accept a fully-qualified path as a command" do
+        command = File::SEPARATOR + "command"
+        Puppet::Util.expects(:execute).with([command]).returns("yay")
+        lambda { @scope.function_generate([command]) }.should_not raise_error(Puppet::ParseError)
+    end
+
+    it "should not accept a relative path as a command" do
+        command = "command"
+        lambda { @scope.function_generate([command]) }.should raise_error(Puppet::ParseError)
+    end
+
+    # Really not sure how to implement this test, just sure it needs
+    # to be implemented.
+    it "should not accept a command containing illegal characters"
+
+    it "should not accept a command containing '..'" do
+        command = File::SEPARATOR + "command" + File::SEPARATOR + ".." + File::SEPARATOR
+        lambda { @scope.function_generate([command]) }.should raise_error(Puppet::ParseError)
+    end
+
+    it "should execute the generate script with the correct working directory" do
+        command = File::SEPARATOR + "command"
+        Dir.expects(:chdir).with(File.dirname(command)).yields
+        Puppet::Util.expects(:execute).with([command]).returns("yay")
+        lambda { @scope.function_generate([command]) }.should_not raise_error(Puppet::ParseError)
+    end
+end

data/spec/unit/parser/functions/require.rb

@@ -8,11 +8,13 @@ describe "the require function" do
         @catalog = stub 'catalog'
         @compiler = stub 'compiler', :catalog => @catalog
 
-        @resource = stub 'resource', :set_parameter => nil, :metaparam_compatibility_mode? => false
+        @resource = stub 'resource', :set_parameter => nil, :metaparam_compatibility_mode? => false, :[] => nil
         @scope = Puppet::Parser::Scope.new()
         @scope.stubs(:resource).returns @resource
         @scope.stubs(:findresource)
         @scope.stubs(:compiler).returns(@compiler)
+        @klass = stub 'class', :classname => "myclass"
+        @scope.stubs(:find_hostclass).returns(@klass)
     end
 
     it "should exist" do
@@ -26,7 +28,7 @@ describe "the require function" do
     end
 
     it "should set the 'require' prarameter on the resource to a resource reference" do
-        @resource.expects(:set_parameter).with { |name, value| name == :require and value.is_a?(Puppet::Parser::Resource::Reference) }
+        @resource.expects(:set_parameter).with { |name, value| name == :require and value[0].is_a?(Puppet::Parser::Resource::Reference) }
         @scope.stubs(:function_include)
         @scope.function_require("myclass")
     end
@@ -45,4 +47,23 @@ describe "the require function" do
 
         @scope.function_require("myclass")
     end
+
+    it "should lookup the absolute class path" do
+        @scope.stubs(:function_include)
+
+        @scope.expects(:find_hostclass).with("myclass").returns(@klass)
+        @klass.expects(:classname).returns("myclass")
+
+        @scope.function_require("myclass")
+    end
+
+    it "should append the required class to the require parameter" do
+        @scope.stubs(:function_include)
+        Puppet::Parser::Resource::Reference.stubs(:new).returns(:require2)
+
+        @resource.expects(:[]).with(:require).returns(:require1)
+        @resource.expects(:set_parameter).with(:require, [:require1, :require2])
+
+        @scope.function_require("myclass")
+    end
 end

data/spec/unit/parser/resource.rb

@@ -381,6 +381,24 @@ describe Puppet::Parser::Resource do
             @resource[:testing].should == %w{other testing}
         end
 
+        it "should not merge parameter values when multiple resources are overriden with '+>' at once " do
+            @resource_2 = mkresource :source => @source
+
+            @resource.  set_parameter(:testing, "old_val_1")
+            @resource_2.set_parameter(:testing, "old_val_2")
+
+            @source.stubs(:child_of?).returns true
+            param = Puppet::Parser::Resource::Param.new(:name => :testing, :value => "new_val", :source => @resource.source)
+            param.add = true
+            @override.set_parameter(param)
+
+            @resource.  merge(@override)
+            @resource_2.merge(@override)
+
+            @resource  [:testing].should == %w{old_val_1 new_val}
+            @resource_2[:testing].should == %w{old_val_2 new_val}
+        end
+
         it "should promote tag overrides to real tags" do
             @source.stubs(:child_of?).returns true
             param = Puppet::Parser::Resource::Param.new(:name => :tag, :value => "testing", :source => @resource.source)

data/spec/unit/parser/scope.rb

@@ -221,6 +221,85 @@ describe Puppet::Parser::Scope do
 
             @scope.lookupvar("myvar", false).should == :value1
         end
+
+        it "should raise an error when setting it again" do
+            @scope.setvar("1", :value2, :ephemeral => true)
+            lambda { @scope.setvar("1", :value3, :ephemeral => true) }.should raise_error
+        end
+
+        it "should declare ephemeral number only variable names" do
+            @scope.ephemeral?("0").should be_true
+        end
+
+        it "should not declare ephemeral other variable names" do
+            @scope.ephemeral?("abc0").should be_nil
+        end
+
+        describe "with more than one level" do
+            it "should prefer latest ephemeral scopes" do
+                @scope.setvar("0", :earliest, :ephemeral => true)
+                @scope.new_ephemeral
+                @scope.setvar("0", :latest, :ephemeral => true)
+                @scope.lookupvar("0", false).should == :latest
+            end
+
+            it "should be able to report the current level" do
+                @scope.ephemeral_level.should == 1
+                @scope.new_ephemeral
+                @scope.ephemeral_level.should == 2
+            end
+
+            it "should check presence of an ephemeral variable accross multiple levels" do
+                @scope.new_ephemeral
+                @scope.setvar("1", :value1, :ephemeral => true)
+                @scope.new_ephemeral
+                @scope.setvar("0", :value2, :ephemeral => true)
+                @scope.new_ephemeral
+                @scope.ephemeral_include?("1").should be_true
+            end
+
+            it "should return false when an ephemeral variable doesn't exist in any ephemeral scope" do
+                @scope.new_ephemeral
+                @scope.setvar("1", :value1, :ephemeral => true)
+                @scope.new_ephemeral
+                @scope.setvar("0", :value2, :ephemeral => true)
+                @scope.new_ephemeral
+                @scope.ephemeral_include?("2").should be_false
+            end
+
+            it "should get ephemeral values from earlier scope when not in later" do
+                @scope.setvar("1", :value1, :ephemeral => true)
+                @scope.new_ephemeral
+                @scope.setvar("0", :value2, :ephemeral => true)
+                @scope.lookupvar("1", false).should == :value1
+            end
+
+            describe "when calling unset_ephemeral_var without a level" do
+                it "should remove all the variables values"  do
+                    @scope.setvar("1", :value1, :ephemeral => true)
+                    @scope.new_ephemeral
+                    @scope.setvar("1", :value2, :ephemeral => true)
+
+                    @scope.unset_ephemeral_var
+
+                    @scope.lookupvar("1", false).should == :undefined
+                end
+            end
+
+            describe "when calling unset_ephemeral_var with a level" do
+                it "should remove ephemeral scopes up to this level" do
+                    @scope.setvar("1", :value1, :ephemeral => true)
+                    @scope.new_ephemeral
+                    @scope.setvar("1", :value2, :ephemeral => true)
+                    @scope.new_ephemeral
+                    @scope.setvar("1", :value3, :ephemeral => true)
+
+                    @scope.unset_ephemeral_var(2)
+
+                    @scope.lookupvar("1", false).should == :value2
+                end
+            end
+        end
     end
 
     describe "when interpolating string" do
@@ -278,6 +357,11 @@ describe Puppet::Parser::Scope do
 
             @scope.ephemeral_from(@match)
         end
+
+        it "should create a new ephemeral level" do
+            @scope.expects(:new_ephemeral)
+            @scope.ephemeral_from(@match)
+        end
     end
 
     describe "when unsetting variables" do
@@ -288,9 +372,16 @@ describe Puppet::Parser::Scope do
         end
 
         it "should be able to unset ephemeral variables" do
-            @scope.setvar("foo", "bar", :ephemeral => true)
-            @scope.unsetvar("foo")
-            @scope.lookupvar("foo").should == ""
+            @scope.setvar("0", "bar", :ephemeral => true)
+            @scope.unsetvar("0")
+            @scope.lookupvar("0").should == ""
+        end
+
+        it "should not unset ephemeral variables in previous ephemeral scope" do
+            @scope.setvar("0", "bar", :ephemeral => true)
+            @scope.new_ephemeral
+            @scope.unsetvar("0")
+            @scope.lookupvar("0").should == "bar"
         end
     end
 end

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

@@ -141,6 +141,20 @@ describe provider_class do
             tokens.should == [ args ]
         end
 
+        it "should allow single quoted escaped spaces in paths" do
+            @resource.stubs(:[]).returns("/foo/")
+            args = [ "set", "'/white\\ space/key'", "value" ]
+            tokens = @provider.parse_commands(args.join(" \t "))
+            tokens.should == [[ "set", "/white\\ space/key", "value" ]]
+        end
+
+        it "should allow double quoted escaped spaces in paths" do
+            @resource.stubs(:[]).returns("/foo/")
+            args = [ "set", '"/white\\ space/key"', "value" ]
+            tokens = @provider.parse_commands(args.join(" \t "))
+            tokens.should == [[ "set", "/white\\ space/key", "value" ]]
+        end
+
         it "should remove trailing slashes" do
             @resource.stubs(:[]).returns("/foo/")
             tokens = @provider.parse_commands("set foo/ bar")
@@ -204,6 +218,16 @@ describe provider_class do
             @provider.process_match(command).should == false
         end
 
+        it "should return true for includes match" do
+            command = ["match", "fake value", "not_include JarJar"]
+            @provider.process_match(command).should == true
+        end
+
+        it "should return false for includes non match" do
+            command = ["match", "fake value", "not_include values"]
+            @provider.process_match(command).should == false
+        end
+
         it "should return true for an array match" do
             command = ["match", "fake value", "== ['set', 'of', 'values']"]
             @provider.process_match(command).should == true
@@ -308,7 +332,7 @@ describe provider_class do
             command = "set JarJar Binks"
             context = "/some/path/"
             @resource.expects(:[]).times(2).returns(command).then.returns(context)
-            @augeas.expects(:set).with("/some/path/JarJar", "Binks")
+            @augeas.expects(:set).with("/some/path/JarJar", "Binks").returns(true)
             @augeas.expects(:save).returns(true)
             @augeas.expects(:close)
             @provider.execute_changes.should == :executed
@@ -338,7 +362,7 @@ describe provider_class do
             command = "clear Jar/Jar"
             context = "/foo/"
             @resource.expects(:[]).times(2).returns(command).then.returns(context)
-            @augeas.expects(:clear).with("/foo/Jar/Jar")
+            @augeas.expects(:clear).with("/foo/Jar/Jar").returns(true)
             @augeas.expects(:save).returns(true)
             @augeas.expects(:close)
             @provider.execute_changes.should == :executed
@@ -380,7 +404,7 @@ describe provider_class do
             context = "/foo/"
             @resource.expects(:[]).times(2).returns(command).then.returns(context)
             @augeas.expects(:insert).with("/Jar/Jar", "Binks", false)
-            @augeas.expects(:clear).with("/foo/Jar/Jar")
+            @augeas.expects(:clear).with("/foo/Jar/Jar").returns(true)
             @augeas.expects(:save).returns(true)
             @augeas.expects(:close)
             @provider.execute_changes.should == :executed

data/spec/unit/provider/ssh_authorized_key/parsed.rb

@@ -15,6 +15,9 @@ describe provider_class do
     before :each do
         @sshauthkey_class = Puppet::Type.type(:ssh_authorized_key)
         @provider = @sshauthkey_class.provider(:parsed)
+        @keyfile = File.join(tmpdir, 'authorized_keys')
+        @user = 'random_bob'
+        Puppet::Util.stubs(:uid).with(@user).returns 12345
     end
 
     after :each do
@@ -23,22 +26,23 @@ describe provider_class do
 
     def mkkey(args)
         fakeresource = fakeresource(:ssh_authorized_key, args[:name])
+        fakeresource.stubs(:should).with(:user).returns @user
+        fakeresource.stubs(:should).with(:target).returns @keyfile
 
         key = @provider.new(fakeresource)
         args.each do |p,v|
             key.send(p.to_s + "=", v)
         end
 
-        return key
+        key
     end
 
     def genkey(key)
         @provider.stubs(:filetype).returns(Puppet::Util::FileType::FileTypeRam)
-        file = @provider.default_target
-
+        File.stubs(:chown)
+        File.stubs(:chmod)
         key.flush
-        text = @provider.target_object(file).read
-        return text
+        @provider.target_object(@keyfile).read
     end
 
     PuppetTest.fakedata("data/providers/ssh_authorized_key/parsed").each { |file|
@@ -73,7 +77,7 @@ describe provider_class do
     end
 
     it "'s parse_options method should be able to parse options containing commas" do
-        options = %w{from="host1.reductlivelabs.com,host.reductivelabs.com" command="/usr/local/bin/run" ssh-pty}
+        options = %w{from="host1.reductlivelabs.com,host.puppetlabs.com" command="/usr/local/bin/run" ssh-pty}
         optionstr = options.join(", ")
 
         @provider.parse_options(optionstr).should == options
@@ -147,20 +151,35 @@ describe provider_class do
                 # but mocha objects strenuously to stubbing File.expand_path
                 # so I'm left with using nobody.
                 @dir = File.expand_path("~nobody/.ssh")
-           end
+            end
 
-            it "should create the directory" do
+            it "should create the directory if it doesn't exist" do
                 File.stubs(:exist?).with(@dir).returns false
                 Dir.expects(:mkdir).with(@dir,0700)
                 @provider.flush
             end
 
-            it "should chown the directory to the user" do
+            it "should not create or chown the directory if it already exist" do
+                File.stubs(:exist?).with(@dir).returns false
+                Dir.expects(:mkdir).never
+                @provider.flush
+            end
+
+            it "should chown the directory to the user if it creates it" do
+                File.stubs(:exist?).with(@dir).returns false
+                Dir.stubs(:mkdir).with(@dir,0700)
                 uid = Puppet::Util.uid("nobody")
                 File.expects(:chown).with(uid, nil, @dir)
                 @provider.flush
             end
 
+            it "should not create or chown the directory if it already exist" do
+                File.stubs(:exist?).with(@dir).returns false
+                Dir.expects(:mkdir).never
+                File.expects(:chown).never
+                @provider.flush
+            end
+
             it "should chown the key file to the user" do
                 uid = Puppet::Util.uid("nobody")
                 File.expects(:chown).with(uid, nil, File.expand_path("~nobody/.ssh/authorized_keys"))
@@ -179,17 +198,9 @@ describe provider_class do
                 @resource.stubs(:should).with(:target).returns("/tmp/.ssh_dir/place_to_put_authorized_keys")
             end
 
-            it "should make the directory" do
-                File.stubs(:exist?).with("/tmp/.ssh_dir").returns false
-                Dir.expects(:mkdir).with("/tmp/.ssh_dir", 0755)
-                @provider.flush
-            end
-
-            it "should chmod the key file to 0644" do
-                File.expects(:chmod).with(0644, "/tmp/.ssh_dir/place_to_put_authorized_keys")
-                @provider.flush
+            it "should raise an error" do
+                proc { @provider.flush }.should raise_error
             end
         end
-
     end
 end