puppet 0.24.9 → 0.25.0

data/test/language/resource.rb

@@ -6,7 +6,7 @@ require 'puppettest'
 require 'puppettest/resourcetesting'
 
 class TestResource < PuppetTest::TestCase
-	include PuppetTest
+    include PuppetTest
     include PuppetTest::ParserTesting
     include PuppetTest::ResourceTesting
     Parser = Puppet::Parser
@@ -39,9 +39,8 @@ class TestResource < PuppetTest::TestCase
         params = res.instance_variable_get("@params")
 
         # First test the simple case:  It's already a parameter
-        param = mock('param')
+        param = stub('param', :name => "pname")
         param.expects(:is_a?).with(Resource::Param).returns(true)
-        param.expects(:name).returns("pname")
         res.send(:set_parameter, param)
         assert_equal(param, params["pname"], "Parameter was not added to hash")
 
@@ -84,53 +83,6 @@ class TestResource < PuppetTest::TestCase
         res.send(:paramcheck, :other)
     end
 
-    def test_to_transobject
-        # First try translating a builtin resource.  Make sure we use some references
-        # and arrays, to make sure they translate correctly.
-        source = mock("source")
-        scope = mkscope
-        scope.stubs(:tags).returns([])
-        refs = []
-        4.times { |i| refs << Puppet::Parser::Resource::Reference.new(:title => "file%s" % i, :type => "file") }
-        res = Parser::Resource.new :type => "file", :title => "/tmp",
-            :source => source, :scope => scope,
-            :params => paramify(source, :owner => "nobody", :group => %w{you me},
-            :require => refs[0], :ignore => %w{svn},
-            :subscribe => [refs[1], refs[2]], :notify => [refs[3]])
-
-        obj = nil
-        assert_nothing_raised do
-            obj = res.to_trans
-        end
-
-        assert_instance_of(Puppet::TransObject, obj)
-
-        assert_equal(obj.type, res.type.downcase)
-        assert_equal(obj.name, res.title)
-
-        # TransObjects use strings, resources use symbols
-        assert_equal("nobody", obj["owner"], "Single-value string was not passed correctly")
-        assert_equal(%w{you me}, obj["group"], "Array of strings was not passed correctly")
-        assert_equal("svn", obj["ignore"], "Array with single string was not turned into single value")
-        assert_equal(["file", refs[0].title], obj["require"], "Resource reference was not passed correctly")
-        assert_equal([["file", refs[1].title], ["file", refs[2].title]], obj["subscribe"], "Array of resource references was not passed correctly")
-        assert_equal(["file", refs[3].title], obj["notify"], "Array with single resource reference was not turned into single value")
-    end
-
-    # FIXME This isn't a great test, but I need to move on.
-    def test_to_transbucket
-        bucket = mock("transbucket")
-        source = mock("source")
-        scope = mkscope
-        res = Parser::Resource.new :type => "mydefine", :title => "yay",
-            :source => source, :scope => scope
-
-
-        result = res.to_trans
-        assert_equal("yay", result.name, "did not set bucket name correctly")
-        assert_equal("Mydefine", result.type, "did not set bucket type correctly")
-    end
-
     def test_evaluate
         # First try the most common case, we're not a builtin type.
         res = mkresource
@@ -154,43 +106,6 @@ class TestResource < PuppetTest::TestCase
         assert_equal(false, res.builtin?)
     end
 
-    def test_reference_conversion
-        # First try it as a normal string
-        ref = Parser::Resource::Reference.new(:type => "file", :title => "/tmp/ref1")
-
-        # Now create an obj that uses it
-        res = mkresource :type => "file", :title => "/tmp/resource",
-            :params => {:require => ref}
-        res.scope = mkscope
-
-        trans = nil
-        assert_nothing_raised do
-            trans = res.to_trans
-        end
-
-        assert_instance_of(Array, trans["require"])
-        assert_equal(["file", "/tmp/ref1"], trans["require"])
-
-        # Now try it when using an array of references.
-        two = Parser::Resource::Reference.new(:type => "file", :title => "/tmp/ref2")
-        res = mkresource :type => "file", :title => "/tmp/resource2",
-            :params => {:require => [ref, two]}
-        res.scope = mkscope
-
-        trans = nil
-        assert_nothing_raised do
-            trans = res.to_trans
-        end
-
-        assert_instance_of(Array, trans["require"][0])
-        trans["require"].each do |val|
-            assert_instance_of(Array, val)
-            assert_equal("file", val[0])
-            assert(val[1] =~ /\/tmp\/ref[0-9]/,
-                "Was %s instead of the file name" % val[1])
-        end
-    end
-
     # This is a bit of a weird one -- the user should not actually know
     # that components exist, so we want references to act like they're not
     # builtin
