puppet 0.23.0 → 0.23.1

data/test/language/functions.rb

@@ -398,17 +398,17 @@ class TestLangFunctions < Test::Unit::TestCase
         interp = mkinterp
         scope = mkscope(:interp => interp)
         
-        fun = interp.newdefine("fun::test")
+        fun = interp.newdefine("yay::ness")
         foo = interp.newdefine("foo::bar")
 
         search = Puppet::Parser::Functions.function(:search)
         assert_nothing_raised do
-            scope.function_search(["foo", "fun"])
+            scope.function_search(["foo", "yay"])
         end
 
         ffun = ffoo = nil
-        assert_nothing_raised do
-            ffun = scope.finddefine("test")
+        assert_nothing_raised("Search path change did not work") do
+            ffun = scope.finddefine("ness")
             ffoo = scope.finddefine('bar')
         end
 
@@ -529,4 +529,4 @@ class TestLangFunctions < Test::Unit::TestCase
     end
 end
 
-# $Id: functions.rb 2401 2007-04-20 15:59:09Z luke $
+# $Id: functions.rb 2714 2007-07-19 18:12:20Z luke $

data/test/language/interpreter.rb

@@ -853,8 +853,22 @@ class TestInterpreter < PuppetTest::TestCase
 
         assert(scope.classlist.include?("sub"), "NodeDef did not evaluate class")
         assert(scope.classlist.include?("other"), "NodeDef did not evaluate other class")
+
+        # Now make sure nodedef doesn't fail when some classes are not defined (#687).
+        assert_nothing_raised("Could not create a node definition with some invalid classes") do
+            node = NodeDef.new :name => "yay", :classes => %w{base unknown}
+        end
+
+        scope = mkscope :interp => interp
+        assert_nothing_raised("Could not evaluate the node definition with some invalid classes") do
+            node.evaluate(:scope => scope)
+        end
+
+        assert(scope.classlist.include?("base"), "NodeDef did not evaluate class")
     end
 
+    # This can stay in the main test suite because it doesn't actually use ldapsearch,
+    # it just overrides the method so it behaves as though it were hitting ldap.
     def test_ldapnodes
         interp = mkinterp
 
@@ -910,6 +924,120 @@ class TestInterpreter < PuppetTest::TestCase
         assert_equal(%w{one two three four five}.sort, node.classes.sort, "node classes were not set correctly with the top node")
         assert_equal({"base" => "true", "center" => "boo", "master" => "far"}, node.parameters, "node parameters were not set correctly with the top node")
     end
