puppet 0.24.1 → 0.24.2

data/test/language/ast/casestatement.rb

@@ -45,7 +45,7 @@ class TestCaseStatement < Test::Unit::TestCase
 
         result = nil
         assert_nothing_raised do
-            result = ast.evaluate :scope => scope
+            result = ast.evaluate scope
         end
         assert(result, "did not get valid result")
         assert_equal(["upper"], $evaluated, "Did not match case-sensitively")
@@ -56,7 +56,7 @@ class TestCaseStatement < Test::Unit::TestCase
         $evaluated.clear
         hash["MyParam"].reset
         assert_nothing_raised do
-            result = ast.evaluate :scope => scope
+            result = ast.evaluate scope
         end
         assert(result, "did not get valid result")
         assert_equal(["lower"], result, "Did not match case-insensitively")
@@ -92,7 +92,7 @@ class TestCaseStatement < Test::Unit::TestCase
                 scope = mkscope
                 scope.setvar("testparam", value)
                 assert_nothing_raised do
-                    result = ast.evaluate(:scope => scope)
+                    result = ast.evaluate(scope)
                 end
 
                 assert_equal(should, result, "Got incorrect result for %s" % value)

data/test/language/ast/resource.rb

@@ -16,8 +16,7 @@ class TestASTResource< Test::Unit::TestCase
     def setup
         super
         @scope = mkscope
-        @parser = @scope.compile.parser
-        @scope.compile.send(:evaluate_main)
+        @parser = @scope.compiler.parser
     end
 
     def newdef(type, title, params = nil)
@@ -36,24 +35,24 @@ class TestASTResource< Test::Unit::TestCase
         title = "title"
 
         # First try a qualified type