@@ -209,7 +124,7 @@ class TestResource < PuppetTest::TestCase
                 "owner" => varref("name"), "mode" => varref("title"))
 
 
-        klass = parser.findclass("", "")
+        klass = parser.find_hostclass("", "")
         should = {:name => :owner, :title => :mode}
         [
         {:name => "one", :title => "two"},

data/test/language/scope.rb

@@ -83,56 +83,6 @@ class TestScope < Test::Unit::TestCase
                      "botscope values shadow parent scope values")
     end
 
-    def test_lookupvar
-        parser = mkparser
-        scope = mkscope :parser => parser
-
-        # first do the plain lookups
-        assert_equal("", scope.lookupvar("var"), "scope did not default to string")
-        assert_equal("", scope.lookupvar("var", true), "scope ignored usestring setting")
-        assert_equal(:undefined, scope.lookupvar("var", false), "scope ignored usestring setting when false")
-
-        # Now set the var
-        scope.setvar("var", "yep")
-        assert_equal("yep", scope.lookupvar("var"), "did not retrieve value correctly")
-
-        # Now test the parent lookups 
-        subscope = mkscope :parser => parser
-        subscope.parent = scope
-        assert_equal("", subscope.lookupvar("nope"), "scope did not default to string with parent")
-        assert_equal("", subscope.lookupvar("nope", true), "scope ignored usestring setting with parent")
-        assert_equal(:undefined, subscope.lookupvar("nope", false), "scope ignored usestring setting when false with parent")
-
-        assert_equal("yep", subscope.lookupvar("var"), "did not retrieve value correctly from parent")
-
-        # Now override the value in the subscope
-        subscope.setvar("var", "sub")
-        assert_equal("sub", subscope.lookupvar("var"), "did not retrieve overridden value correctly")
-
-        # Make sure we punt when the var is qualified.  Specify the usestring value, so we know it propagates.
-        scope.expects(:lookup_qualified_var).with("one::two", false).returns(:punted)
-        assert_equal(:punted, scope.lookupvar("one::two", false), "did not return the value of lookup_qualified_var")
-    end
-
-    def test_lookup_qualified_var
-        parser = mkparser
-        scope = mkscope :parser => parser
-
-        scopes = {}
-        classes = ["", "one", "one::two", "one::two::three"].each do |name|
-            klass = parser.newclass(name)
-            Puppet::Parser::Resource.new(:type => "class", :title => name, :scope => scope, :source => mock('source')).evaluate
-            scopes[name] = scope.compiler.class_scope(klass)
-        end
-
-        classes.each do |name|
-            var = [name, "var"].join("::")
-            scopes[name].expects(:lookupvar).with("var", false).returns(name)
-
-            assert_equal(name, scope.send(:lookup_qualified_var, var, false), "did not get correct value from lookupvar")
-        end
-    end
-
     def test_declarative
         # set to declarative
         top = mkscope
@@ -216,7 +166,7 @@ class TestScope < Test::Unit::TestCase
         assert_equal(top, sub.parent, "Did not find parent scope correctly")
         assert_equal(top, sub.parent, "Did not find parent scope on second call")
     end
-    
+
     def test_strinterp
         # Make and evaluate our classes so the qualified lookups work
         parser = mkparser
@@ -288,6 +238,7 @@ class TestScope < Test::Unit::TestCase
     end
 
     def test_tagfunction
