puppet 0.23.2 → 0.24.0

data/test/language/functions.rb

@@ -1,9 +1,8 @@
 #!/usr/bin/env ruby
 
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+require File.dirname(__FILE__) + '/../lib/puppettest'
 
 require 'puppet'
-require 'puppet/parser/interpreter'
 require 'puppet/parser/parser'
 require 'puppet/network/client'
 require 'puppettest'
@@ -50,10 +49,9 @@ class TestLangFunctions < Test::Unit::TestCase
 
     def test_taggedfunction
         scope = mkscope
+        scope.resource.tag("yayness")
 
-        tag = "yayness"
-        scope.tag(tag)
-
+        # Make sure the ast stuff does what it's supposed to
         {"yayness" => true, "booness" => false}.each do |tag, retval|
             func = taggedobj(tag, :rvalue)
 
@@ -64,6 +62,12 @@ class TestLangFunctions < Test::Unit::TestCase
 
             assert_equal(retval, val, "'tagged' returned %s for %s" % [val, tag])
         end
+
+        # Now make sure we correctly get tags.
+        scope.resource.tag("resourcetag")
+        assert(scope.function_tagged("resourcetag"), "tagged function did not catch resource tags")
+        scope.compile.catalog.tag("configtag")
+        assert(scope.function_tagged("configtag"), "tagged function did not catch catalog tags")
     end
 
     def test_failfunction
@@ -198,30 +202,30 @@ class TestLangFunctions < Test::Unit::TestCase
             f.puts "original text"
         end
 
-        manifest = tempfile()
         file = tempfile()
-        File.open(manifest, "w") do |f|
-            f.puts %{file { "#{file}": content => template("#{template}") }}
-        end
 
-        interpreter = Puppet::Parser::Interpreter.new(
-            :Manifest => manifest,
-            :UseNodes => false
-        )
+        Puppet[:code] = %{file { "#{file}": content => template("#{template}") }}
+        Puppet[:environments] = "yay"
+        interp = Puppet::Parser::Interpreter.new
+        node = mknode
+        node.stubs(:environment).returns("yay")
 
-        parsedate = interpreter.parsedate()
+        Puppet[:environment] = "yay"
 
-        objects = nil
+        catalog = nil
         assert_nothing_raised {
-            objects = interpreter.run("myhost", {})
+            catalog = interp.compile(node)
         }
 
-        fileobj = objects[0]
+        version = catalog.version
+
+        fileobj = catalog.vertices.find { |r| r.title == file }
+        assert(fileobj, "File was not in catalog")
 
         assert_equal("original text\n", fileobj["content"],
             "Template did not work")
 
-        Puppet[:filetimeout] = 0
+        Puppet[:filetimeout] = -5
         # Have to sleep because one second is the fs's time granularity.
         sleep(1)
 
@@ -230,12 +234,9 @@ class TestLangFunctions < Test::Unit::TestCase
             f.puts "new text"
         end
 
-        assert_nothing_raised {
-            objects = interpreter.run("myhost", {})
-        }
-        newdate = interpreter.parsedate()
+        newversion = interp.compile(node).version
 
-        assert(parsedate != newdate, "Parse date did not change")
+        assert(version != newversion, "Parse date did not change")
     end
 
     def test_template_defined_vars
@@ -306,35 +307,36 @@ class TestLangFunctions < Test::Unit::TestCase
     end
 
     def test_realize
-        @interp, @scope, @source = mkclassframing
+        scope = mkscope
+        parser = scope.compile.parser
     
         # Make a definition
-        @interp.newdefine("mytype")
+        parser.newdefine("mytype")
         
         [%w{file /tmp/virtual}, %w{mytype yay}].each do |type, title|
             # Make a virtual resource
             virtual = mkresource(:type => type, :title => title,
-                :virtual => true, :params => {})
+                :virtual => true, :params => {}, :scope => scope)
         
-            @scope.setresource virtual
+            scope.compile.store_resource(scope, virtual)
 
             ref = Puppet::Parser::Resource::Reference.new(
                 :type => type, :title => title,
-                :scope => @scope
+                :scope => scope
             )
             # Now call the realize function
             assert_nothing_raised do
-                @scope.function_realize(ref)
+                scope.function_realize(ref)
             end
 
             # Make sure it created a collection
