puppet 0.24.9 → 0.25.0

data/spec/unit/parser/resource.rb

@@ -68,11 +68,11 @@ describe Puppet::Parser::Resource do
         @resource[:one].should == "yay"
     end
 
-    it "should have a method for converting to a ral resource" do
-        trans = mock 'trans', :to_type => "yay"
+    it "should use a Puppet::Resource for converting to a ral resource" do
+        trans = mock 'resource', :to_ral => "yay"
         @resource = mkresource
-        @resource.expects(:to_trans).returns trans
-        @resource.to_type.should == "yay"
+        @resource.expects(:to_resource).returns trans
+        @resource.to_ral.should == "yay"
     end
 
     describe "when initializing" do
@@ -92,6 +92,13 @@ describe Puppet::Parser::Resource do
             res = Puppet::Parser::Resource.new(@arguments)
             res.ref.should == "Resource[testing]"
         end
+
+        it "should be tagged with user tags" do
+            tags = [ "tag1", "tag2" ]
+            @arguments[:params] = [ param(:tag, tags , :source) ]
+            res = Puppet::Parser::Resource.new(@arguments)
+            (res.tags & tags).should == tags
+        end
     end
 
     describe "when evaluating" do
@@ -180,32 +187,22 @@ describe Puppet::Parser::Resource do
             @resource["noop"].should == "false"
         end
 
-        it "should copy all metaparams that it finds" do
-            @scope.setvar("require", "container")
-            @scope.setvar("notify", "container")
+        it "should not copy relationship metaparams" do
+            @scope.setvar("require", "bar")
 
             @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
 
-            @resource["require"].should == "container"
-            @resource["notify"].should == "container"
+            @resource["require"].should be_nil
         end
 
-        it "should stack relationship metaparams from its container if it already has them" do
-            @resource.set_parameter("require", "resource")
-            @scope.setvar("require", "container")
-
-            @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
-
-            @resource["require"].sort.should == %w{container resource}
-        end
-
-        it "should flatten the array resulting from stacking relationship metaparams" do
-            @resource.set_parameter("require", ["resource1", "resource2"])
-            @scope.setvar("require", %w{container1 container2})
+        it "should copy all metaparams that it finds" do
+            @scope.setvar("noop", "foo")
+            @scope.setvar("schedule", "bar")
 
             @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
 
-            @resource["require"].sort.should == %w{container1 container2 resource1 resource2}
+            @resource["noop"].should == "foo"
+            @resource["schedule"].should == "bar"
         end
 
         it "should add any tags from the scope resource" do
@@ -335,6 +332,118 @@ describe Puppet::Parser::Resource do
             @resource[:testing].should == %w{other testing}
         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)
+
+            @override.set_parameter(param)
+
+            @resource.merge(@override)
+
+            @resource.tagged?("testing").should be_true
+        end
+
+    end
+
+    it "should be able to be converted to a normal resource" do
+        @source = stub 'scope', :name => "myscope"
+        @resource = mkresource :source => @source
+        @resource.should respond_to(:to_resource)
+    end
+
+    it "should use its resource converter to convert to a transportable resource" do
+        @source = stub 'scope', :name => "myscope"
+        @resource = mkresource :source => @source
+
+        newresource = Puppet::Resource.new(:file, "/my")
+        Puppet::Resource.expects(:new).returns(newresource)
+
+        newresource.expects(:to_trans).returns "mytrans"
+
+        @resource.to_trans.should == "mytrans"
+    end
+
+    it "should return nil if converted to a transportable resource and it is virtual" do
+        @source = stub 'scope', :name => "myscope"
+        @resource = mkresource :source => @source
+
+        @resource.expects(:virtual?).returns true
+        @resource.to_trans.should be_nil
+    end
 