+
+    # Setup a module.
+    def mk_module(name, files = {})
+        mdir = File.join(@dir, name)
+        mandir = File.join(mdir, "manifests")
+        FileUtils.mkdir_p mandir
+
+        if defs = files[:define]
+            files.delete(:define)
+        end
+        Dir.chdir(mandir) do
+            files.each do |file, classes|
+                File.open("%s.pp" % file, "w") do |f|
+                    classes.each { |klass|
+                        if defs
+                            f.puts "define %s {}" % klass
+                        else
+                            f.puts "class %s {}" % klass
+                        end
+                    }
+                end
+            end
+        end
+    end
+
+    # #596 - make sure classes and definitions load automatically if they're in modules, so we don't have to manually load each one.
+    def test_module_autoloading
+        @dir = tempfile
+        Puppet[:modulepath] = @dir
+
+        FileUtils.mkdir_p @dir
+
+        interp = mkinterp
+
+        # Make sure we fail like normal for actually missing classes
+        assert_nil(interp.findclass("", "nosuchclass"), "Did not return nil on missing classes")
+
+        # test the simple case -- the module class itself
+        name = "simple"
+        mk_module(name, :init => [name])
+
+        # Try to load the module automatically now
+        klass = interp.findclass("", name)
+        assert_instance_of(AST::HostClass, klass, "Did not autoload class from module init file")
+        assert_equal(name, klass.classname, "Incorrect class was returned")
+
+        # Try loading the simple module when we're in something other than the base namespace.
+        interp = mkinterp
+        klass = interp.findclass("something::else", name)
+        assert_instance_of(AST::HostClass, klass, "Did not autoload class from module init file")
+        assert_equal(name, klass.classname, "Incorrect class was returned")
+
+        # Now try it with a definition as the base file
+        name = "simpdef"
+        mk_module(name, :define => true, :init => [name])
+
+        klass = interp.finddefine("", name)
+        assert_instance_of(AST::Component, 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
+        interp = mkinterp
+        modname = "both"
+        name = "sub"
+        mk_module(modname, :init => %w{both both::sub})
+
+        # First try it with a namespace
+        klass = interp.findclass("both", name)
+        assert_instance_of(AST::HostClass, klass, "Did not autoload sub class from module init file with a namespace")
+        assert_equal("both::sub", klass.classname, "Incorrect class was returned")
+
+        # Now try it using the fully qualified name
+        interp = mkinterp
+        klass = interp.findclass("", "both::sub")
+        assert_instance_of(AST::HostClass, klass, "Did not autoload sub class from module init file with no namespace")
+        assert_equal("both::sub", klass.classname, "Incorrect class was returned")
+
+
+        # Now try it with the class in a different file
+        interp = mkinterp
+        modname = "separate"
+        name = "sub"
+        mk_module(modname, :init => %w{separate}, :sub => %w{separate::sub})
+
+        # First try it with a namespace
+        klass = interp.findclass("separate", name)
+        assert_instance_of(AST::HostClass, klass, "Did not autoload sub class from separate file with a namespace")
+        assert_equal("separate::sub", klass.classname, "Incorrect class was returned")
+
+        # Now try it using the fully qualified name
+        interp = mkinterp
+        klass = interp.findclass("", "separate::sub")
+        assert_instance_of(AST::HostClass, klass, "Did not autoload sub class from separate file with no namespace")
+        assert_equal("separate::sub", klass.classname, "Incorrect class was returned")
+
+        # Now make sure we don't get a failure when there's no module file
+        interp = mkinterp
+        modname = "alone"
+        name = "sub"
+        mk_module(modname, :sub => %w{alone::sub})
+
+        # First try it with a namespace
+        assert_nothing_raised("Could not autoload file when module file is missing") do
+            klass = interp.findclass("alone", name)
+        end
+        assert_instance_of(AST::HostClass, klass, "Did not autoload sub class from alone file with a namespace")
+        assert_equal("alone::sub", klass.classname, "Incorrect class was returned")
+
+        # Now try it using the fully qualified name
+        interp = mkinterp
+        klass = interp.findclass("", "alone::sub")
+        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
 end
 
 class LdapNodeTest < PuppetTest::TestCase
@@ -1043,4 +1171,4 @@ class LdapReconnectTests < PuppetTest::TestCase
     end
 end
 
-# $Id: interpreter.rb 2597 2007-06-17 21:41:50Z luke $
+# $Id: interpreter.rb 2686 2007-07-12 19:49:41Z luke $

data/test/language/node.rb

@@ -17,16 +17,26 @@ class TestParser < Test::Unit::TestCase
     def test_simple_hostname
         check_parseable "host1"
         check_parseable "'host2'"
+        check_parseable "\"host3\""
         check_parseable [ "'host1'",  "host2" ]
         check_parseable [ "'host1'",  "'host2'" ]
+        check_parseable [ "'host1'",  "\"host2\"" ]
+        check_parseable [ "\"host1\"",  "host2" ]
+        check_parseable [ "\"host1\"",  "'host2'" ]
+        check_parseable [ "\"host1\"",  "\"host2\"" ]
     end
 
     def test_qualified_hostname
         check_parseable "'host.example.com'"
+        check_parseable "\"host.example.com\""
         check_parseable [ "'host.example.com'", "host1" ]
+        check_parseable [ "\"host.example.com\"", "host1" ]
         check_parseable "'host-1.37examples.example.com'"
+        check_parseable "\"host-1.37examples.example.com\""
         check_parseable "'svn.23.nu'"
+        check_parseable "\"svn.23.nu\""
         check_parseable "'HOST'"
+        check_parseable "\"HOST\""
     end
     
     def test_inherits_from_default
@@ -36,9 +46,10 @@ class TestParser < Test::Unit::TestCase
     def test_reject_hostname
         check_nonparseable "host.example.com"
         check_nonparseable "host@example.com"
-        check_nonparseable "\"host\""
         check_nonparseable "'$foo.example.com'"
+        check_nonparseable "\"$foo.example.com\""
         check_nonparseable "'host1 host2'"
+        check_nonparseable "\"host1 host2\""
         check_nonparseable "HOST"
     end
 
@@ -54,7 +65,7 @@ class TestParser < Test::Unit::TestCase
             interp = mkinterp :Code => code
         }
         # Strip quotes