+        Puppet::Parser::Functions.function(:tag)
         scope = mkscope
         resource = mock 'resource'
         scope.resource = resource
@@ -324,6 +275,7 @@ class TestScope < Test::Unit::TestCase
     end
 
     def test_definedfunction
+        Puppet::Parser::Functions.function(:defined)
         parser = mkparser
         %w{one two}.each do |name|
             parser.newdefine name
@@ -402,11 +354,14 @@ class TestScope < Test::Unit::TestCase
         end
     end
 
-    if defined? ActiveRecord
+    if defined? ::ActiveRecord
     # Verify that we can both store and collect an object in the same
     # run, whether it's in the same scope as a collection or a different
     # scope.
     def test_storeandcollect
+        catalog_cache_class = Puppet::Resource::Catalog.indirection.cache_class
+        facts_cache_class = Puppet::Node::Facts.indirection.cache_class
+        node_cache_class = Puppet::Node.indirection.cache_class
         Puppet[:storeconfigs] = true
         Puppet::Rails.init
         sleep 1
@@ -440,6 +395,10 @@ Host <<||>>"
                 assert(flat.find{|o| o.name == name }, "Did not find #{name}")
             end
         }
+        Puppet[:storeconfigs] = false
+        Puppet::Resource::Catalog.cache_class =  catalog_cache_class
+        Puppet::Node::Facts.cache_class = facts_cache_class
+        Puppet::Node.cache_class = node_cache_class
     end
     else
         $stderr.puts "No ActiveRecord -- skipping collection tests"
@@ -458,16 +417,16 @@ Host <<||>>"
             "Did not add extra namespace correctly")
     end
 
-    def test_findclass_and_finddefine
+    def test_find_hostclass_and_find_definition
         parser = mkparser
 
-        # Make sure our scope calls the parser findclass method with
+        # Make sure our scope calls the parser find_hostclass method with
         # the right namespaces
         scope = mkscope :parser => parser
 
         parser.metaclass.send(:attr_accessor, :last)
 
-        methods = [:findclass, :finddefine]
+        methods = [:find_hostclass, :find_definition]
         methods.each do |m|
             parser.meta_def(m) do |namespace, name|
                 @checked ||= []

data/test/language/snippets.rb

@@ -10,7 +10,7 @@ require 'puppet/network/handler'
 require 'puppettest'
 
 class TestSnippets < Test::Unit::TestCase
-	include PuppetTest
+    include PuppetTest
 
     def setup
         super
@@ -24,21 +24,21 @@ class TestSnippets < Test::Unit::TestCase
     end
 
     def assert_file(path, msg = nil)
-        unless file = @file[path]
+        unless file = @catalog.resource(:file, path)
             msg ||= "Could not find file %s" % path
             raise msg
         end
     end
 
     def assert_not_file(path, msg = nil)
-        if file = @file[path]
+        if file = @catalog.resource(:file, path)
             msg ||= "File %s exists!" % path
             raise msg
         end
     end
 
     def assert_mode_equal(mode, path)
-        unless file = @file[path]
+        unless file = @catalog.resource(:file, path)
             raise "Could not find file %s" % path
         end
 
@@ -50,7 +50,7 @@ class TestSnippets < Test::Unit::TestCase
     def snippet(name)
         File.join(self.class.snippetdir, name)
     end
-    
+
     def file2ast(file)
         parser = Puppet::Parser::Parser.new()
         parser.file = file
@@ -142,7 +142,7 @@ class TestSnippets < Test::Unit::TestCase
     def disabled_test_defaults
         Puppet::Type.eachtype { |type|
             next if type.name == :puppet or type.name == :component
-            
+
             rands = randeach(type)
 
             name = type.name.to_s.capitalize
@@ -220,8 +220,8 @@ class TestSnippets < Test::Unit::TestCase
         path1 = "/tmp/argumenttest1"
         path2 = "/tmp/argumenttest2"
 
-        file1 = @file[path1]
-        file2 = @file[path2]
+        file1 = @catalog.resource(:file, path1)
+        file2 = @catalog.resource(:file, path2)
 
         assert_file(path1)
         assert_mode_equal(0755, path1)
@@ -237,10 +237,11 @@ class TestSnippets < Test::Unit::TestCase
             /tmp/existsfile3
             /tmp/existsfile4
             /tmp/existsfile5
+            /tmp/existsfile6
         }
 
         paths.each { |path|
-            file = @file[path]
+            file = @catalog.resource(:file, path)
             assert(file, "File %s is missing" % path)
             assert_mode_equal(0755, path)
         }