-            assert_equal(1, @scope.collections.length,
+            assert_equal(1, scope.compile.collections.length,
                 "Did not set collection")
 
             assert_nothing_raised do
-                @scope.collections.each do |coll| coll.evaluate end
+                scope.compile.collections.each do |coll| coll.evaluate end
             end
-            @scope.collections.clear
+            scope.compile.collections.clear
 
             # Now make sure the virtual resource is no longer virtual
             assert(! virtual.virtual?, "Did not make virtual resource real")
@@ -343,29 +345,29 @@ class TestLangFunctions < Test::Unit::TestCase
         # Make sure we puke on any resource that doesn't exist
         none = Puppet::Parser::Resource::Reference.new(
             :type => "file", :title => "/tmp/nosuchfile",
-            :scope => @scope
+            :scope => scope
         )
 
         # The function works
         assert_nothing_raised do
-            @scope.function_realize(none.to_s)
+            scope.function_realize(none.to_s)
         end
 
         # Make sure it created a collection
-        assert_equal(1, @scope.collections.length,
+        assert_equal(1, scope.compile.collections.length,
             "Did not set collection")
 
         # And the collection has our resource in it
-        assert_equal([none.to_s], @scope.collections[0].resources,
+        assert_equal([none.to_s], scope.compile.collections[0].resources,
             "Did not set resources in collection")
     end
     
     def test_defined
-        interp = mkinterp
-        scope = mkscope(:interp => interp)
+        scope = mkscope
+        parser = scope.compile.parser
         
-        interp.newclass("yayness")
-        interp.newdefine("rahness")
+        parser.newclass("yayness")
+        parser.newdefine("rahness")
         
         assert_nothing_raised do
             assert(scope.function_defined("yayness"), "yayness class was not considered defined")
@@ -383,9 +385,9 @@ class TestLangFunctions < Test::Unit::TestCase
             "Multiple falses were somehow true")
         
         # Now make sure we can test resources
-        scope.setresource mkresource(:type => "file", :title => "/tmp/rahness",
+        scope.compile.store_resource(scope, mkresource(:type => "file", :title => "/tmp/rahness",
             :scope => scope, :source => scope.source,
-            :params => {:owner => "root"})
+            :params => {:owner => "root"}))
         
         yep = Puppet::Parser::Resource::Reference.new(:type => "file", :title => "/tmp/rahness")
         nope = Puppet::Parser::Resource::Reference.new(:type => "file", :title => "/tmp/fooness")
@@ -395,11 +397,11 @@ class TestLangFunctions < Test::Unit::TestCase
     end
 
     def test_search
-        interp = mkinterp
-        scope = mkscope(:interp => interp)
+        parser = mkparser
+        scope = mkscope(:parser => parser)
         
-        fun = interp.newdefine("yay::ness")
-        foo = interp.newdefine("foo::bar")
+        fun = parser.newdefine("yay::ness")
+        foo = parser.newdefine("foo::bar")
 
         search = Puppet::Parser::Functions.function(:search)
         assert_nothing_raised do
@@ -417,45 +419,25 @@ class TestLangFunctions < Test::Unit::TestCase
     end
 
     def test_include
-        interp = mkinterp
-        scope = mkscope(:interp => interp)
+        scope = mkscope
+        parser = scope.compile.parser
 
         assert_raise(Puppet::ParseError, "did not throw error on missing class") do
             scope.function_include("nosuchclass")
         end
 
-        interp.newclass("myclass")
+        parser.newclass("myclass")
 
-        assert_nothing_raised do
-            scope.function_include "myclass"
-        end
-
-        assert(scope.classlist.include?("myclass"),
-            "class was not evaluated")
-
-        # Now try multiple classes at once
-        classes = %w{one two three}.each { |c| interp.newclass(c) }
+        scope.compile.expects(:evaluate_classes).with(%w{myclass otherclass}, scope, false).returns(%w{myclass otherclass})
 
         assert_nothing_raised do
-            scope.function_include classes
-        end
-
-        classes.each do |c|
-            assert(scope.classlist.include?(c),
-                "class %s was not evaluated" % c)
-        end
-
-        # Now try a scoped class
-        interp.newclass("os::redhat")
-
-        assert_nothing_raised("Could not include qualified class name") do
-            scope.function_include("os::redhat")
+            scope.function_include(["myclass", "otherclass"])
         end
     end
 
     def test_file
-        interp = mkinterp
-        scope = mkscope(:interp => interp)
+        parser = mkparser
+        scope = mkscope(:parser => parser)
 
         file1 = tempfile
         file2 = tempfile
@@ -497,8 +479,8 @@ class TestLangFunctions < Test::Unit::TestCase
         assert_equal("yay\n", %x{#{command}}, "command did not work")
         assert_equal("yay-foo\n", %x{#{command} foo}, "command did not work")
 
-        interp = mkinterp
-        scope = mkscope(:interp => interp)
+        scope = mkscope
+        parser = scope.compile.parser
 
         val = nil
         assert_nothing_raised("Could not call generator with no args") do
@@ -529,4 +511,3 @@ class TestLangFunctions < Test::Unit::TestCase
     end
 end
 
-# $Id: functions.rb 2714 2007-07-19 18:12:20Z luke $

data/test/language/lexer.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+require File.dirname(__FILE__) + '/../lib/puppettest'
 
 require 'puppet'
 require 'puppet/parser/lexer'
@@ -111,7 +111,7 @@ class TestLexer < Test::Unit::TestCase
         types.each { |t|
             @lexer.string = t
             assert_equal(
-                [[:TYPE,t],[false,false]],
+                [[:CLASSREF,t],[false,false]],
                 @lexer.fullscan
             )
         }
@@ -254,6 +254,23 @@ class TestLexer < Test::Unit::TestCase
         @lexer.scan {}
         assert_equal("]", @lexer.expected, "expected value is wrong after pop")
     end
+
+    # #774
+    def test_classref_token
+        string = ["Foo", "::Foo","Foo::Bar","::Foo::Bar"]
+
+        string.each do |foo|
+            assert_nothing_raised {
+                @lexer.string = foo
+            }
+
+            ret = nil
+            assert_nothing_raised {
+                ret = @lexer.fullscan
+            }
+
+            assert_equal([:CLASSREF, foo],ret[0], "Did not correctly tokenize '%s'" % foo)
+        end
+    end
 end
 
-# $Id: lexer.rb 2531 2007-05-25 00:31:28Z luke $

data/test/language/parser.rb

@@ -1,14 +1,17 @@
 #!/usr/bin/env ruby
 
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+require File.dirname(__FILE__) + '/../lib/puppettest'
 
 require 'mocha'
 require 'puppet'
 require 'puppet/parser/parser'
 require 'puppettest'
+require 'puppettest/support/utils'
 
 class TestParser < Test::Unit::TestCase
+    include PuppetTest
     include PuppetTest::ParserTesting
+    include PuppetTest::Support::Utils
     def setup
         super
         Puppet[:parseonly] = true
@@ -38,13 +41,13 @@ class TestParser < Test::Unit::TestCase
     def test_failers
         failers { |file|
             parser = mkparser
-            interp = mkinterp
             Puppet.debug("parsing failer %s" % file) if __FILE__ == $0
-            assert_raise(Puppet::ParseError) {
+            assert_raise(Puppet::ParseError, "Did not fail while parsing %s" % file) {
                 parser.file = file
                 ast = parser.parse
-                scope = mkscope :interp => interp
-                ast.classes[""].evaluate :scope => scope
+                config = mkcompile(parser)
+                config.compile
+                #ast.classes[""].evaluate :scope => config.topscope
             }
             Puppet::Type.allclear
         }
@@ -371,7 +374,7 @@ file { "/tmp/yayness":
             ret = parser.parse(str1).classes[""].code[0]
         }
         assert_instance_of(Puppet::Parser::AST::IfStatement, ret)
-        parser.clear
+        parser = mkparser
         str2 = %{if true { #{exec.call("true")} } else { #{exec.call("false")} }}
         assert_nothing_raised {
             ret = parser.parse(str2).classes[""].code[0]
@@ -475,7 +478,7 @@ file { "/tmp/yayness":
 
             assert_instance_of(AST::ASTArray, ret.classes[""].code)
             resdef = ret.classes[""].code[0]
-            assert_instance_of(AST::ResourceDef, resdef)
+            assert_instance_of(AST::Resource, resdef)
             assert_equal("/tmp/testing", resdef.title.value)
             # We always get an astarray back, so...
             check.call(resdef, "simple resource")
@@ -486,26 +489,9 @@ file { "/tmp/yayness":
             end
 
             ret.classes[""].each do |res|
-                assert_instance_of(AST::ResourceDef, res)
+                assert_instance_of(AST::Resource, res)
                 check.call(res, "multiresource")
             end
-
-            # Now evaluate these
-            scope = mkscope
-
-            klass = parser.newclass ""
-            scope.source = klass
-
-            assert_nothing_raised do
-                ret.classes[""].evaluate :scope => scope
-            end
-
-            # Make sure we can find both of them
-            %w{/tmp/1 /tmp/2}.each do |title|
-                res = scope.findresource("File[#{title}]")
-                assert(res, "Could not find %s" % title)
-                check.call(res, "found multiresource")
-            end
         end
     end
 
@@ -618,11 +604,12 @@ file { "/tmp/yayness":
             f.puts "file { '#{file}': ensure => present }"
         end
 
-        interp = mkinterp :Manifest => top, :UseNodes => false
+        Puppet[:manifest] = top
+        interp = Puppet::Parser::Interpreter.new
 
         code = nil
         assert_nothing_raised do
-            code = interp.run("hostname.domain.com", {}).flatten
+            code = interp.compile(mknode).extract.flatten
         end
         assert(code.length == 1, "Did not get the file")
         assert_instance_of(Puppet::TransObject, code[0])
@@ -653,6 +640,14 @@ file { "/tmp/yayness":
         }
     end
 
+    # #774
+    def test_fully_qualified_collection_statement
+        parser = mkparser
+        assert_nothing_raised("Could not parse fully qualified collection statement") {
+            parser.parse %{Foo::Bar <||>}
+        }
+    end
+
     def test_module_import
         basedir = File.join(tmpdir(), "module-import")
         @@tmpfiles << basedir
@@ -672,7 +667,7 @@ file { "/tmp/yayness":
             targets << target
             txt = %[ file { '#{target}': content => "#{fname}" } ]
             if fname == "init.pp"
-                txt = %[import 'mani1' \nimport '#{modname}/mani2'\nimport '#{modname}/sub/*.pp' ] + txt
+                txt = %[import 'mani1' \nimport '#{modname}/mani2'\nimport '#{modname}/sub/*.pp'\n ] + txt
             end
             File::open(File::join(manipath, fname), "w") do |f|
                 f.puts txt
@@ -685,6 +680,7 @@ file { "/tmp/yayness":
 
         manifest = File.join(modpath, "manifest.pp")
         manifest_texts.each do |txt|
+            Puppet::Type.allclear
             File.open(manifest, "w") { |f| f.puts txt }
 
             assert_nothing_raised {
@@ -785,7 +781,7 @@ file { "/tmp/yayness":
 
         assert_instance_of(AST::HostClass, result.classes["yay"], "Did not create 'yay' class")
         assert_instance_of(AST::HostClass, result.classes[""], "Did not create main class")
-        assert_instance_of(AST::Component, result.definitions["bar"], "Did not create 'bar' definition")
+        assert_instance_of(AST::Definition, result.definitions["bar"], "Did not create 'bar' definition")
         assert_instance_of(AST::Node, result.nodes["foo"], "Did not create 'foo' node")
     end
 
@@ -871,7 +867,8 @@ file { "/tmp/yayness":
     end
 
     def test_newclass
-        parser = mkparser
+        scope = mkscope
+        parser = scope.compile.parser
 
         mkcode = proc do |ary|
             classes = ary.collect do |string|
@@ -880,7 +877,6 @@ file { "/tmp/yayness":
             AST::ASTArray.new(:children => classes)
         end
 
-        scope = Puppet::Parser::Scope.new(:interp => mkinterp)
 
         # First make sure that code is being appended
         code = mkcode.call(%w{original code})
@@ -1118,7 +1114,7 @@ file { "/tmp/yayness":
         mk_module(name, :define => true, :init => [name])
 
         klass = parser.finddefine("", name)
-        assert_instance_of(AST::Component, klass, "Did not autoload class from module init file")
+        assert_instance_of(AST::Definition, klass, "Did not autoload class from module init file")
         assert_equal(name, klass.classname, "Incorrect class was returned")
 
         # Now try it with namespace classes where both classes are in the init file
@@ -1175,6 +1171,22 @@ file { "/tmp/yayness":
         assert_instance_of(AST::HostClass, klass, "Did not autoload sub class from alone file with no namespace")
         assert_equal("alone::sub", klass.classname, "Incorrect class was returned")
     end
+    
+    # Make sure class, node, and define methods are case-insensitive
+    def test_structure_case_insensitivity
+        parser = mkparser
+        
+        result = nil
+        assert_nothing_raised do
+            result = parser.newclass "Yayness"
+        end
+        assert_equal(result, parser.findclass("", "yayNess"))
+        
+        assert_nothing_raised do
+            result = parser.newdefine "FunTest"
+        end
+        assert_equal(result, parser.finddefine("", "fUntEst"),
+            "%s was not matched" % "fUntEst")
+    end
 end
 
-# $Id: parser.rb 2742 2007-08-03 23:49:53Z luke $