Merge branch 'master' of ssh://reductivelabs.com/opt/rl/git/puppet

8 files changed, 113 insertions, 69 deletions

diff --git a/lib/puppet/parser/collector.rb b/lib/puppet/parser/collector.rb
index 3eb37dfa2..e3c91bccb 100644
--- a/lib/puppet/parser/collector.rb
+++ b/lib/puppet/parser/collector.rb
@@ -23,7 +23,8 @@ class Puppet::Parser::Collector
         host = Puppet::Rails::Host.find_by_name(@scope.host)
 
         args = {:include => {:param_values => :param_name}}
-        args[:conditions] = "(exported = 't' AND restype = '%s')" % [@type]
+        args[:conditions] = "(exported = %s AND restype = '%s')" %
+	    [ActiveRecord::Base.connection.quote(true), @type]
         if @equery
             args[:conditions] += " AND (%s)" % [@equery]
         end
diff --git a/lib/puppet/parser/compile.rb b/lib/puppet/parser/compile.rb
index 992b165e5..f23b42a35 100644
--- a/lib/puppet/parser/compile.rb
+++ b/lib/puppet/parser/compile.rb
@@ -83,12 +83,12 @@ class Puppet::Parser::Compile
         return @configuration
     end
 
-    # FIXME There are no tests for this.
+    # LAK:FIXME There are no tests for this.
     def delete_collection(coll)
         @collections.delete(coll) if @collections.include?(coll)
     end
 
-    # FIXME There are no tests for this.
+    # LAK:FIXME There are no tests for this.
     def delete_resource(resource)
         @resource_table.delete(resource.ref) if @resource_table.include?(resource.ref)
     end
@@ -114,7 +114,7 @@ class Puppet::Parser::Compile
     # find, just tag the configuration and move on.  This method really just
     # creates resource objects that point back to the classes, and then the
     # resources are themselves evaluated later in the process.
-    def evaluate_classes(classes, scope)
+    def evaluate_classes(classes, scope, lazy_evaluate = true)
         unless scope.source
             raise Puppet::DevError, "No source for scope passed to evaluate_classes"
         end
@@ -126,6 +126,10 @@ 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)
+
+                # If they've disabled lazy evaluation (which the :include function does),
+                # then evaluate our resource immediately.
+                resource.evaluate unless lazy_evaluate
                 @configuration.tag(klass.classname)
                 found << name
             else
diff --git a/lib/puppet/parser/functions.rb b/lib/puppet/parser/functions.rb
index 1d07122d4..a0e8da86f 100644
--- a/lib/puppet/parser/functions.rb
+++ b/lib/puppet/parser/functions.rb
@@ -109,7 +109,9 @@ module Functions
     # Include the specified classes
     newfunction(:include, :doc => "Evaluate one or more classes.") do |vals|
         vals = [vals] unless vals.is_a?(Array)
-        klasses = compile.evaluate_classes(vals, self)
+
+        # The 'false' disables lazy evaluation.
+        klasses = compile.evaluate_classes(vals, self, false)
 
         missing = vals.find_all do |klass|
             ! klasses.include?(klass)
diff --git a/lib/puppet/type/pfile/target.rb b/lib/puppet/type/pfile/target.rb
index b4a6481e0..a0e5dc401 100644
--- a/lib/puppet/type/pfile/target.rb
+++ b/lib/puppet/type/pfile/target.rb
@@ -45,6 +45,8 @@ module Puppet
                     end
                 end
 
+		@resource.send(:property_fix)
+
                 :link_created
             end
         end
diff --git a/spec/unit/parser/compile.rb b/spec/unit/parser/compile.rb
index 8bfcdd495..93c440417 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,94 @@ 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
+
+        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)
+
+        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)
+
+        Puppet::Parser::Resource.stubs(:new).returns(@resource)
+        @compile.evaluate_classes(%w{myclass}, @scope)
+    end
+
+    it "should not evaluate the resources created for found classes unless asked" do
+        @compile.configuration.stubs(:tag)
+
+        @compile.stubs(:store_resource)
+        @resource.expects(:evaluate).never
+
+        Puppet::Parser::Resource.stubs(:new).returns(@resource)
+        @compile.evaluate_classes(%w{myclass}, @scope)
+    end
+
+    it "should immediately evaluate the resources created for found classes when asked" 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, false)
+    end
+
+    it "should return the list of found classes" do
+        @compile.configuration.stubs(:tag)
+
+        @compile.stubs(:store_resource)
+        @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..2fc36f6cd 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, false).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 7bd2f107d..92981b557 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|