puppet 0.18.4 → 0.22.4

data/test/language/lexer.rb

@@ -1,13 +1,10 @@
-if __FILE__ == $0
-    $:.unshift '../../lib'
-    $:.unshift '..'
-    $puppetbase = "../.."
-end
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppet'
 require 'puppet/parser/lexer'
-require 'test/unit'
-require 'puppettest.rb'
+require 'puppettest'
 
 #%q{service("telnet") = \{
 #    port => "23",
@@ -17,9 +14,13 @@ require 'puppettest.rb'
 #} => [[:NAME, "service"], [:LPAREN, "("], [:DQUOTE, "\""], [:NAME, "telnet"], [:DQUOTE, "\""], [:RPAREN, ")"], [:EQUALS, "="], [:lbrace, "{"], [:NAME, "port"], [:FARROW, "=>"], [:DQUOTE, "\""], [:NAME, "23"], [:DQUOTE, "\""], [:COMMA, ","], [:NAME, "protocol"], [:FARROW, "=>"], [:DQUOTE, "\""], [:NAME, "tcp"], [:DQUOTE, "\""], [:COMMA, ","], [:NAME, "name"], [:FARROW, "=>"], [:DQUOTE, "\""], [:NAME, "telnet"], [:DQUOTE, "\""], [:COMMA, ","], [:RBRACE, "}"]]
 
 class TestLexer < Test::Unit::TestCase
-	include TestPuppet
+	include PuppetTest
     def setup
         super
+        mklexer
+    end
+
+    def mklexer
         @lexer = Puppet::Parser::Lexer.new()
     end
 
