puppet 0.23.2 → 0.24.0

data/test/executables/puppetmasterd.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/network/client'
@@ -140,4 +140,3 @@ class TestPuppetMasterD < Test::Unit::TestCase
     end
 end
 
-# $Id: puppetmasterd.rb 2259 2007-03-06 19:03:05Z luke $

data/test/executables/puppetmodule.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+require File.dirname(__FILE__) + '/../lib/puppettest'
 
 require 'puppettest'
 
@@ -53,4 +53,3 @@ class TestPuppetModule < Test::Unit::TestCase
     end
 end
 
-# $Id: puppetmodule.rb 2259 2007-03-06 19:03:05Z luke $

data/test/language/ast.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+require File.dirname(__FILE__) + '/../lib/puppettest'
 
 require 'puppettest'
 require 'puppet/parser/interpreter'
@@ -49,29 +49,26 @@ class TestAST < Test::Unit::TestCase
 
     # Make sure our override object behaves "correctly"
     def test_override
-        interp, scope, source = mkclassframing
+        scope = mkscope
 
         ref = nil
         assert_nothing_raised do
-            ref = resourceoverride("resource", "yaytest", "one" => "yay", "two" => "boo")
+            ref = resourceoverride("file", "/yayness", "owner" => "blah", "group" => "boo")
         end
 
+        Puppet::Parser::Resource.expects(:new).with { |o| o.is_a?(Hash) }.returns(:override)
+        scope.compile.expects(:store_override).with(:override)
         ret = nil
         assert_nothing_raised do
             ret = ref.evaluate :scope => scope
         end
 
-        assert_instance_of(Puppet::Parser::Resource, ret)
-
-        assert(ret.override?, "Resource was not an override resource")
-
-        assert(scope.overridetable[ret.ref].include?(ret),
-            "Was not stored in the override table")
+        assert_equal(:override, ret, "Did not return override")
     end
 
     # make sure our resourcedefaults ast object works correctly.
     def test_resourcedefaults
-        interp, scope, source = mkclassframing
+        scope = mkscope
 
         # Now make some defaults for files
         args = {:source => "/yay/ness", :group => "yayness"}
@@ -82,7 +79,7 @@ class TestAST < Test::Unit::TestCase
 
         hash = nil
         assert_nothing_raised do
-            hash = scope.lookupdefaults("file")
+            hash = scope.lookupdefaults("File")
         end
 
         hash.each do |name, value|
@@ -97,16 +94,16 @@ class TestAST < Test::Unit::TestCase
     end
 
     def test_node
-        interp = mkinterp
-        scope = mkscope(:interp => interp)
+        scope = mkscope
+        parser = scope.compile.parser
 
         # Define a base node
