Classes once again get evaluated immediately when the

'include' function is used, instead of being lazy-evaluated.

Previous work caused resources to get created to model
these classes, but in the process, I removed the fact
that the classes were evaluated immediately.  This meant
that you couldn't guarantee that a class was evaluated
before you went to use its variables.

5 files changed, 94 insertions, 64 deletions

diff --git a/lib/puppet/parser/compile.rb b/lib/puppet/parser/compile.rb
index 992b165e5..1b58eca42 100644
--- a/lib/puppet/parser/compile.rb
+++ b/lib/puppet/parser/compile.rb
@@ -126,6 +126,7 @@ class Puppet::Parser::Compile
                 # of resources.
                 resource = Puppet::Parser::Resource.new(:type => "class", :title => klass.classname, :scope => scope, :source => scope.source)
                 store_resource(scope, resource)
+                resource.evaluate
                 @configuration.tag(klass.classname)
                 found << name
             else
diff --git a/spec/unit/parser/compile.rb b/spec/unit/parser/compile.rb
index 8bfcdd495..c7a367957 100755
--- a/spec/unit/parser/compile.rb
+++ b/spec/unit/parser/compile.rb
@@ -34,20 +34,10 @@ describe Puppet::Parser::Compile, " when compiling" do
         one = stub 'one', :classname => "one"
         three = stub 'three', :classname => "three"
         @node.stubs(:name).returns("whatever")
-        @compile.parser.expects(:findclass).with("", "").returns(main)
-        @compile.parser.expects(:findclass).with("", "one").returns(one)
-        @compile.parser.expects(:findclass).with("", "two").returns(nil)
-        @compile.parser.expects(:findclass).with("", "three").returns(three)
-        @compile.parser.expects(:findclass).with("", "four").returns(nil)
         @node.stubs(:classes).returns(classes)
-        @compile.send :evaluate_main
-        @compile.send :evaluate_node_classes
 
-        # Now make sure we've created the appropriate resources.
-        @compile.resources.find { |r| r.to_s == "Class[one]" }.should be_an_instance_of(Puppet::Parser::Resource)
-        @compile.resources.find { |r| r.to_s == "Class[three]" }.should be_an_instance_of(Puppet::Parser::Resource)
-        @compile.resources.find { |r| r.to_s == "Class[two]" }.should be_nil
-        @compile.resources.find { |r| r.to_s == "Class[four]" }.should be_nil
+        @compile.expects(:evaluate_classes).with(classes, @compile.topscope)
+        @compile.send :evaluate_node_classes
     end
 
     it "should enable ast_nodes if the parser has any nodes" do
@@ -60,3 +50,88 @@ describe Puppet::Parser::Compile, " when compiling" do
         @compile.ast_nodes?.should be_false
     end
 end
+
+describe Puppet::Parser::Compile, " when evaluating classes" do
+    before do
+        @node = stub 'node', :name => 'mynode'
+        @parser = stub 'parser', :version => "1.0"
+        @scope = stub 'scope', :source => mock("source")
+        @compile = Puppet::Parser::Compile.new(@node, @parser)
+    end
+
+    it "should fail if there's no source listed for the scope" do
+        scope = stub 'scope', :source => nil
+        proc { @compile.evaluate_classes(%w{one two}, scope) }.should raise_error(Puppet::DevError)
+    end
+
+    it "should tag the configuration with the name of each not-found class" do
+        @compile.configuration.expects(:tag).with("notfound")
+        @scope.expects(:findclass).with("notfound").returns(nil)
+        @compile.evaluate_classes(%w{notfound}, @scope)
+    end
+end
+
+describe Puppet::Parser::Compile, " when evaluating found classes" do
+    before do
+        @node = stub 'node', :name => 'mynode'
+        @parser = stub 'parser', :version => "1.0"
+        @scope = stub 'scope', :source => mock("source")
+        @compile = Puppet::Parser::Compile.new(@node, @parser)
+
+        @class = stub 'class', :classname => "my::class"
+        @scope.stubs(:findclass).with("myclass").returns(@class)
+
+        @resource = mock 'resource'
+    end
+
+    it "should create a resource for each found class" do
+        @compile.configuration.stubs(:tag)
+
+        @compile.stubs :store_resource
+        @resource.stubs(:evaluate)
+
+        Puppet::Parser::Resource.expects(:new).with(:scope => @scope, :source => @scope.source, :title => "my::class", :type => "class").returns(@resource)
+        @compile.evaluate_classes(%w{myclass}, @scope)
+    end
+
+    it "should store each created resource in the compile" do
+        @compile.configuration.stubs(:tag)
+
+        @compile.expects(:store_resource).with(@scope, @resource)
+        @resource.stubs(:evaluate)
+
+        Puppet::Parser::Resource.stubs(:new).returns(@resource)
+        @compile.evaluate_classes(%w{myclass}, @scope)
+    end
+
+    it "should tag the configuration with the fully-qualified name of each found class" do
+        @compile.configuration.expects(:tag).with("my::class")
+
+        @compile.stubs(:store_resource)
+        @resource.stubs(:evaluate)
+
+        Puppet::Parser::Resource.stubs(:new).returns(@resource)
+        @compile.evaluate_classes(%w{myclass}, @scope)
+    end
+
+    it "should immediately evaluate the resources created for found classes" do
+        @compile.configuration.stubs(:tag)
+
+        @compile.stubs(:store_resource)
+        @resource.expects(:evaluate)
+
+        Puppet::Parser::Resource.stubs(:new).returns(@resource)
+        @compile.evaluate_classes(%w{myclass}, @scope)
+    end
+
+    it "should return the list of found classes" do
+        @compile.configuration.stubs(:tag)
+
+        @compile.stubs(:store_resource)
+        @resource.expects(:evaluate)
+        @scope.stubs(:findclass).with("notfound").returns(nil)
+
+        Puppet::Parser::Resource.stubs(:new).returns(@resource)
+        @compile.evaluate_classes(%w{myclass notfound}, @scope).should == %w{myclass}
+    end
+end
diff --git a/test/language/compile.rb b/test/language/compile.rb
index 07ef54626..380da3da5 100755
--- a/test/language/compile.rb
+++ b/test/language/compile.rb
@@ -267,36 +267,6 @@ class TestCompile < Test::Unit::TestCase
         end
     end
 