@@ -86,9 +87,10 @@ class TestLexer < Test::Unit::TestCase
 
     def test_files
         textfiles() { |file|
-            @lexer.file = file
-            assert_nothing_raised() {
-                @lexer.fullscan()
+            lexer = Puppet::Parser::Lexer.new()
+            lexer.file = file
+            assert_nothing_raised("Failed to lex %s" % file) {
+                lexer.fullscan()
             }
             Puppet::Type.allclear
         }
@@ -156,6 +158,90 @@ class TestLexer < Test::Unit::TestCase
 
         assert_equal([[:AT, "@"], [:NAME, "type"], [:LBRACE, "{"], [false,false]],ret)
     end
+
+    def test_namespace
+        @lexer.string = %{class myclass}
+
+        assert_nothing_raised {
+            @lexer.fullscan
+        }
+
+        assert_equal("myclass", @lexer.namespace)
+
+        assert_nothing_raised do
+            @lexer.namepop
+        end
+
+        assert_equal("", @lexer.namespace)
+
+        @lexer.string = "class base { class sub { class more"
+
+        assert_nothing_raised {
+            @lexer.fullscan
+        }
+
+        assert_equal("base::sub::more", @lexer.namespace)
+
+        assert_nothing_raised do
+            @lexer.namepop
+        end
+
+        assert_equal("base::sub", @lexer.namespace)
+
+        # Now try it with some fq names
+        mklexer
+
+        @lexer.string = "class base { class sub::more {"
+
+        assert_nothing_raised {
+            @lexer.fullscan
+        }
+
+        assert_equal("base::sub::more", @lexer.namespace)
+
+        assert_nothing_raised do
+            @lexer.namepop
+        end
+
+        assert_equal("base", @lexer.namespace)
+    end
+
+    def test_indefine
+        @lexer.string = %{define me}
+
+        assert_nothing_raised {
+            @lexer.scan { |t,s| }
+        }
+
+        assert(@lexer.indefine?, "Lexer not considered in define")
+
+        # Now make sure we throw an error when trying to nest defines.
+        assert_raise(Puppet::ParseError) do
+            @lexer.string = %{define another}
+            @lexer.scan { |t,s| }
+        end
+
+        assert_nothing_raised do
+            @lexer.indefine = false
+        end
+
+        assert(! @lexer.indefine?, "Lexer still considered in define")
+    end
+
+    # Make sure the different qualified variables work.
+    def test_variable
+        ["$variable", "$::variable", "$qualified::variable", "$further::qualified::variable"].each do |string|
+            @lexer.string = string
+
+            assert_nothing_raised("Could not lex %s" % string) do
+                @lexer.scan do |t, s|
+                    assert_equal(:VARIABLE, t, "did not get variable as token")
+                    assert_equal(string.sub(/^\$/, ''), s, "did not get correct string back")
+                    break
+                end
+            end
+        end
+    end
 end
 
-# $Id: lexer.rb 1189 2006-05-13 18:27:22Z luke $
+# $Id: lexer.rb 2393 2007-04-19 18:34:03Z luke $

data/test/language/node.rb

@@ -1,21 +1,17 @@
-if __FILE__ == $0
-    $:.unshift '../../lib'
-    $:.unshift '..'
-    $puppetbase = "../.."
-end
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppet'
 require 'puppet/parser/parser'
-require 'test/unit'
 require 'puppettest'
 
 class TestParser < Test::Unit::TestCase
-	include ParserTesting
+    include PuppetTest::ParserTesting
 
     def setup
         super
         Puppet[:parseonly] = true
-        @parser = Puppet::Parser::Parser.new()
     end
 
     def test_simple_hostname
@@ -32,6 +28,10 @@ class TestParser < Test::Unit::TestCase
         check_parseable "'svn.23.nu'"
         check_parseable "'HOST'"
     end
+    
+    def test_inherits_from_default
+        check_parseable(["default", "host1"], "node default {}\nnode host1 inherits default {}")
+    end
 
     def test_reject_hostname
         check_nonparseable "host.example.com"
@@ -44,52 +44,45 @@ class TestParser < Test::Unit::TestCase
 
     AST = Puppet::Parser::AST
 
-    def check_parseable(hostnames)
+    def check_parseable(hostnames, code = nil)
         unless hostnames.is_a?(Array)
             hostnames = [ hostnames ]
         end
+        interp = nil
+        code ||= "node #{hostnames.join(", ")} { }"
         assert_nothing_raised {
-            @parser.string = "node #{hostnames.join(", ")} { }"
+            interp = mkinterp :Code => code
         }
         # Strip quotes
         hostnames.map! { |s| s.sub(/^'(.*)'$/, "\\1") }
-        ast = nil
+
+        # parse
         assert_nothing_raised {
-            ast = @parser.parse
+            interp.send(:parsefiles)
         }
-        # Verify that the AST has the expected structure
-        # and that the leaves have the right hostnames in them
-        assert_kind_of(AST::ASTArray, ast)
-        assert_equal(1, ast.children.size)
-        nodedef = ast.children[0]
-        assert_kind_of(AST::NodeDef, nodedef)
-        assert_kind_of(AST::ASTArray, nodedef.names)
-        assert_equal(hostnames.size, nodedef.names.children.size)
-        hostnames.size.times do |i|
-            hostnode = nodedef.names.children[i]
-            assert_kind_of(AST::HostName, hostnode)
-            assert_equal(hostnames[i], hostnode.value)
+
+        # Now make sure we can look up each of the names
+        hostnames.each do |name|
+            assert(interp.nodesearch(name),
+                "Could not find node %s" % name.inspect)
         end
     end
 
     def check_nonparseable(hostname)
-        assert_nothing_raised {
-            @parser.string = "node #{hostname} { }"
-        }
-
-        assert_raise(Puppet::DevError, Puppet::ParseError) {
-            @parser.parse
+        interp = nil
+        assert_raise(Puppet::DevError, Puppet::ParseError, "#{hostname} passed") {
+            interp = mkinterp :Code => "node #{hostname} { }"
+            interp.send(:parsefiles)
         }
     end
 
     # Make sure we can find default nodes if there's no other entry
     def test_default_node
         Puppet[:parseonly] = false
-        @parser = Puppet::Parser::Parser.new()
 
         fileA = tempfile()
         fileB = tempfile()
-        @parser.string = %{
+        code = %{
 node mynode {
     file { "#{fileA}": ensure => file }
 }
@@ -98,34 +91,25 @@ node default {
     file { "#{fileB}": ensure => file }
 }
 }
-
-        # First make sure it parses
-        ast = nil
+        interp = nil
         assert_nothing_raised {
-            ast = @parser.parse
-        }
-
-        args = {
-            :ast => ast,
-            :facts => {},
-            :names => ["mynode"]
+            interp = mkinterp :Code => code
         }
-        # Make sure we get a config for "mynode"
 
-        trans = nil
+        # First make sure it parses
         assert_nothing_raised {
-            trans = Puppet::Parser::Scope.new.evaluate(args)
+            interp.send(:parsefiles)
         }
 
-        assert(trans, "Did not get config for mynode")
+        # Make sure we find our normal node
+        assert(interp.nodesearch("mynode"),
+            "Did not find normal node")
 
-        args[:names] = ["othernode"]
-        # Now make sure the default node is used
-        trans = nil
-        assert_nothing_raised {
-            trans = Puppet::Parser::Scope.new.evaluate(args)
-        }
+        # Now look for the default node
+        default = interp.nodesearch("someother")
+        assert(default,
+            "Did not find default node")
 
-        assert(trans, "Did not get config for default node")
+        assert_equal("default", default.fqname)
     end
 end

data/test/language/parser.rb

@@ -1,36 +1,33 @@
-if __FILE__ == $0
-    $:.unshift '../../lib'
-    $:.unshift '..'
-    $puppetbase = "../.."
-end
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppet'
 require 'puppet/parser/parser'
-require 'test/unit'
 require 'puppettest'
 
 class TestParser < Test::Unit::TestCase
-	include ParserTesting
+    include PuppetTest::ParserTesting
     def setup
         super
         Puppet[:parseonly] = true
         #@lexer = Puppet::Parser::Lexer.new()
-        @parser = Puppet::Parser::Parser.new()
     end
 
     def test_each_file
         textfiles { |file|
+            parser = mkparser
             Puppet.debug("parsing %s" % file) if __FILE__ == $0
             assert_nothing_raised() {
-                @parser.file = file
-                @parser.parse
+                parser.file = file
+                parser.parse
             }
 
             Puppet::Type.eachtype { |type|
                 type.each { |obj|
-                    assert(obj.file)
-                    assert(obj.name)
-                    assert(obj.line)
+                    assert(obj.file, "File is not set on %s" % obj.ref)
+                    assert(obj.name, "Name is not set on %s" % obj.ref)
+                    assert(obj.line, "Line is not set on %s" % obj.ref)
                 }
             }
             Puppet::Type.allclear
@@ -39,18 +36,20 @@ class TestParser < Test::Unit::TestCase
 
     def test_failers
         failers { |file|
+            parser = mkparser
             Puppet.debug("parsing failer %s" % file) if __FILE__ == $0
             assert_raise(Puppet::ParseError) {
-                @parser.file = file
-                ast = @parser.parse
-                Puppet::Parser::Scope.new.evaluate(:ast => ast)
+                parser.file = file
+                ast = parser.parse
+                scope = mkscope :interp => parser.interp
+                ast.evaluate :scope => scope
             }
             Puppet::Type.allclear
         }
     end
 
     def test_arrayrvalues
-        parser = Puppet::Parser::Parser.new()
+        parser = mkparser
         ret = nil
         file = tempfile()
         assert_nothing_raised {
@@ -90,7 +89,7 @@ class TestParser < Test::Unit::TestCase
         }
 
         assert_nothing_raised("Could not parse multiple files") {
-            parser = Puppet::Parser::Parser.new()
+            parser = mkparser
             parser.file = manifest
             parser.parse
         }
@@ -105,102 +104,18 @@ class TestParser < Test::Unit::TestCase
             f.puts "import \" no such file \""
         end
         assert_raise(Puppet::ParseError) {
-            parser = Puppet::Parser::Parser.new()
+            parser = mkparser
             parser.file = manifest
             parser.parse
         }
     end
 
-    def test_defaults
-        basedir = File.join(tmpdir(), "defaulttesting")
-        @@tmpfiles << basedir
-        Dir.mkdir(basedir)
-
-        defs1 = {
-            "testing" => "value"
-        }
-
-        defs2 = {
-            "one" => "two",
-            "three" => "four",
-            "five" => false,
-            "seven" => "eight",
-            "nine" => true,
-            "eleven" => "twelve"
-        }
-
-        mkdef = proc { |hash|
-            hash.collect { |arg, value|
-                "%s = %s" % [arg, value]
-            }.join(", ")
-        }
-        manifest = File.join(basedir, "manifest")
-        File.open(manifest, "w") { |f|
-            f.puts "
-    define method(#{mkdef.call(defs1)}, other) {
-        $variable = $testing
-    }
-
-    define othermethod(#{mkdef.call(defs2)}, goodness) {
-        $more = less
-    }
-
-    method {
-        other => yayness
-    }
-
-    othermethod {
-        goodness => rahness
-    }
-"
-        }
-
-        ast = nil
-        assert_nothing_raised("Could not parse multiple files") {
-            parser = Puppet::Parser::Parser.new()
-            parser.file = manifest
-            ast = parser.parse
-        }
-
-        assert(ast, "Did not receive AST while parsing defaults")
-
-        scope = nil
-        assert_nothing_raised("Could not evaluate defaults parse tree") {
-            scope = Puppet::Parser::Scope.new()
-            scope.name = "parsetest"
-            scope.type = "parsetest"
-            objects = scope.evaluate(:ast => ast)
-        }
-
-        method = nil
-        othermethod = nil
-        assert_nothing_raised {
-            method = scope.find { |child|
-                child.is_a?(Puppet::Parser::Scope) and child.type == "method"
-            }
-            defs1.each { |var, value|
-                curval = method.lookupvar(var)
-                assert_equal(value, curval, "Did not get default")
-            }
-        }
-
-        assert_nothing_raised {
-            method = scope.find { |child|
-                child.is_a?(Puppet::Parser::Scope) and child.type == "othermethod"
-            }
-            defs2.each { |var, value|
-                curval = method.lookupvar(var)
-                assert_equal(value, curval, "Did not get default")
-            }
-        }
-    end
-
     def test_trailingcomma
         path = tempfile()
         str = %{file { "#{path}": ensure => file, }
         }
 
-        parser = Puppet::Parser::Parser.new
+        parser = mkparser
         parser.string = str
 
         assert_nothing_raised("Could not parse trailing comma") {
@@ -222,7 +137,7 @@ class TestParser < Test::Unit::TestCase
             f.puts %{import "#{imported}"\ninclude foo}
         end
 
-        parser = Puppet::Parser::Parser.new
+        parser = mkparser
         parser.file = importer
 
         # Make sure it parses fine
@@ -248,21 +163,21 @@ class TestParser < Test::Unit::TestCase
             f.puts %{import "#{fullfile}"\ninclude full\nimport "local.pp"\ninclude local}
         end
 
-        file = tempfile()
-        files << file
+        fullmaker = tempfile()
+        files << fullmaker
 
         File.open(fullfile, "w") do |f|
-            f.puts %{class full { file { "#{file}": ensure => file }}}
+            f.puts %{class full { file { "#{fullmaker}": ensure => file }}}
         end
 
-        file = tempfile()
-        files << file
+        localmaker = tempfile()
+        files << localmaker
 
         File.open(localfile, "w") do |f|
-            f.puts %{class local { file { "#{file}": ensure => file }}}
+            f.puts %{class local { file { "#{localmaker}": ensure => file }}}
         end
 
-        parser = Puppet::Parser::Parser.new
+        parser = mkparser
         parser.file = importer
 
         # Make sure it parses
@@ -294,7 +209,7 @@ class TestParser < Test::Unit::TestCase
             f.puts %{class local { file { "#{file}": ensure => file }}}
         end
 
-        parser = Puppet::Parser::Parser.new
+        parser = mkparser
         parser.file = importer
 
         assert_nothing_raised {
@@ -331,7 +246,7 @@ class TestParser < Test::Unit::TestCase
             f.puts %{import "subdir/subtwo"}
         end
 
-        parser = Puppet::Parser::Parser.new
+        parser = mkparser
         parser.file = top
 
         assert_nothing_raised {
@@ -339,46 +254,20 @@ class TestParser < Test::Unit::TestCase
         }
     end
 
-    # Verify that collectable objects are marked that way.
-    def test_collectable
-        Puppet[:storeconfigs] = true
-        ["@port { ssh: protocols => tcp, number => 22 }",
-         "@port { ssh: protocols => tcp, number => 22;
-            smtp: protocols => tcp, number => 25 }"].each do |text|
-            parser = Puppet::Parser::Parser.new
-            parser.string = text
-
-            ret = nil
-            assert_nothing_raised {
-                ret = parser.parse
-            }
-
-            assert_instance_of(AST::ASTArray, ret)
-
-            ret.each do |obj|
-                assert_instance_of(AST::ObjectDef, obj)
-                assert(obj.collectable, "Object was not marked collectable")
-            end
-        end
-    end
-
     # Defaults are purely syntactical, so it doesn't make sense to be able to
     # collect them.
     def test_uncollectabledefaults
         string = "@Port { protocols => tcp }"
-        parser = Puppet::Parser::Parser.new
-        parser.string = string
 
         assert_raise(Puppet::ParseError) {
-            parser.parse
+            mkparser.parse(string)
         }
     end
 
     # Verify that we can parse collections
     def test_collecting
-        Puppet[:storeconfigs] = true
-        text = "port <| |>"
-        parser = Puppet::Parser::Parser.new
+        text = "Port <| |>"
+        parser = mkparser
         parser.string = text
 
         ret = nil
@@ -398,7 +287,7 @@ class TestParser < Test::Unit::TestCase
         File.open(file, "w") do |f|
             f.puts %{}
         end
-        parser = Puppet::Parser::Parser.new
+        parser = mkparser
         parser.file = file
         assert_nothing_raised {
             parser.parse
@@ -418,7 +307,7 @@ node nodeA, nodeB {
 }
         end
 
-        parser = Puppet::Parser::Parser.new
+        parser = mkparser
         parser.file = file
         ast = nil
         assert_nothing_raised {
@@ -429,7 +318,7 @@ node nodeA, nodeB {
     def test_emptyarrays
         str = %{$var = []\n}
 
-        parser = Puppet::Parser::Parser.new
+        parser = mkparser
         parser.string = str
 
         # Make sure it parses fine
@@ -448,7 +337,7 @@ file { "/tmp/yayness":
     ensure => exists
 }
 }
-        parser = Puppet::Parser::Parser.new
+        parser = mkparser
         parser.string = str
 
         # Make sure it parses fine
@@ -456,6 +345,424 @@ file { "/tmp/yayness":
             parser.parse
         }
     end
+
+    def test_metaparams_in_definition_prototypes
+        parser = mkparser
+
+
+        assert_raise(Puppet::ParseError) {
+            parser.parse %{define mydef($schedule) {}}
+        }
+
+        assert_nothing_raised {
+            parser.parse %{define adef($schedule = false) {}}
+            parser.parse %{define mydef($schedule = daily) {}}
+        }
+    end
+
+    def test_parsingif
+        parser = mkparser
+        exec = proc do |val|
+            %{exec { "/bin/echo #{val}": logoutput => true }}
+        end
+        str1 = %{if true { #{exec.call("true")} }}
+        ret = nil
+        assert_nothing_raised {
+            ret = parser.parse(str1)[0]
+        }
+        assert_instance_of(Puppet::Parser::AST::IfStatement, ret)
+        str2 = %{if true { #{exec.call("true")} } else { #{exec.call("false")} }}
+        assert_nothing_raised {
+            ret = parser.parse(str2)[0]
+        }
+        assert_instance_of(Puppet::Parser::AST::IfStatement, ret)
+        assert_instance_of(Puppet::Parser::AST::Else, ret.else)
+    end
+
+    def test_hostclass
+        parser = mkparser
+        interp = parser.interp
+
+        assert_nothing_raised {
+            parser.parse %{class myclass { class other {} }}
+        }
+        assert(interp.findclass("", "myclass"), "Could not find myclass")
+        assert(interp.findclass("", "myclass::other"), "Could not find myclass::other")
+
+        assert_nothing_raised {
+            parser.parse "class base {}
+            class container {
+                class deep::sub inherits base {}
+            }"
+        }
+        sub = interp.findclass("", "container::deep::sub")
+        assert(sub, "Could not find sub")
+        assert_equal("base", sub.parentclass.type)
+        
+        # Now try it with a parent class being a fq class
+        assert_nothing_raised {
+            parser.parse "class container::one inherits container::deep::sub {}"
+        }
+        sub = interp.findclass("", "container::one")
+        assert(sub, "Could not find one")
+        assert_equal("sub", sub.parentclass.type)
+        
+        # Finally, try including a qualified class
+        assert_nothing_raised("Could not include fully qualified class") {
+            parser.parse "include container::deep::sub"
+        }
+    end
+
+    def test_topnamespace
+        parser = mkparser
+        parser.interp.clear
+
+        # Make sure we put the top-level code into a class called "" in
+        # the "" namespace
+        assert_nothing_raised do
+            out = parser.parse ""
+
+            assert_nil(out)
+            assert_nil(parser.interp.findclass("", ""))
+        end
+
+        # Now try something a touch more complicated
+        parser.interp.clear
+        assert_nothing_raised do
+            out = parser.parse "Exec { path => '/usr/bin:/usr/sbin' }"
+            assert_instance_of(AST::ASTArray, out)
+            assert_equal("", parser.interp.findclass("", "").type)
+            assert_equal("", parser.interp.findclass("", "").namespace)
+            assert_equal(out.object_id, parser.interp.findclass("", "").code.object_id)
+        end
+    end
+
+    # Make sure virtual and exported resources work appropriately.
+    def test_virtualresources
+        tests = [:virtual]
+        if Puppet.features.rails?
+            Puppet[:storeconfigs] = true
+            tests << :exported
+        end
+
+        tests.each do |form|
+            parser = mkparser
+
+            if form == :virtual
+                at = "@"
+            else
+                at = "@@"
+            end
+
+            check = proc do |res, msg|
+                if res.is_a?(Puppet::Parser::Resource)
+                    txt = res.ref
+                else
+                    txt = res.class
+                end
+                # Real resources get marked virtual when exported
+                if form == :virtual or res.is_a?(Puppet::Parser::Resource)
+                    assert(res.virtual, "#{msg} #{at}#{txt} is not virtual")
+                end
+                if form == :virtual
+                    assert(! res.exported, "#{msg} #{at}#{txt} is exported")
+                else
+                    assert(res.exported, "#{msg} #{at}#{txt} is not exported")
+                end
+            end
+
+            ret = nil
+            assert_nothing_raised do
+                ret = parser.parse("#{at}file { '/tmp/testing': owner => root }")
+            end
+
+            assert_equal("/tmp/testing", ret[0].title.value)
+            # We always get an astarray back, so...
+            assert_instance_of(AST::ResourceDef, ret[0])
+            check.call(ret[0], "simple resource")
+
+            # Now let's try it with multiple resources in the same spec
+            assert_nothing_raised do
+                ret = parser.parse("#{at}file { ['/tmp/1', '/tmp/2']: owner => root }")
+            end
+
+            assert_instance_of(AST::ASTArray, ret)
+            ret.each do |res|
+                assert_instance_of(AST::ResourceDef, res)
+                check.call(res, "multiresource")
+            end
+
+            # Now evaluate these
+            scope = mkscope
+
+            klass = scope.interp.newclass ""
+            scope.source = klass
+
+            assert_nothing_raised do
+                ret.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
+
+    def test_collections
+        tests = [:virtual]
+        if Puppet.features.rails?
+            Puppet[:storeconfigs] = true
+            tests << :exported
+        end
+
+        tests.each do |form|
+            parser = mkparser
+
+            if form == :virtual
+                arrow = "<||>"
+            else
+                arrow = "<<||>>"
+            end
+
+            check = proc do |coll|
+                assert_instance_of(AST::Collection, coll)
+                assert_equal(form, coll.form)
+            end
+
+            ret = nil
+            assert_nothing_raised do
+                ret = parser.parse("File #{arrow}")
+            end
+            check.call(ret[0])
+        end
+    end
+
+    def test_collectionexpressions
+        %w{== !=}.each do |oper|
+            str = "File <| title #{oper} '/tmp/testing' |>"
+
+            parser = mkparser
+
+            res = nil
+            assert_nothing_raised do
+                res = parser.parse(str)[0]
+            end
+
+            assert_instance_of(AST::Collection, res)
+
+            query = res.query
+            assert_instance_of(AST::CollExpr, query)
+
+            assert_equal(:virtual, query.form)
+            assert_equal("title", query.test1.value)
+            assert_equal("/tmp/testing", query.test2.value)
+            assert_equal(oper, query.oper)
+        end
+    end
+
+    def test_collectionstatements
+        %w{and or}.each do |joiner|
+            str = "File <| title == '/tmp/testing' #{joiner} owner == root |>"
+
+            parser = mkparser
+
+            res = nil
+            assert_nothing_raised do
+                res = parser.parse(str)[0]
+            end
+
+            assert_instance_of(AST::Collection, res)
+
+            query = res.query
+            assert_instance_of(AST::CollExpr, query)
+
+            assert_equal(joiner, query.oper)
+            assert_instance_of(AST::CollExpr, query.test1)
+            assert_instance_of(AST::CollExpr, query.test2)
+        end
+    end
+
+    def test_collectionstatements_with_parens
+        [
+            "(title == '/tmp/testing' and owner == root) or owner == wheel",
+            "(title == '/tmp/testing')"
+        ].each do |test|
+            str = "File <| #{test} |>"
+            parser = mkparser
+
+            res = nil
+            assert_nothing_raised("Could not parse '#{test}'") do
+                res = parser.parse(str)[0]
+            end
+
+            assert_instance_of(AST::Collection, res)
+
+            query = res.query
+            assert_instance_of(AST::CollExpr, query)
+
+            #assert_equal(joiner, query.oper)
+            #assert_instance_of(AST::CollExpr, query.test1)
+            #assert_instance_of(AST::CollExpr, query.test2)
+        end
+    end
+
+    # We've had problems with files other than site.pp importing into main.
+    def test_importing_into_main
+        top = tempfile()
+        other = tempfile()
+        File.open(top, "w") do |f|
+            f.puts "import '#{other}'"
+        end
+
+        file = tempfile()
+        File.open(other, "w") do |f|
+            f.puts "file { '#{file}': ensure => present }"
+        end
+
+        interp = mkinterp :Manifest => top, :UseNodes => false
+
+        code = nil
+        assert_nothing_raised do
+            code = interp.run("hostname.domain.com", {}).flatten
+        end
+        assert(code.length == 1, "Did not get the file")
+        assert_instance_of(Puppet::TransObject, code[0])
+    end
+    
+    def test_fully_qualified_definitions
+        parser = mkparser
+        interp = parser.interp
+
+        assert_nothing_raised("Could not parse fully-qualified definition") {
+            parser.parse %{define one::two { }}
+        }
+        assert(interp.finddefine("", "one::two"), "Could not find one::two with no namespace")
+        assert(interp.finddefine("one", "two"), "Could not find two in namespace one")
+        
+        # Now try using the definition
+        assert_nothing_raised("Could not parse fully-qualified definition usage") {
+            parser.parse %{one::two { yayness: }}
+        }
+    end
+
+    # #524
+    def test_functions_with_no_arguments
+        parser = mkparser
+        assert_nothing_raised("Could not parse statement function with no args") {
+            parser.parse %{tag()}
+        }
+        assert_nothing_raised("Could not parse rvalue function with no args") {
+            parser.parse %{$testing = template()}
+        }
+    end
+
+    def test_module_import
+        basedir = File.join(tmpdir(), "module-import")
+        @@tmpfiles << basedir
+        Dir.mkdir(basedir)
+        modfiles = [ "init.pp", "mani1.pp", "mani2.pp",
+                     "sub/smani1.pp", "sub/smani2.pp" ]
+
+        modpath = File.join(basedir, "modules")
+        Puppet[:modulepath] = modpath
+
+        modname = "amod"
+        manipath = File::join(modpath, modname, Puppet::Module::MANIFESTS)
+        FileUtils::mkdir_p(File::join(manipath, "sub"))
+        targets = []
+        modfiles.each do |fname|
+            target = File::join(basedir, File::basename(fname, '.pp'))
+            targets << target
+            txt = %[ file { '#{target}': content => "#{fname}" } ]
+            if fname == "init.pp"
+                txt = %[import 'mani1' \nimport '#{modname}/mani2'\nimport '#{modname}/sub/*.pp' ] + txt
+            end
+            File::open(File::join(manipath, fname), "w") do |f|
+                f.puts txt
+            end
+        end
+
+        manifest_texts = [ "import '#{modname}'",
+                           "import '#{modname}/init'",
+                           "import '#{modname}/init.pp'" ]
+
+        manifest = File.join(modpath, "manifest.pp")
+        manifest_texts.each do |txt|
+            File.open(manifest, "w") { |f| f.puts txt }
+
+            assert_nothing_raised {
+                parser = mkparser
+                parser.file = manifest
+                parser.parse
+            }
+            assert_creates(manifest, *targets)
+        end
+    end
+
+    # #544
+    def test_ignoreimports
+        parser = mkparser
+
+        assert(! Puppet[:ignoreimport], ":ignoreimport defaulted to true")
+        assert_raise(Puppet::ParseError, "Did not fail on missing import") do
+            parser.parse("import 'nosuchfile'")
+        end
+        assert_nothing_raised("could not set :ignoreimport") do
+            Puppet[:ignoreimport] = true
+        end
+        assert_nothing_raised("Parser did not follow :ignoreimports") do
+            parser.parse("import 'nosuchfile'")
+        end
+    end
+
+    def test_multiple_imports_on_one_line
+        one = tempfile
+        two = tempfile
+        base = tempfile
+        File.open(one, "w") { |f| f.puts "$var = value" }
+        File.open(two, "w") { |f| f.puts "$var = value" }
+        File.open(base, "w") { |f| f.puts "import '#{one}', '#{two}'" }
+
+        parser = mkparser
+        parser.file = base
+
+        # Importing is logged at debug time.
+        Puppet::Util::Log.level = :debug
+        assert_nothing_raised("Parser could not import multiple files at once") do
+            parser.parse
+        end
+
+        [one, two].each do |file|
+            assert(@logs.detect { |l| l.message =~ /importing '#{file}'/},
+                "did not import %s" % file)
+        end
+    end
+
+    def test_cannot_assign_qualified_variables
+        parser = mkparser
+        assert_raise(Puppet::ParseError, "successfully assigned a qualified variable") do
+            parser.parse("$one::two = yay")
+        end
+    end
+
+    # #588
+    def test_globbing_with_directories
+        dir = tempfile
+        Dir.mkdir(dir)
+        subdir = File.join(dir, "subdir")
+        Dir.mkdir(subdir)
+        file = File.join(dir, "file.pp")
+        maker = tempfile
+        File.open(file, "w") { |f| f.puts "file { '#{maker}': ensure => file }" }
+
+        parser = mkparser
+        assert_nothing_raised("Globbing failed when it matched a directory") do
+            parser.import("%s/*" % dir)
+        end
+    end
 end
 
-# $Id: parser.rb 1245 2006-06-08 20:06:41Z luke $
+# $Id: parser.rb 2404 2007-04-20 16:40:47Z luke $