@@ -250,7 +251,7 @@ class TestSnippets < Test::Unit::TestCase
         paths = %w{a b c d e f g h}.collect { |l| "/tmp/iteration%stest" % l }
 
         paths.each { |path|
-            file = @file[path]
+            file = @catalog.resource(:file, path)
             assert_file(path)
             assert_mode_equal(0755, path)
         }
@@ -271,7 +272,7 @@ class TestSnippets < Test::Unit::TestCase
         dir = "/tmp/testdirtest"
         assert_file(file)
         assert_file(dir)
-        assert_equal(:directory, @file[dir].should(:ensure), "Directory is not set to be a directory")
+        assert_equal(:directory, @catalog.resource(:file, dir).should(:ensure), "Directory is not set to be a directory")
     end
 
     def snippet_scopetest
@@ -281,7 +282,7 @@ class TestSnippets < Test::Unit::TestCase
     end
 
     def snippet_selectorvalues
-        nums = %w{1 2 3 4 5}
+        nums = %w{1 2 3 4 5 6 7}
         files = nums.collect { |n|
             "/tmp/selectorvalues%s" % n
         }
@@ -358,7 +359,7 @@ class TestSnippets < Test::Unit::TestCase
         }.each { |count, str|
             path = "/tmp/singlequote%s" % count
             assert_file(path)
-            assert_equal(str, @file[path].should(:content))
+            assert_equal(str, @catalog.resource(:file, path).parameter(:content).actual_content)
         }
     end
 
@@ -396,21 +397,20 @@ class TestSnippets < Test::Unit::TestCase
     end
 
     def snippet_emptyexec
-        assert(Puppet::Type.type(:exec)["touch /tmp/emptyexectest"],
-            "Did not create exec")
+        assert(@catalog.resource(:exec, "touch /tmp/emptyexectest"), "Did not create exec")
     end
 
     def snippet_multisubs
         path = "/tmp/multisubtest"
         assert_file(path)
-        file = @file[path]
-        assert_equal("sub2", file.should(:content), "sub2 did not override content")
+        file = @catalog.resource(:file, path)
+        assert_equal("{md5}5fbef65269a99bddc2106251dd89b1dc", file.should(:content), "sub2 did not override content")
         assert_mode_equal(0755, path)
     end
 
     def snippet_collection
         assert_file("/tmp/colltest1")
-        assert_nil(@file["/tmp/colltest2"], "Incorrectly collected file")
+        assert_nil(@catalog.resource(:file, "/tmp/colltest2"), "Incorrectly collected file")
     end
 
     def snippet_virtualresources
@@ -418,7 +418,7 @@ class TestSnippets < Test::Unit::TestCase
             assert_file("/tmp/virtualtest#{num}")
         end
     end