-    def test_evaluate_classes
-        compile = mkcompile
-        compile.parser.expects(:findclass).with("", "").returns(stub('main', :classname => ""))
-        compile.send :evaluate_main
-        classes = {
-            "one" => stub('class one', :classname => "one"),
-            "three" => stub('class three', :classname => "three")
-        }
-
-        classes.each do |name, obj|
-            compile.parser.expects(:findclass).with("", name).returns(obj)
-        end
-        %w{two four}.each do |name|
-            compile.parser.expects(:findclass).with("", name).returns(nil)
-        end
-
-        %w{one two three four}.each do |name|
-            compile.configuration.expects(:tag).with(name)
-        end
-
-        result = nil
-        assert_nothing_raised("could not call evaluate_node_classes") do
-            result = compile.send(:evaluate_classes, %w{one two three four}, compile.topscope)
-        end
-        %w{one three}.each do |found|
-            assert(compile.resources.find { |r| r.to_s == "Class[#{found}]" }, "Did not create a class resource for %s" % found)
-        end
-        assert_equal(%w{one three}, result, "Did not return the list of evaluated classes")
-    end
-
     def test_evaluate_collections
         compile = mkcompile
 
diff --git a/test/language/functions.rb b/test/language/functions.rb
index 746ba4b1d..3a7779d3d 100755
--- a/test/language/functions.rb
+++ b/test/language/functions.rb
@@ -427,30 +427,10 @@ class TestLangFunctions < Test::Unit::TestCase
 
         parser.newclass("myclass")
 
-        assert_nothing_raised do
-            scope.function_include "myclass"
-        end
-
-        assert(scope.compile.resources.find { |r| r.to_s == "Class[myclass]" }, 
-            "class was not evaluated")
-
-        # Now try multiple classes at once
-        classes = %w{one two three}.each { |c| parser.newclass(c) }
+        scope.compile.expects(:evaluate_classes).with(%w{myclass otherclass}, scope).returns(%w{myclass otherclass})
 
         assert_nothing_raised do
-            scope.function_include classes
-        end
-
-        classes.each do |c|
-            assert(scope.compile.resources.find { |r| r.to_s == "Class[#{c}]" },
-                "class %s was not evaluated" % c)
-        end
-
-        # Now try a scoped class
-        parser.newclass("os::redhat")
-
-        assert_nothing_raised("Could not include qualified class name") do
-            scope.function_include("os::redhat")
+            scope.function_include(["myclass", "otherclass"])
         end
     end
 
diff --git a/test/lib/puppettest.rb b/test/lib/puppettest.rb
index eb50077b8..a9ca6d472 100755
--- a/test/lib/puppettest.rb
+++ b/test/lib/puppettest.rb
@@ -195,6 +195,8 @@ module PuppetTest
         end
 
         Puppet[:ignoreschedules] = true
+
+        @start = Time.now
     end
 
     def tempfile
@@ -244,6 +246,8 @@ module PuppetTest
     end
 
     def teardown
+        @stop = Time.now
+        File.open("/tmp/test_times.log", ::File::WRONLY|::File::CREAT|::File::APPEND) { |f| f.puts "%0.4f %s %s" % [@stop - @start, @method_name, self.class] }
         @@cleaners.each { |cleaner| cleaner.call() }
 
         @@tmpfiles.each { |file|