-        basenode = interp.newnode "basenode", :code => AST::ASTArray.new(:children => [
+        basenode = parser.newnode "basenode", :code => AST::ASTArray.new(:children => [
             resourcedef("file", "/tmp/base", "owner" => "root")
         ])
 
         # Now define a subnode
-        nodes = interp.newnode ["mynode", "othernode"],
+        nodes = parser.newnode ["mynode", "othernode"],
             :code => AST::ASTArray.new(:children => [
                 resourcedef("file", "/tmp/mynode", "owner" => "root"),
                 resourcedef("file", "/tmp/basenode", "owner" => "daemon")
@@ -116,13 +113,13 @@ class TestAST < Test::Unit::TestCase
 
         # Make sure we can find them all.
         %w{mynode othernode}.each do |node|
-            assert(interp.nodesearch_code(node), "Could not find %s" % node)
+            assert(parser.nodes[node], "Could not find %s" % node)
         end
-        mynode = interp.nodesearch_code("mynode")
+        mynode = parser.nodes["mynode"]
 
         # Now try evaluating the node
         assert_nothing_raised do
-            mynode.evaluate :scope => scope
+            mynode.evaluate :scope => scope, :resource => scope.resource
         end
 
         # Make sure that we can find each of the files
@@ -135,11 +132,11 @@ class TestAST < Test::Unit::TestCase
         assert_equal("daemon", basefile[:owner])
 
         # Now make sure we can evaluate nodes with parents
-        child = interp.newnode(%w{child}, :parent => "basenode").shift
+        child = parser.newnode(%w{child}, :parent => "basenode").shift
 
-        newscope = mkscope :interp => interp
+        newscope = mkscope :parser => parser
         assert_nothing_raised do
-            child.evaluate :scope => newscope
+            child.evaluate :scope => newscope, :resource => scope.resource
         end
 
         assert(newscope.findresource("File[/tmp/base]"),
@@ -147,8 +144,7 @@ class TestAST < Test::Unit::TestCase
     end
 
     def test_collection
-        interp = mkinterp
-        scope = mkscope(:interp => interp)
+        scope = mkscope
 
         coll = nil
         assert_nothing_raised do
@@ -165,20 +161,21 @@ class TestAST < Test::Unit::TestCase
         assert_instance_of(Puppet::Parser::Collector, ret)
 
         # Now make sure we get it back from the scope
-        assert_equal([ret], scope.collections)
+        colls = scope.compile.instance_variable_get("@collections")
+        assert_equal([ret], colls, "Did not store collector in config's collection list")
     end
 
     def test_virtual_collexp
-        @interp, @scope, @source = mkclassframing
+        scope = mkscope
 
         # make a resource
         resource = mkresource(:type => "file", :title => "/tmp/testing",
-            :params => {:owner => "root", :group => "bin", :mode => "644"})
+            :scope => scope, :params => {:owner => "root", :group => "bin", :mode => "644"})
 
         run_collection_queries(:virtual) do |string, result, query|
             code = nil
             assert_nothing_raised do
-                str, code = query.evaluate :scope => @scope
+                str, code = query.evaluate :scope => scope
             end
 
             assert_instance_of(Proc, code)
@@ -189,5 +186,3 @@ class TestAST < Test::Unit::TestCase
         end
     end
 end
-
-# $Id: ast.rb 2597 2007-06-17 21:41:50Z luke $

data/test/language/ast/casestatement.rb

@@ -3,7 +3,7 @@
 #  Created by Luke A. Kanies on 2006-12-22.
 #  Copyright (c) 2006. All rights reserved.
 
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+require File.dirname(__FILE__) + '/../../lib/puppettest'
 
 require 'puppettest'
 require 'puppettest/parsertesting'
@@ -101,4 +101,3 @@ class TestCaseStatement < Test::Unit::TestCase
     end
 end
 
-# $Id: casestatement.rb 2231 2007-02-27 21:31:02Z luke $

data/test/language/ast/definition.rb

@@ -0,0 +1,166 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke A. Kanies on 2006-02-20.
+#  Copyright (c) 2006. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../lib/puppettest'
+
+require 'puppettest'
+require 'mocha'
+require 'puppettest/parsertesting'
+require 'puppettest/resourcetesting'
+
+class TestASTDefinition < Test::Unit::TestCase
+	include PuppetTest
+	include PuppetTest::ParserTesting
+    include PuppetTest::ResourceTesting
+	AST = Puppet::Parser::AST
+
+    def test_initialize
+        parser = mkparser
+
+        # Create a new definition
+        klass = parser.newdefine "yayness",
+            :arguments => [["owner", stringobj("nobody")], %w{mode}],
+            :code => AST::ASTArray.new(
+                :children => [resourcedef("file", "/tmp/$name",
+                        "owner" => varref("owner"), "mode" => varref("mode"))]
+            )
+
+        # Test validattr? a couple different ways
+        [:owner, "owner", :schedule, "schedule"].each do |var|
+            assert(klass.validattr?(var), "%s was not considered valid" % var.inspect)
+        end
+
+        [:random, "random"].each do |var|
+            assert(! klass.validattr?(var), "%s was considered valid" % var.inspect)
+        end
+
+    end
+
+    def test_evaluate
+        parser = mkparser
+        config = mkcompile
+        config.send(:evaluate_main)
+        scope = config.topscope
+        klass = parser.newdefine "yayness",
+            :arguments => [["owner", stringobj("nobody")], %w{mode}],
+            :code => AST::ASTArray.new(
+                :children => [resourcedef("file", "/tmp/$name",
+                        "owner" => varref("owner"), "mode" => varref("mode"))]
+            )
+
+        resource = Puppet::Parser::Resource.new(
+            :title => "first",
+            :type => "yayness",
+            :exported => false,
+            :virtual => false,
+            :scope => scope,
+            :source => scope.source
+        )
+        resource.send(:set_parameter, "name", "first")
+        resource.send(:set_parameter, "mode", "755")
+
+        resource.stubs(:title)
+        assert_nothing_raised do
+            klass.evaluate(:scope => scope, :resource => resource)
+        end
+
+        firstobj = config.findresource("File[/tmp/first]")
+        assert(firstobj, "Did not create /tmp/first obj")
+
+        assert_equal("File", firstobj.type)
+        assert_equal("/tmp/first", firstobj.title)
+        assert_equal("nobody", firstobj[:owner])
+        assert_equal("755", firstobj[:mode])
+
+        # Make sure we can't evaluate it with the same args
+        assert_raise(Puppet::ParseError) do
+            klass.evaluate(:scope => scope, :resource => resource)
+        end
+
+        # Now create another with different args
+        resource2 = Puppet::Parser::Resource.new(
+            :title => "second",
+            :type => "yayness",
+            :exported => false,
+            :virtual => false,
+            :scope => scope,
+            :source => scope.source
+        )
+        resource2.send(:set_parameter, "name", "second")
+        resource2.send(:set_parameter, "mode", "755")
+        resource2.send(:set_parameter, "owner", "daemon")
+
+        assert_nothing_raised do
+            klass.evaluate(:scope => scope, :resource => resource2)
+        end
+
+        secondobj = config.findresource("File[/tmp/second]")
+        assert(secondobj, "Did not create /tmp/second obj")
+
+        assert_equal("File", secondobj.type)
+        assert_equal("/tmp/second", secondobj.title)
+        assert_equal("daemon", secondobj[:owner])
+        assert_equal("755", secondobj[:mode])
+    end
+
+    # #539 - definitions should support both names and titles
+    def test_names_and_titles
+        parser = mkparser
+        scope = mkscope :parser => parser
+
+        [
+            {:name => "one", :title => "two"},
+            {:title => "mytitle"}
+        ].each_with_index do |hash, i|
+            # Create a definition that uses both name and title.  Put this
+            # inside the loop so the subscope expectations work.
+            klass = parser.newdefine "yayness%s" % i
+
+            resource = Puppet::Parser::Resource.new(
+                :title => hash[:title],
+                :type => "yayness%s" % i,
+                :exported => false,
+                :virtual => false,
+                :scope => scope,
+                :source => scope.source
+            )
+
+            subscope = klass.subscope(scope, resource)
+
+            klass.expects(:subscope).returns(subscope)
+
+            if hash[:name]
+                resource.stubs(:to_hash).returns({:name => hash[:name]})
+            end
+
+            assert_nothing_raised("Could not evaluate definition with %s" % hash.inspect) do
+                klass.evaluate(:scope => scope, :resource => resource)
+            end
+
+            name = hash[:name] || hash[:title]
+            title = hash[:title]
+
+            assert_equal(name, subscope.lookupvar("name"),
+                "Name did not get set correctly")
+            assert_equal(title, subscope.lookupvar("title"),
+                "title did not get set correctly")
+
+            [:name, :title].each do |param|
+                val = resource.send(param)
+                assert(subscope.tags.include?(val),
+                    "Scope was not tagged with %s '%s'" % [param, val])
+            end
+        end
+    end
+
+    # Testing the root cause of #615.  We should be using the fqname for the type, instead
+    # of just the short name.
+    def test_fully_qualified_types
+        parser = mkparser
+        klass = parser.newclass("one::two")
+
+        assert_equal("one::two", klass.classname, "Class did not get fully qualified class name")
+    end
+end

data/test/language/ast/hostclass.rb

@@ -3,7 +3,7 @@
 #  Created by Luke A. Kanies on 2006-02-20.
 #  Copyright (c) 2006. All rights reserved.
 
-$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+require File.dirname(__FILE__) + '/../../lib/puppettest'
 
 require 'puppettest'
 require 'puppettest/parsertesting'
@@ -17,25 +17,27 @@ class TestASTHostClass < Test::Unit::TestCase
 	AST = Puppet::Parser::AST
 
     def test_hostclass
-        interp, scope, source = mkclassframing
+        scope = mkscope
+        parser = scope.compile.parser
 
         # Create the class we're testing, first with no parent
-        klass = interp.newclass "first",
+        klass = parser.newclass "first",
             :code => AST::ASTArray.new(
                 :children => [resourcedef("file", "/tmp",
                         "owner" => "nobody", "mode" => "755")]
             )
 
+        resource = Puppet::Parser::Resource.new(:type => "class", :title => "first", :scope => scope)
         assert_nothing_raised do
-            klass.evaluate(:scope => scope)
+            klass.evaluate(:scope => scope, :resource => resource)
         end
 
         # Then try it again
         assert_nothing_raised do
-            klass.evaluate(:scope => scope)
+            klass.evaluate(:scope => scope, :resource => resource)
         end
 
-        assert(scope.class_scope(klass), "Class was not considered evaluated")
+        assert(scope.compile.class_scope(klass), "Class was not considered evaluated")
 
         tmp = scope.findresource("File[/tmp]")
         assert(tmp, "Could not find file /tmp")
@@ -43,13 +45,13 @@ class TestASTHostClass < Test::Unit::TestCase
         assert_equal("755", tmp[:mode])
 
         # Now create a couple more classes.
-        newbase = interp.newclass "newbase",
+        newbase = parser.newclass "newbase",
             :code => AST::ASTArray.new(
                 :children => [resourcedef("file", "/tmp/other",
                         "owner" => "nobody", "mode" => "644")]
             )
 
-        newsub = interp.newclass "newsub",
+        newsub = parser.newclass "newsub",
             :parent => "newbase",
             :code => AST::ASTArray.new(
                 :children => [resourcedef("file", "/tmp/yay",
@@ -60,7 +62,7 @@ class TestASTHostClass < Test::Unit::TestCase
             )
 
         # Override a different variable in the top scope.
-        moresub = interp.newclass "moresub",
+        moresub = parser.newclass "moresub",
             :parent => "newbase",
             :code => AST::ASTArray.new(
                 :children => [resourceoverride("file", "/tmp/other",
@@ -68,15 +70,15 @@ class TestASTHostClass < Test::Unit::TestCase
             )
 
         assert_nothing_raised do
-            newsub.evaluate(:scope => scope)
+            newsub.evaluate(:scope => scope, :resource => resource)
         end
 
         assert_nothing_raised do
-            moresub.evaluate(:scope => scope)
+            moresub.evaluate(:scope => scope, :resource => resource)
         end
 
-        assert(scope.class_scope(newbase), "Did not eval newbase")
-        assert(scope.class_scope(newsub), "Did not eval newsub")
+        assert(scope.compile.class_scope(newbase), "Did not eval newbase")
+        assert(scope.compile.class_scope(newsub), "Did not eval newsub")
 
         yay = scope.findresource("File[/tmp/yay]")
         assert(yay, "Did not find file /tmp/yay")
@@ -92,19 +94,20 @@ class TestASTHostClass < Test::Unit::TestCase
     # Make sure that classes set their namespaces to themselves.  This
     # way they start looking for definitions in their own namespace.
     def test_hostclass_namespace
-        interp, scope, source = mkclassframing
+        scope = mkscope
+        parser = scope.compile.parser
 
         # Create a new class
         klass = nil
         assert_nothing_raised do
-            klass = interp.newclass "funtest"
+            klass = parser.newclass "funtest"
         end
 
         # Now define a definition in that namespace
 
         define = nil
         assert_nothing_raised do
-            define = interp.newdefine "funtest::mydefine"
+            define = parser.newdefine "funtest::mydefine"
         end
 
         assert_equal("funtest", klass.namespace,
@@ -113,7 +116,7 @@ class TestASTHostClass < Test::Unit::TestCase
         assert_equal("funtest", define.namespace,
             "component namespace was not set in the definition")
 
-        newscope = klass.subscope(scope)
+        newscope = klass.subscope(scope, mock("resource"))
 
         assert_equal(["funtest"], newscope.namespaces,
             "Scope did not inherit namespace")
@@ -127,24 +130,27 @@ class TestASTHostClass < Test::Unit::TestCase
     # At the same time, make sure definitions in the parent class can be
     # found within the subclass (#517).
     def test_parent_scope_from_parentclass
-        interp = mkinterp
+        scope = mkscope
+        parser = scope.compile.parser
 
-        interp.newclass("base")
-        fun = interp.newdefine("base::fun")
-        interp.newclass("middle", :parent => "base")
-        interp.newclass("sub", :parent => "middle")
-        scope = mkscope :interp => interp
+        source = parser.newclass ""
+        parser.newclass("base")
+        fun = parser.newdefine("base::fun")
+        parser.newclass("middle", :parent => "base")
+        parser.newclass("sub", :parent => "middle")
+        scope = mkscope :parser => parser
 
         ret = nil
         assert_nothing_raised do
-            ret = scope.evalclasses("sub")
+            ret = scope.compile.evaluate_classes(["sub"], scope)
         end
+        scope.compile.send(:evaluate_generators)
 
-        subscope = scope.class_scope(scope.findclass("sub"))
+        subscope = scope.compile.class_scope(scope.findclass("sub"))
         assert(subscope, "could not find sub scope")
-        mscope = scope.class_scope(scope.findclass("middle"))
+        mscope = scope.compile.class_scope(scope.findclass("middle"))
         assert(mscope, "could not find middle scope")
-        pscope = scope.class_scope(scope.findclass("base"))
+        pscope = scope.compile.class_scope(scope.findclass("base"))
         assert(pscope, "could not find parent scope")
 
         assert(pscope == mscope.parent, "parent scope of middle was not set correctly")
@@ -158,6 +164,21 @@ class TestASTHostClass < Test::Unit::TestCase
         assert(result, "could not find parent-defined definition from sub")
         assert(fun == result, "found incorrect parent-defined definition from sub")
     end
-end
 
-# $Id: hostclass.rb 2730 2007-07-31 02:34:07Z luke $
+    # #795 - make sure the subclass's tags get set before we
+    # evaluate the parent class, so we can be sure that the parent
+    # class can switch based on the sub classes.
+    def test_tags_set_before_parent_is_evaluated
+        scope = mkscope
+        parser = scope.compile.parser
+        base = parser.newclass "base"
+        sub = parser.newclass "sub", :parent => "base"
+
+        base.expects(:safeevaluate).with do |args|
+            assert(scope.compile.catalog.tags.include?("sub"), "Did not tag with sub class name before evaluating base class")
+            base.evaluate(args)
+            true
+        end
+        sub.evaluate :scope => scope, :resource => scope.resource
+    end
+end