-    
+
     def snippet_componentrequire
         %w{1 2}.each do |num|
             assert_file("/tmp/testing_component_requires#{num}",
@@ -471,11 +471,21 @@ class TestSnippets < Test::Unit::TestCase
         assert_file("/tmp/multipleclassone", "one")
         assert_file("/tmp/multipleclasstwo", "two")
     end
-    
+
     def snippet_multilinecomments
         assert_not_file("/tmp/multilinecomments","Did create a commented resource");
     end
 
+    def snippet_collection_override
+        path = "/tmp/collection"
+        assert_file(path)
+        assert_mode_equal(0600, path)
+    end
+
+    def snippet_ifexpression
+        assert_file("/tmp/testiftest","if test");
+    end
+
     # Iterate across each of the snippets and create a test.
     Dir.entries(snippetdir).sort.each { |file|
         next if file =~ /^\./
@@ -499,23 +509,13 @@ class TestSnippets < Test::Unit::TestCase
 
                 catalog = nil
                 assert_nothing_raised("Could not compile catalog") {
-                    catalog = Puppet::Node::Catalog.find(node)
+                    catalog = Puppet::Resource::Catalog.find(node)
                 }
 
                 assert_nothing_raised("Could not convert catalog") {
                     catalog = catalog.to_ral
                 }
 
-                Puppet::Type.eachtype { |type|
-                    type.each { |obj|
-                        # don't worry about this for now
-                        #unless obj.name == "puppet[top]" or
-                        #    obj.is_a?(Puppet.type(:schedule))
-                        #    assert(obj.parent, "%s has no parent" % obj.name)
-                        #end
-                        assert(obj.name)
-                    }
-                }
                 @catalog = catalog
                 assert_nothing_raised {
                     self.send(mname)

data/test/lib/puppettest.rb

@@ -8,7 +8,7 @@ $LOAD_PATH.unshift(mainlib) unless $LOAD_PATH.include?(mainlib)
 require 'puppet'
 
 # include any gems in vendor/gems
-Dir["#{mainlib}/../vendor/gems/**"].each do |path| 
+Dir["#{mainlib}/../vendor/gems/**"].each do |path|
     libpath = File.join(path, "lib")
     if File.directory?(libpath)
         $LOAD_PATH.unshift(libpath)
@@ -53,10 +53,10 @@ module PuppetTest
         require 'getoptlong'
 
         result = GetoptLong.new(
-            [ "--debug",	"-d",			GetoptLong::NO_ARGUMENT ],
-            [ "--resolve",	"-r",			GetoptLong::REQUIRED_ARGUMENT ],
-            [ "-n",			                GetoptLong::REQUIRED_ARGUMENT ],
-            [ "--help",		"-h",			GetoptLong::NO_ARGUMENT ]
+            [ "--debug",    "-d", GetoptLong::NO_ARGUMENT       ],
+            [ "--resolve",  "-r", GetoptLong::REQUIRED_ARGUMENT ],
+            [ "-n",               GetoptLong::REQUIRED_ARGUMENT ],
+            [ "--help",     "-h", GetoptLong::NO_ARGUMENT       ]
         )
 
         usage = "USAGE: TESTOPTS='[-n <method> -n <method> ...] [-d]' rake [target] [target] ..."
@@ -138,7 +138,7 @@ module PuppetTest
 
         ENV["RUBYLIB"] = curlibs.join(":")
     end
-    
+
     def logcollector
         collector = []
         Puppet::Util::Log.newdestination(collector)
@@ -217,7 +217,7 @@ module PuppetTest
             end
             Puppet::Util::Log.level = :debug
             #$VERBOSE = 1
-        #else    
+        #else
         #    Puppet::Util::Log.close
         #    Puppet::Util::Log.newdestination(@logs)
         #    Puppet[:httplog] = tempfile()
@@ -236,10 +236,11 @@ module PuppetTest
         end
 
         f = File.join(self.tmpdir(), "tempfile_" + @@tmpfilenum.to_s)
+        @@tmpfiles ||= []
         @@tmpfiles << f
         return f
     end
-    
+
     def textmate?
         if ENV["TM_FILENAME"]
             return true
@@ -257,8 +258,8 @@ module PuppetTest
     def tmpdir
         unless defined? @tmpdir and @tmpdir
             @tmpdir = case Facter["operatingsystem"].value
-                      when "Darwin": "/private/tmp"
-                      when "SunOS": "/var/tmp"
+                      when "Darwin"; "/private/tmp"
+                      when "SunOS"; "/var/tmp"
                       else
                             "/tmp"
                       end
@@ -301,11 +302,10 @@ module PuppetTest
 
         @@tmppids.clear
 
-        Puppet::Type.allclear
         Puppet::Util::Storage.clear
         Puppet.clear
         Puppet.settings.clear
-        Puppet::Indirector::Indirection.clear_cache
+        Puppet::Util::Cacher.expire
 
         @memoryatend = Puppet::Util.memory
         diff = @memoryatend - @memoryatstart