+    describe "when being converted to a resource" do
+        before do
+            @source = stub 'scope', :name => "myscope"
+            @parser_resource = mkresource :source => @source, :params => {:foo => "bar", :fee => "fum"}
+        end
+
+        it "should create an instance of Puppet::Resource" do
+            @parser_resource.to_resource.should be_instance_of(Puppet::Resource)
+        end
+
+        it "should set the type correctly on the Puppet::Resource" do
+            @parser_resource.to_resource.type.should == @parser_resource.type
+        end
+
+        it "should set the title correctly on the Puppet::Resource" do
+            @parser_resource.to_resource.title.should == @parser_resource.title
+        end
+
+        it "should copy over all of the parameters" do
+            result = @parser_resource.to_resource.to_hash
+
+            # The name will be in here, also.
+            result[:foo].should == "bar"
+            result[:fee].should == "fum"
+        end
+
+        it "should copy over the tags" do
+            @parser_resource.tag "foo"
+            @parser_resource.tag "bar"
+
+            @parser_resource.to_resource.tags.should == @parser_resource.tags
+        end
+
+        it "should copy over the line" do
+            @parser_resource.line = 40
+            @parser_resource.to_resource.line.should == 40
+        end
+
+        it "should copy over the file" do
+            @parser_resource.file = "/my/file"
+            @parser_resource.to_resource.file.should == "/my/file"
+        end
+
+        it "should copy over the 'exported' value" do
+            @parser_resource.exported = true
+            @parser_resource.to_resource.exported.should be_true
+        end
+
+        it "should copy over the 'virtual' value" do
+            @parser_resource.virtual = true
+            @parser_resource.to_resource.virtual.should be_true
+        end
+
+        it "should convert any parser resource references to Puppet::Resource::Reference instances" do
+            ref = Puppet::Parser::Resource::Reference.new(:title => "/my/file", :type => "file")
+            @parser_resource = mkresource :source => @source, :params => {:foo => "bar", :fee => ref}
+            result = @parser_resource.to_resource
+            result[:fee].should == Puppet::Resource::Reference.new(:file, "/my/file")
+        end
+
+        it "should convert any parser resource references to Puppet::Resource::Reference instances even if they are in an array" do
+            ref = Puppet::Parser::Resource::Reference.new(:title => "/my/file", :type => "file")
+            @parser_resource = mkresource :source => @source, :params => {:foo => "bar", :fee => ["a", ref]}
+            result = @parser_resource.to_resource
+            result[:fee].should == ["a", Puppet::Resource::Reference.new(:file, "/my/file")]
+        end
+
+        it "should convert any parser resource references to Puppet::Resource::Reference instances even if they are in an array of array, and even deeper" do
+            ref1 = Puppet::Parser::Resource::Reference.new(:title => "/my/file1", :type => "file")
+            ref2 = Puppet::Parser::Resource::Reference.new(:title => "/my/file2", :type => "file")
+            @parser_resource = mkresource :source => @source, :params => {:foo => "bar", :fee => ["a", [ref1,ref2]]}
+            result = @parser_resource.to_resource
+            result[:fee].should == ["a", Puppet::Resource::Reference.new(:file, "/my/file1"), Puppet::Resource::Reference.new(:file, "/my/file2")]
+        end
     end
 end

data/spec/unit/parser/scope.rb

@@ -4,39 +4,137 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Parser::Scope do
     before :each do
-        @scope = Puppet::Parser::Scope.new()
         @topscope = Puppet::Parser::Scope.new()
-        @scope.stubs(:parent).returns(@topscope)
+        # This is necessary so we don't try to use the compiler to discover our parent.
+        @topscope.parent = nil
+        @scope = Puppet::Parser::Scope.new()
+        @scope.parent = @topscope
     end
 
-    describe Puppet::Parser::Scope, "when setvar is called with append=true" do
+    describe "when looking up a variable" do
+        it "should default to an empty string" do
+            @scope.lookupvar("var").should == ""
+        end
+
+        it "should return an string when asked for a string" do
+            @scope.lookupvar("var", true).should == ""
+        end
+
+        it "should return ':undefined' for unset variables when asked not to return a string" do
+            @scope.lookupvar("var", false).should == :undefined
+        end
+
+        it "should be able to look up values" do
+            @scope.setvar("var", "yep")
+            @scope.lookupvar("var").should == "yep"
+        end
+
+        it "should be able to look up variables in parent scopes" do
+            @topscope.setvar("var", "parentval")
+            @scope.lookupvar("var").should == "parentval"
+        end
+
+        it "should prefer its own values to parent values" do
+            @topscope.setvar("var", "parentval")
+            @scope.setvar("var", "childval")
+            @scope.lookupvar("var").should == "childval"
+        end
+
+        describe "and the variable is qualified" do
+            before do
+                @parser = Puppet::Parser::Parser.new()
+                @compiler = Puppet::Parser::Compiler.new(stub("node", :name => "foonode"), @parser)
+                @scope.compiler = @compiler
+                @scope.parser = @parser
+            end
+
+            def create_class_scope(name)
+                klass = @parser.newclass(name)
+                Puppet::Parser::Resource.new(:type => "class", :title => name, :scope => @scope, :source => mock('source')).evaluate
+
+                return @compiler.class_scope(klass)
+            end
+
+            it "should be able to look up explicitly fully qualified variables from main" do
+                other_scope = create_class_scope("")
+
+                other_scope.setvar("othervar", "otherval")
+
+                @scope.lookupvar("::othervar").should == "otherval"
+            end
 