-        assert_equal("One::Two", newdef("two", title).evaluate(:scope => twoscope)[0].type,
+        assert_equal("One::Two", newdef("two", title).evaluate(twoscope)[0].type,
             "Defined type was not made fully qualified")
 
         # Then try a type that does not need to be qualified
-        assert_equal("One", newdef("one", title).evaluate(:scope => twoscope)[0].type,
+        assert_equal("One", newdef("one", title).evaluate(twoscope)[0].type,
             "Unqualified defined type was not handled correctly")
 
         # Then an unqualified type from within the one namespace
-        assert_equal("Three", newdef("three", title).evaluate(:scope => twoscope)[0].type,
+        assert_equal("Three", newdef("three", title).evaluate(twoscope)[0].type,
             "Defined type was not made fully qualified")
 
         # Then a builtin type
-        assert_equal("File", newdef("file", title).evaluate(:scope => twoscope)[0].type,
+        assert_equal("File", newdef("file", title).evaluate(twoscope)[0].type,
             "Builtin type was not handled correctly")
 
         # Now try a type that does not exist, which should throw an error.
         assert_raise(Puppet::ParseError, "Did not fail on a missing type in a resource reference") do
-            newdef("nosuchtype", title).evaluate(:scope => twoscope)
+            newdef("nosuchtype", title).evaluate(twoscope)
         end
     end
 end

data/test/language/ast/resource_reference.rb

@@ -20,7 +20,7 @@ class TestASTResourceReference < Test::Unit::TestCase
     def setup
         super
         @scope = mkscope
-        @parser = @scope.compile.parser
+        @parser = @scope.compiler.parser
     end
 
     def test_evaluate
@@ -31,7 +31,7 @@ class TestASTResourceReference < Test::Unit::TestCase
 
             evaled = nil
             assert_nothing_raised("Could not evaluate resource ref") do
-                evaled = ref.evaluate(:scope => @scope)
+                evaled = ref.evaluate(@scope)
             end
 
             assert_equal(type, evaled.type, "Type did not translate correctly")
@@ -44,7 +44,7 @@ class TestASTResourceReference < Test::Unit::TestCase
         ref = newref("Class", "one")
         evaled = nil
         assert_nothing_raised("Could not evaluate resource ref") do
-            evaled = ref.evaluate(:scope => @scope)
+            evaled = ref.evaluate(@scope)
         end
 
         assert_equal("Class", evaled.type, "Did not set type to 'class'")
@@ -61,24 +61,24 @@ class TestASTResourceReference < Test::Unit::TestCase
         title = "title"
 
         # First try a qualified type
-        assert_equal("One::Two", newref("two", title).evaluate(:scope => twoscope).type,
+        assert_equal("One::Two", newref("two", title).evaluate(twoscope).type,
             "Defined type was not made fully qualified")
 
         # Then try a type that does not need to be qualified
-        assert_equal("One", newref("one", title).evaluate(:scope => twoscope).type,
+        assert_equal("One", newref("one", title).evaluate(twoscope).type,
             "Unqualified defined type was not handled correctly")
 
         # Then an unqualified type from within the one namespace
-        assert_equal("Three", newref("three", title).evaluate(:scope => twoscope).type,
+        assert_equal("Three", newref("three", title).evaluate(twoscope).type,
             "Defined type was not made fully qualified")
 
         # Then a builtin type
-        assert_equal("File", newref("file", title).evaluate(:scope => twoscope).type,
+        assert_equal("File", newref("file", title).evaluate(twoscope).type,
             "Builtin type was not handled correctly")
 
         # Now try a type that does not exist, which should throw an error.
         assert_raise(Puppet::ParseError, "Did not fail on a missing type in a resource reference") do
-            newref("nosuchtype", title).evaluate(:scope => twoscope)
+            newref("nosuchtype", title).evaluate(twoscope)
         end
 
         # Now run the same tests, but with the classes
@@ -86,20 +86,20 @@ class TestASTResourceReference < Test::Unit::TestCase
         @parser.newclass "one::five"
 
         # First try an unqualified type
-        assert_equal("four", newref("class", "four").evaluate(:scope => twoscope).title,
+        assert_equal("four", newref("class", "four").evaluate(twoscope).title,
             "Unqualified class was not found")
 
         # Then a qualified class
-        assert_equal("one::five", newref("class", "five").evaluate(:scope => twoscope).title,
+        assert_equal("one::five", newref("class", "five").evaluate(twoscope).title,
             "Class was not made fully qualified")
 
         # Then try a type that does not need to be qualified
-        assert_equal("four", newref("class", "four").evaluate(:scope => twoscope).title,
+        assert_equal("four", newref("class", "four").evaluate(twoscope).title,
             "Unqualified class was not handled correctly")
 
         # Now try a type that does not exist, which should throw an error.
         assert_raise(Puppet::ParseError, "Did not fail on a missing type in a resource reference") do
-            newref("class", "nosuchclass").evaluate(:scope => twoscope)
+            newref("class", "nosuchclass").evaluate(twoscope)
         end
     end
 end

data/test/language/ast/selector.rb

@@ -37,7 +37,7 @@ class TestSelector < Test::Unit::TestCase
             params = maker.call()
             sel = AST::Selector.new(:param => param, :values => params.values)
             result = nil
-            assert_nothing_raised { result = sel.evaluate(:scope => scope) }
+            assert_nothing_raised { result = sel.evaluate(scope) }
             assert_equal(should[str], result, "did not case-sensitively match %s" % str)
         end
         
@@ -53,7 +53,7 @@ class TestSelector < Test::Unit::TestCase
             params.delete(:upper)
             sel = AST::Selector.new(:param => param, :values => params.values)
             result = nil
-            assert_nothing_raised { result = sel.evaluate(:scope => scope) }
+            assert_nothing_raised { result = sel.evaluate(scope) }
             assert_equal("lower", result, "did not case-insensitively match %s" % str)
         end
     end

data/test/language/ast/variable.rb

@@ -22,9 +22,9 @@ class TestVariable < Test::Unit::TestCase
     end
 
     def test_evaluate
-        assert_equal("", @var.evaluate(:scope => @scope), "did not return empty string on unset var")
+        assert_equal("", @var.evaluate(@scope), "did not return empty string on unset var")
         @scope.setvar(@name, "something")
-        assert_equal("something", @var.evaluate(:scope => @scope), "incorrect variable value")
+        assert_equal("something", @var.evaluate(@scope), "incorrect variable value")
     end
 end
 

data/test/language/functions.rb

@@ -41,7 +41,7 @@ class TestLangFunctions < Test::Unit::TestCase
         scope = mkscope
         val = nil
         assert_nothing_raised do
-            val = func.evaluate(:scope => scope)
+            val = func.evaluate(scope)
         end
 
         assert_equal("output avalue", val)
@@ -57,7 +57,7 @@ class TestLangFunctions < Test::Unit::TestCase
 
             val = nil
             assert_nothing_raised do
-                val = func.evaluate(:scope => scope)
+                val = func.evaluate(scope)
             end
 
             assert_equal(retval, val, "'tagged' returned %s for %s" % [val, tag])
@@ -66,7 +66,7 @@ class TestLangFunctions < Test::Unit::TestCase
         # 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")
+        scope.compiler.catalog.tag("configtag")
         assert(scope.function_tagged("configtag"), "tagged function did not catch catalog tags")
     end
 
@@ -86,7 +86,7 @@ class TestLangFunctions < Test::Unit::TestCase
         scope = mkscope
         val = nil
         assert_raise(Puppet::ParseError) do
-            val = func.evaluate(:scope => scope)
+            val = func.evaluate(scope)
         end
     end
 
@@ -117,16 +117,16 @@ class TestLangFunctions < Test::Unit::TestCase
 
         scope = mkscope
         assert_raise(Puppet::ParseError) do
-            ast.evaluate(:scope => scope)
+            ast.evaluate(scope)
         end
 
         scope.setvar("one", "One")
         assert_raise(Puppet::ParseError) do
-            ast.evaluate(:scope => scope)
+            ast.evaluate(scope)
         end
         scope.setvar("two", "Two")
         assert_nothing_raised do
-            ast.evaluate(:scope => scope)
+            ast.evaluate(scope)
         end
 
         assert_equal("template One\ntemplate Two\n", scope.lookupvar("output"),
@@ -155,13 +155,13 @@ class TestLangFunctions < Test::Unit::TestCase
 
         scope = mkscope
         assert_raise(Puppet::ParseError) do
-            ast.evaluate(:scope => scope)
+            ast.evaluate(scope)
         end
 
         scope.setvar("yayness", "this is yayness")
 
         assert_nothing_raised do
-            ast.evaluate(:scope => scope)
+            ast.evaluate(scope)
         end
 
         assert_equal("template this is yayness\n", scope.lookupvar("output"),
@@ -191,7 +191,7 @@ class TestLangFunctions < Test::Unit::TestCase
         scope = mkscope
         scope.setvar("myvar", "this is yayness")
         assert_raise(Puppet::ParseError) do
-            ast.evaluate(:scope => scope)
+            ast.evaluate(scope)
         end
     end
 
@@ -264,14 +264,14 @@ class TestLangFunctions < Test::Unit::TestCase
         }.each do |string, value|
             scope = mkscope
             assert_raise(Puppet::ParseError) do
-                ast.evaluate(:scope => scope)
+                ast.evaluate(scope)
             end
 
             scope.setvar("yayness", string)
             assert_equal(string, scope.lookupvar("yayness", false))
 
             assert_nothing_raised("An empty string was not a valid variable value") do
-                ast.evaluate(:scope => scope)
+                ast.evaluate(scope)
             end
 
             assert_equal("template #{value}\n", scope.lookupvar("output"),
@@ -308,7 +308,7 @@ class TestLangFunctions < Test::Unit::TestCase
 
     def test_realize
         scope = mkscope
-        parser = scope.compile.parser
+        parser = scope.compiler.parser
     
         # Make a definition
         parser.newdefine("mytype")
@@ -318,7 +318,7 @@ class TestLangFunctions < Test::Unit::TestCase
             virtual = mkresource(:type => type, :title => title,
                 :virtual => true, :params => {}, :scope => scope)
         
-            scope.compile.store_resource(scope, virtual)
+            scope.compiler.add_resource(scope, virtual)
 
             ref = Puppet::Parser::Resource::Reference.new(
                 :type => type, :title => title,
@@ -330,13 +330,13 @@ class TestLangFunctions < Test::Unit::TestCase
             end
 
             # Make sure it created a collection
-            assert_equal(1, scope.compile.collections.length,
+            assert_equal(1, scope.compiler.collections.length,
                 "Did not set collection")
 
             assert_nothing_raised do
-                scope.compile.collections.each do |coll| coll.evaluate end
+                scope.compiler.collections.each do |coll| coll.evaluate end
             end
-            scope.compile.collections.clear
+            scope.compiler.collections.clear
 
             # Now make sure the virtual resource is no longer virtual
             assert(! virtual.virtual?, "Did not make virtual resource real")
@@ -354,17 +354,17 @@ class TestLangFunctions < Test::Unit::TestCase
         end
 
         # Make sure it created a collection
-        assert_equal(1, scope.compile.collections.length,
+        assert_equal(1, scope.compiler.collections.length,
             "Did not set collection")
 
         # And the collection has our resource in it
-        assert_equal([none.to_s], scope.compile.collections[0].resources,
+        assert_equal([none.to_s], scope.compiler.collections[0].resources,
             "Did not set resources in collection")
     end
     
     def test_defined
         scope = mkscope
-        parser = scope.compile.parser
+        parser = scope.compiler.parser
         
         parser.newclass("yayness")
         parser.newdefine("rahness")
@@ -385,7 +385,7 @@ class TestLangFunctions < Test::Unit::TestCase
             "Multiple falses were somehow true")
         
         # Now make sure we can test resources
-        scope.compile.store_resource(scope, mkresource(:type => "file", :title => "/tmp/rahness",
+        scope.compiler.add_resource(scope, mkresource(:type => "file", :title => "/tmp/rahness",
             :scope => scope, :source => scope.source,
             :params => {:owner => "root"}))
         
@@ -420,7 +420,7 @@ class TestLangFunctions < Test::Unit::TestCase
 
     def test_include
         scope = mkscope
-        parser = scope.compile.parser
+        parser = scope.compiler.parser
 
         assert_raise(Puppet::ParseError, "did not throw error on missing class") do
             scope.function_include("nosuchclass")
@@ -428,7 +428,7 @@ class TestLangFunctions < Test::Unit::TestCase
 
         parser.newclass("myclass")
 
-        scope.compile.expects(:evaluate_classes).with(%w{myclass otherclass}, scope, false).returns(%w{myclass otherclass})
+        scope.compiler.expects(:evaluate_classes).with(%w{myclass otherclass}, scope, false).returns(%w{myclass otherclass})
 
         assert_nothing_raised do
             scope.function_include(["myclass", "otherclass"])
@@ -480,7 +480,7 @@ class TestLangFunctions < Test::Unit::TestCase
         assert_equal("yay-foo\n", %x{#{command} foo}, "command did not work")
 
         scope = mkscope
-        parser = scope.compile.parser
+        parser = scope.compiler.parser
 
         val = nil
         assert_nothing_raised("Could not call generator with no args") do

data/test/language/parser.rb

@@ -45,9 +45,9 @@ class TestParser < Test::Unit::TestCase
             assert_raise(Puppet::ParseError, "Did not fail while parsing %s" % file) {
                 parser.file = file
                 ast = parser.parse
-                config = mkcompile(parser)
+                config = mkcompiler(parser)
                 config.compile
-                #ast.classes[""].evaluate :scope => config.topscope
+                #ast.classes[""].evaluate config.topscope
             }
             Puppet::Type.allclear
         }
@@ -868,7 +868,7 @@ file { "/tmp/yayness":
 
     def test_newclass
         scope = mkscope
-        parser = scope.compile.parser
+        parser = scope.compiler.parser
 
         mkcode = proc do |ary|
             classes = ary.collect do |string|
@@ -891,7 +891,7 @@ file { "/tmp/yayness":
         assert(parser.classes["myclass"], "Could not find definition")
         assert_equal("myclass", parser.classes["myclass"].classname)
         assert_equal(%w{original code},
-             parser.classes["myclass"].code.evaluate(:scope => scope))
+             parser.classes["myclass"].code.evaluate(scope))
 
         # Newclass behaves differently than the others -- it just appends
         # the code to the existing class.
@@ -901,7 +901,7 @@ file { "/tmp/yayness":
         end
         assert(klass, "Did not return class when appending")
         assert_equal(%w{original code something new},
-            parser.classes["myclass"].code.evaluate(:scope => scope))
+            parser.classes["myclass"].code.evaluate(scope))
 
         # Now create the same class name in a different scope
         assert_nothing_raised {
@@ -914,7 +914,7 @@ file { "/tmp/yayness":
         assert_equal("other::myclass", other.classname)
         assert_equal("other::myclass", other.namespace)
         assert_equal(%w{something diff},
-             other.code.evaluate(:scope => scope))
+             other.code.evaluate(scope))
 
         # Make sure newclass deals correctly with nodes with no code
         klass = parser.newclass("nocode")
@@ -925,7 +925,7 @@ file { "/tmp/yayness":
         end
         assert(klass, "Did not return class with no code")
         assert_equal(%w{yay test},
-            parser.classes["nocode"].code.evaluate(:scope => scope))
+            parser.classes["nocode"].code.evaluate(scope))
 
         # Then try merging something into nothing
         parser.newclass("nocode2", :code => mkcode.call(%w{foo test}))
@@ -936,7 +936,7 @@ file { "/tmp/yayness":
         end
         assert(klass, "Did not return class with no code")
         assert_equal(%w{foo test},
-            parser.classes["nocode2"].code.evaluate(:scope => scope))
+            parser.classes["nocode2"].code.evaluate(scope))
 
         # And lastly, nothing and nothing
         klass = parser.newclass("nocode3")
@@ -1188,5 +1188,17 @@ file { "/tmp/yayness":
         assert_equal(result, parser.finddefine("", "fUntEst"),
             "%s was not matched" % "fUntEst")
     end
+
+    def test_manifests_with_multiple_environments
+        parser = mkparser :environment => "something"
+
+        # We use an exception to cut short the processing to simplify our stubbing
+        #Puppet::Module.expects(:find_manifests).with("test", {:cwd => ".", :environment => "something"}).raises(Puppet::ParseError)
+        Puppet::Module.expects(:find_manifests).with("test", {:cwd => ".", :environment => "something"}).returns([])
+
+        assert_raise(Puppet::ImportError) do
+            parser.import("test") 
+        end
+    end
 end
 

data/test/language/resource.rb

@@ -106,7 +106,6 @@ class TestResource < PuppetTest::TestCase
 
     def test_finish
         res = mkresource
-        res.expects(:add_overrides)
         res.expects(:add_defaults)
         res.expects(:add_metaparams)
         res.expects(:validate)
@@ -266,48 +265,12 @@ class TestResource < PuppetTest::TestCase
         ref.expects(:definedtype).returns(type)
         res.expects(:finish)
         res.scope = mock("scope")
-        config = mock("config")
-        res.scope.expects(:compile).returns(config)
-        config.expects(:delete_resource).with(res)
 
-        args = {:scope => res.scope, :resource => res}
-        type.expects(:evaluate).with(args)
+        type.expects(:evaluate_code).with(res)
 
         res.evaluate
     end
 
-    def test_add_overrides
-        # Try it with nil
-        res = mkresource
-        res.scope = mock('scope')
-        config = mock("config")
-        res.scope.expects(:compile).returns(config)
-        config.expects(:resource_overrides).with(res).returns(nil)
-        res.expects(:merge).never
-        res.send(:add_overrides)
-
-        # And an empty array
-        res = mkresource
-        res.scope = mock('scope')
-        config = mock("config")
-        res.scope.expects(:compile).returns(config)
-        config.expects(:resource_overrides).with(res).returns([])
-        res.expects(:merge).never
-        res.send(:add_overrides)
-
-        # And with some overrides
-        res = mkresource
-        res.scope = mock('scope')
-        config = mock("config")
-        res.scope.expects(:compile).returns(config)
-        returns = %w{a b}
-        config.expects(:resource_overrides).with(res).returns(returns)
-        res.expects(:merge).with("a")
-        res.expects(:merge).with("b")
-        res.send(:add_overrides)
-        assert(returns.empty?, "Did not clear overrides")
-    end
-
     def test_proxymethods
         res = Parser::Resource.new :type => "evaltest", :title => "yay",
             :source => mock("source"), :scope => mkscope
@@ -378,7 +341,7 @@ class TestResource < PuppetTest::TestCase
         {:name => "one", :title => "two"},
         {:title => "three"},
         ].each do |hash|
-            config = mkcompile parser
+            config = mkcompiler parser
             args = {:type => "yayness", :title => hash[:title],
                 :source => klass, :scope => config.topscope}
             if hash[:name]
@@ -425,7 +388,7 @@ class TestResource < PuppetTest::TestCase
             :code => resourcedef("file", varref("name"),
                 "mode" => "644"))
 
-        config = mkcompile(parser)
+        config = mkcompiler(parser)
 
         res = mkresource :type => "yayness", :title => "foo", :params => {}, :scope => config.topscope
         res.virtual = true
@@ -464,8 +427,8 @@ class TestResource < PuppetTest::TestCase
         scope = stub 'scope', :resource => scope_resource
         resource = Puppet::Parser::Resource.new(:type => "file", :title => "yay", :scope => scope, :source => mock('source'))
 
-        # Make sure we get the scope resource's tags, plus the type and title
-        %w{srone srtwo yay file}.each do |tag|
+        # Make sure we get the type and title
+        %w{yay file}.each do |tag|
             assert(resource.tags.include?(tag), "Did not tag resource with %s" % tag)
         end