-        hostnames.map! { |s| s.sub(/^'(.*)'$/, "\\1") }
+        hostnames.map! { |s| s.sub(/^['"](.*)['"]$/, "\\1") }
 
         # parse
         assert_nothing_raised {

data/test/language/resource.rb

@@ -69,6 +69,31 @@ class TestResource < PuppetTest::TestCase
         end
     end
 
+    def check_paramadd(val1, val2, merged_val)
+        res = mkresource :params => {"one" => val1}
+        assert_nothing_raised do
+            res.set Parser::Resource::Param.new(
+                        :name => "one", :value => val2,
+                        :add => true, :source => @scope.findclass("sub1"))
+        end
+        assert_equal(merged_val, res[:one])
+    end
+
+    def test_paramadd
+        check_paramadd([], [], [])
+        check_paramadd([], "rah", ["rah"])
+        check_paramadd([], ["rah", "bah"], ["rah", "bah"])
+
+        check_paramadd("yay", [], ["yay"])
+        check_paramadd("yay", "rah", ["yay", "rah"])
+        check_paramadd("yay", ["rah", "bah"], ["yay", "rah", "bah"])
+
+        check_paramadd(["yay", "boo"], [], ["yay", "boo"])
+        check_paramadd(["yay", "boo"], "rah", ["yay", "boo", "rah"])
+        check_paramadd(["yay", "boo"], ["rah", "bah"],
+                       ["yay", "boo", "rah", "bah"])
+    end
+
     def test_merge
         # Start with the normal one
         res = mkresource
@@ -498,4 +523,4 @@ class TestResource < PuppetTest::TestCase
     end
 end
 
-# $Id: resource.rb 2597 2007-06-17 21:41:50Z luke $
+# $Id: resource.rb 2670 2007-07-10 15:31:19Z luke $

data/test/language/scope.rb

@@ -325,13 +325,13 @@ class TestScope < Test::Unit::TestCase
 
         base = scope.findclass("base")
         assert(base, "Could not find base class")
-        assert(! scope.setclass?(base), "Class incorrectly set")
+        assert(! scope.class_scope(base), "Class incorrectly set")
         assert(! scope.classlist.include?("base"), "Class incorrectly in classlist")
         assert_nothing_raised do
             scope.setclass base
         end
 
-        assert(scope.setclass?(base), "Class incorrectly unset")
+        assert(scope.class_scope(base), "Class incorrectly unset")
         assert(scope.classlist.include?("base"), "Class not in classlist")
 
         # Make sure we can retrieve the scope.
@@ -344,7 +344,7 @@ class TestScope < Test::Unit::TestCase
             scope.setclass "string"
         end
 
-        assert(! scope.setclass?("string"), "string incorrectly set")
+        assert(! scope.class_scope("string"), "string incorrectly set")
 
         # Set "" in the class list, and make sure it doesn't show up in the return
         top = scope.findclass("")
@@ -411,7 +411,7 @@ class TestScope < Test::Unit::TestCase
         end
 
         [myclass, otherclass].each do |klass|
-            assert(scope.setclass?(klass),
+            assert(scope.class_scope(klass),
                 "%s was not set" % klass.classname)
         end
     end
@@ -760,6 +760,26 @@ Host <<||>>"
         assert_equal("", scope.lookupvar("testing", true),
             "undef was not returned as '' when string")
     end
+
+    # #620 - Nodes and classes should conflict, else classes don't get evaluated
+    def test_nodes_and_classes_name_conflict
+        scope = mkscope
+        
+        node = AST::Node.new :classname => "test", :namespace => ""
+        scope.setclass(node)
+
+        assert(scope.nodescope?, "Scope was not marked a node scope when a node was set")
+
+        # Now make a subscope that will be a class scope
+        klass = AST::HostClass.new :classname => "test", :namespace => ""
+        kscope = klass.subscope(scope)
+
+        # Now make sure we throw a failure, because we're trying to do a class and node
+        # with the same name
+        assert_raise(Puppet::ParseError, "Did not fail on class and node with same name") do
+            kscope.class_scope(klass)
+        end
+    end
 end
 
-# $Id: scope.rb 2523 2007-05-17 21:51:36Z luke $
+# $Id: scope.rb 2646 2007-07-04 21:06:26Z luke $

data/test/lib/puppettest/support/collection.rb

@@ -1,7 +1,7 @@
 
 module PuppetTest::Support::Collection
     def run_collection_queries(form)
-        {true => [%{title == "/tmp/testing"}, %{(title == "/tmp/testing")},
+        {true => [%{title == "/tmp/testing"}, %{(title == "/tmp/testing")}, %{group == bin},
             %{title == "/tmp/testing" and group == bin}, %{title == bin or group == bin},
             %{title == "/tmp/testing" or title == bin}, %{title == "/tmp/testing"},
             %{(title == "/tmp/testing" or title == bin) and group == bin}],
@@ -27,4 +27,4 @@ module PuppetTest::Support::Collection
     end
 end
 
-# $Id: collection.rb 2597 2007-06-17 21:41:50Z luke $
+# $Id: collection.rb 2705 2007-07-18 17:32:46Z luke $

data/test/network/client/master.rb

@@ -261,65 +261,41 @@ class TestMasterClient < Test::Unit::TestCase
     end
 
     def test_getplugins
+        Puppet[:filetimeout] = -1
         Puppet[:pluginsource] = tempfile()
         Dir.mkdir(Puppet[:pluginsource])
+        Dir.mkdir(File.join(Puppet[:pluginsource], "testing"))
 
-        myplugin = File.join(Puppet[:pluginsource], "myplugin.rb")
+        $loaded = []
+        loader = Puppet::Util::Autoload.new(self, "testing")
+
+        myplugin = File.join(Puppet[:pluginsource], "testing", "myplugin.rb")
         File.open(myplugin, "w") do |f|
-            f.puts %{Puppet::Type.newtype(:myplugin) do
-    newparam(:argument) do
-        isnamevar
-    end
-end
-}
+            f.puts %{$loaded << :myplugin}
         end
 
-        assert_nothing_raised {
+        assert_nothing_raised("Could not get plugins") {
             Puppet::Network::Client.master.getplugins
         }
 
-        destfile = File.join(Puppet[:plugindest], "myplugin.rb")
+        destfile = File.join(Puppet[:plugindest], "testing", "myplugin.rb")
 
         assert(File.exists?(destfile), "Did not get plugin")
 
-        obj = Puppet::Type.type(:myplugin)
-
-        assert(obj, "Did not define type")
+        assert(loader.load(:myplugin), "Did not load downloaded plugin")
 
-        assert(obj.validattr?(:argument),
-            "Did not get namevar")
+        assert($loaded.include?(:myplugin), "Downloaded code was not evaluated")
 
         # Now modify the file and make sure the type is replaced
         File.open(myplugin, "w") do |f|
-            f.puts %{Puppet::Type.newtype(:myplugin) do
-    newparam(:yayness) do
-        isnamevar
-    end
-
-    newparam(:rahness) do
-    end
-end
-}
+            f.puts %{$loaded << :changed}
         end
 
-        assert_nothing_raised {
+        assert_nothing_raised("Could not get plugin changes") {
             Puppet::Network::Client.master.getplugins
         }
 
-        destfile = File.join(Puppet[:pluginpath], "myplugin.rb")
-
-        obj = Puppet::Type.type(:myplugin)
-
-        assert(obj, "Did not define type")
-
-        assert(obj.validattr?(:yayness),
-            "Did not get namevar")
-
-        assert(obj.validattr?(:rahness),
-            "Did not get other var")
-
-        assert(! obj.validattr?(:argument),
-            "Old namevar is still valid")
+        assert($loaded.include?(:changed), "Changed code was not evaluated")
 
         # Now try it again, to make sure we don't have any objects lying around
         assert_nothing_raised {
@@ -328,6 +304,7 @@ end
     end
 
     def test_getfacts
+        Puppet[:filetimeout] = -1
         Puppet[:factsource] = tempfile()
         Dir.mkdir(Puppet[:factsource])
         hostname = Facter.value(:hostname)
@@ -616,9 +593,7 @@ end
             end
         end
 
-        assert_raise(ArgumentError, "did not fail") do
-            master.run
-        end
+        master.run
 
         assert(! master.send(:lockfile).locked?,
             "Master is still locked after failure")
@@ -723,6 +698,17 @@ end
         assert(FileTest.exists?(@createdfile), "File does not exist on disk")
         assert_nil(ftype[@createdfile], "file object was not removed from memory")
     end
+
+    # #685
+    def test_http_failures_do_not_kill_puppetd
+        client = mkclient
+
+        client.meta_def(:getconfig) { raise "A failure" }
+
+        assert_nothing_raised("Failure in getconfig threw an error") do
+            client.run
+        end
+    end
 end
 
-# $Id: master.rb 2545 2007-05-31 22:47:01Z luke $
+# $Id: master.rb 2669 2007-07-10 04:17:07Z luke $