+            it "should be able to look up explicitly fully qualified variables from other scopes" do
+                other_scope = create_class_scope("other")
+
+                other_scope.setvar("var", "otherval")
+
+                @scope.lookupvar("::other::var").should == "otherval"
+            end
+
+            it "should be able to look up deeply qualified variables" do
+                other_scope = create_class_scope("other::deep::klass")
+
+                other_scope.setvar("var", "otherval")
+
+                @scope.lookupvar("other::deep::klass::var").should == "otherval"
+            end
+
+            it "should return an empty string for qualified variables that cannot be found in other classes" do
+                other_scope = create_class_scope("other::deep::klass")
+
+                @scope.lookupvar("other::deep::klass::var").should == ""
+            end
+
+            it "should warn and return an empty string for qualified variables whose classes have not been evaluated" do
+                klass = @parser.newclass("other::deep::klass")
+                @scope.expects(:warning)
+                @scope.lookupvar("other::deep::klass::var").should == ""
+            end
+
+            it "should warn and return an empty string for qualified variables whose classes do not exist" do
+                @scope.expects(:warning)
+                @scope.lookupvar("other::deep::klass::var").should == ""
+            end
+
+            it "should return ':undefined' when asked for a non-string qualified variable from a class that does not exist" do
+                @scope.stubs(:warning)
+                @scope.lookupvar("other::deep::klass::var", false).should == :undefined
+            end
+
+            it "should return ':undefined' when asked for a non-string qualified variable from a class that has not been evaluated" do
+                @scope.stubs(:warning)
+                klass = @parser.newclass("other::deep::klass")
+                @scope.lookupvar("other::deep::klass::var", false).should == :undefined
+            end
+        end
+    end
+
+    describe "when setvar is called with append=true" do
         it "should raise error if the variable is already defined in this scope" do
-            @scope.setvar("var","1",nil,nil,false)
-            lambda { @scope.setvar("var","1",nil,nil,true) }.should raise_error(Puppet::ParseError)
+            @scope.setvar("var","1", :append => false)
+            lambda { @scope.setvar("var","1", :append => true) }.should raise_error(Puppet::ParseError)
         end
 
         it "it should lookup current variable value" do
             @scope.expects(:lookupvar).with("var").returns("2")
-            @scope.setvar("var","1",nil,nil,true)
+            @scope.setvar("var","1", :append => true)
         end
 
         it "it should store the concatenated string '42'" do
-            @topscope.setvar("var","4",nil,nil,false)
-            @scope.setvar("var","2",nil,nil,true)
+            @topscope.setvar("var","4", :append => false)
+            @scope.setvar("var","2", :append => true)
             @scope.lookupvar("var").should == "42"
         end
 
         it "it should store the concatenated array [4,2]" do
-            @topscope.setvar("var",[4],nil,nil,false)
-            @scope.setvar("var",[2],nil,nil,true)
+            @topscope.setvar("var",[4], :append => false)
+            @scope.setvar("var",[2], :append => true)
             @scope.lookupvar("var").should == [4,2]
         end
 
     end
 
-    describe Puppet::Parser::Scope, "when calling number?" do
-
+    describe "when calling number?" do
         it "should return nil if called with anything not a number" do
             Puppet::Parser::Scope.number?([2]).should be_nil
         end
@@ -98,4 +196,101 @@ describe Puppet::Parser::Scope do
         end
     end
 
+    describe "when using ephemeral variables" do
+        it "should store the variable value" do
+            @scope.setvar("1", :value, :ephemeral => true)
+
+            @scope.lookupvar("1").should == :value
+        end
+
+        it "should remove the variable value when unset_ephemeral_var is called" do
+            @scope.setvar("1", :value, :ephemeral => true)
+            @scope.stubs(:parent).returns(nil)
+
+            @scope.unset_ephemeral_var
+
+            @scope.lookupvar("1", false).should == :undefined
+        end
+
+        it "should not remove classic variables when unset_ephemeral_var is called" do
+            @scope.setvar("myvar", :value1)
+            @scope.setvar("1", :value2, :ephemeral => true)
+            @scope.stubs(:parent).returns(nil)
+
+            @scope.unset_ephemeral_var
+
+            @scope.lookupvar("myvar", false).should == :value1
+        end
+    end
+
+    describe "when interpolating string" do
+        (0..9).each do |n|
+            it "should allow $#{n} to match" do
+                @scope.setvar(n.to_s, "value", :ephemeral => true)
+
+                @scope.strinterp("$#{n}").should == "value"
+            end
+        end
+
+        (0..9).each do |n|
+            it "should not allow $#{n} to match if not ephemeral" do
+                @scope.setvar(n.to_s, "value", :ephemeral => false)
+
+                @scope.strinterp("$#{n}").should_not == "value"
+            end
+        end
+
+        it "should not allow $10 to match" do
+            @scope.setvar("10", "value", :ephemeral => true)
+
+            @scope.strinterp('==$10==').should_not == "==value=="
+        end
+
+        it "should not allow ${10} to match" do
+            @scope.setvar("10", "value", :ephemeral => true)
+
+            @scope.strinterp('==${10}==').should == "==value=="
+        end
+    end
+
+    describe "when setting ephemeral vars from matches" do
+        before :each do
+            @match = stub 'match', :is_a? => true
+            @match.stubs(:[]).with(0).returns("this is a string")
+            @match.stubs(:captures).returns([])
+            @scope.stubs(:setvar)
+        end
+
+        it "should accept only MatchData" do
+            lambda { @scope.ephemeral_from("match") }.should raise_error
+        end
+
+        it "should set $0 with the full match" do
+            @scope.expects(:setvar).with { |*arg| arg[0] == "0" and arg[1] == "this is a string" and arg[2][:ephemeral] }
+
+            @scope.ephemeral_from(@match)
+        end
+
+        it "should set every capture as ephemeral var" do
+            @match.stubs(:captures).returns([:capture1,:capture2])
+            @scope.expects(:setvar).with { |*arg| arg[0] == "1" and arg[1] == :capture1 and arg[2][:ephemeral] }
+            @scope.expects(:setvar).with { |*arg| arg[0] == "2" and arg[1] == :capture2 and arg[2][:ephemeral] }
+
+            @scope.ephemeral_from(@match)
+        end
+    end
+
+    describe "when unsetting variables" do
+        it "should be able to unset normal variables" do
+            @scope.setvar("foo", "bar")
+            @scope.unsetvar("foo")
+            @scope.lookupvar("foo").should == ""
+        end
+
+        it "should be able to unset ephemeral variables" do
+            @scope.setvar("foo", "bar", :ephemeral => true)
+            @scope.unsetvar("foo")
+            @scope.lookupvar("foo").should == ""
+        end
+    end
 end

data/spec/unit/parser/templatewrapper.rb

@@ -8,7 +8,7 @@ describe Puppet::Parser::TemplateWrapper do
         parser = stub('parser', :watch_file => true)
         @scope = stub('scope', :compiler => compiler, :parser => parser, :to_hash => {})
         @file = "fake_template"
-        Puppet::Module.stubs(:find_template).returns("/tmp/fake_template")
+        Puppet::Parser::Files.stubs(:find_template).returns("/tmp/fake_template")
         FileTest.stubs(:exists?).returns("true")
         File.stubs(:read).with("/tmp/fake_template").returns("template content")
         @tw = Puppet::Parser::TemplateWrapper.new(@scope)
@@ -21,13 +21,18 @@ describe Puppet::Parser::TemplateWrapper do
     end
 
     it "should check template file existance and read its content" do
-        Puppet::Module.expects(:find_template).with("fake_template", "foo").returns("/tmp/fake_template")
-        FileTest.expects(:exists?).with("/tmp/fake_template").returns(true)
+        Puppet::Parser::Files.expects(:find_template).with("fake_template", "foo").returns("/tmp/fake_template")
         File.expects(:read).with("/tmp/fake_template").returns("template content")
 
         @tw.file = @file
     end
 
+    it "should fail if a template cannot be found" do
+        Puppet::Parser::Files.expects(:find_template).with("fake_template", "foo").returns nil
+
+        lambda { @tw.file = @file }.should raise_error(Puppet::ParseError)
+    end
+
     it "should turn into a string like template[name] for file based template" do
         @tw.file = @file
         @tw.to_s.should eql("template[/tmp/fake_template]")