puppet 2.6.2 → 2.6.3

data/lib/puppet/util/suidmanager.rb

@@ -88,7 +88,7 @@ module Puppet::Util::SUIDManager
   module_function :initgroups
 
   def run_and_capture(command, new_uid=nil, new_gid=nil)
-    output = Puppet::Util.execute(command, :failonfail => false, :uid => new_uid, :gid => new_gid)
+    output = Puppet::Util.execute(command, :failonfail => false, :combine => true, :uid => new_uid, :gid => new_gid)
     [output, $CHILD_STATUS.dup]
   end
   module_function :run_and_capture

data/lib/puppet/util/zaml.rb

@@ -120,6 +120,9 @@ class Object
   def to_yaml_properties
     instance_variables.sort        # Default YAML behavior
   end
+  def yaml_property_munge(x)
+    x
+  end
   def zamlized_class_name(root)
     cls = self.class
     "!ruby/#{root.name.downcase}#{cls == root ? '' : ":#{cls.respond_to?(:name) ? cls.name : cls}"}"
@@ -136,7 +139,7 @@ class Object
             z.nl
             v[1..-1].to_zaml(z)       # Remove leading '@'
             z.emit(': ')
-            instance_variable_get(v).to_zaml(z)
+            yaml_property_munge(instance_variable_get(v)).to_zaml(z)
           }
         end
       }

data/spec/integration/indirector/bucket_file/rest_spec.rb

@@ -36,8 +36,16 @@ describe "Filebucket REST Terminus" do
     @host = Puppet::SSL::Host.new(Puppet[:certname])
 
     @params = { :port => 34343, :handlers => [ :file_bucket_file ] }
-    @server = Puppet::Network::Server.new(@params)
-    @server.listen
+    retries = 0
+    begin
+      @server = Puppet::Network::Server.new(@params)
+      @server.listen
+    rescue Errno::EADDRINUSE => e
+      sleep 0.1
+      puts "Port 34343 is in use; waiting for it to be free" if retries == 50
+      retry if (retries += 1) < 100
+      pending "Can't run too many simultaneous tests"
+    end
 
     @old_terminus = Puppet::FileBucket::File.indirection.terminus_class
     Puppet::FileBucket::File.terminus_class = :rest

data/spec/integration/indirector/certificate_revocation_list/rest_spec.rb

@@ -33,8 +33,16 @@ describe "Certificate REST Terminus" do
     ca.generate(Puppet[:certname]) unless Puppet::SSL::Certificate.find(Puppet[:certname])
 
     @params = { :port => 34343, :handlers => [ :certificate_revocation_list ] }
-    @server = Puppet::Network::Server.new(@params)
-    @server.listen
+    retries = 0
+    begin
+      @server = Puppet::Network::Server.new(@params)
+      @server.listen
+    rescue Errno::EADDRINUSE => e
+      sleep 0.1
+      puts "Port 34343 is in use; waiting for it to be free" if retries == 50
+      retry if (retries += 1) < 100
+      pending "Can't run too many simultaneous tests"
+    end
 
     # And make sure we've generated the CRL
     @crl = ca.crl

data/spec/integration/parser/functions_spec.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Puppet::Parser::Functions do
+  before :each do
+    Puppet::Parser::Functions.rmfunction("template") if Puppet::Parser::Functions.function("template")
+  end
+
+  it "should support multiple threads autoloading the same function" do
+    threads = []
+    lambda {
+      10.times { |a|
+        threads << Thread.new {
+          Puppet::Parser::Functions.function("template")
+        }
+      }
+    }.should_not raise_error
+    threads.each { |t| t.join }
+  end
+end

data/spec/integration/parser/ruby_manifest_spec.rb

@@ -69,7 +69,7 @@ describe "Pure ruby manifests" do
     write_file('foo.rb', "hostclass 'bar' do file 'test_file', :owner => 'root', :mode => '644' end")
     catalog = compile("import 'foo'\ninclude bar")
     file = catalog.resource("File[test_file]")
-    file.should be_a Puppet::Resource
+    file.should be_a(Puppet::Resource)
     file.type.should == 'File'
     file.title.should == 'test_file'
     file.exported.should_not be

data/spec/integration/ssl/certificate_authority_spec.rb

@@ -121,9 +121,7 @@ describe Puppet::SSL::CertificateAuthority do
     it "should save valid certificates" do
       @ca.sign("luke.madstop.com")
 
-      ssl = %x{which openssl}
-
-      unless ssl
+      unless ssl = Puppet::Util::which('openssl')
         pending "No ssl available"
       else
         ca_cert = Puppet[:cacert]

data/spec/integration/util/file_locking_spec.rb

@@ -5,28 +5,30 @@ Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f
 require 'puppet/util/file_locking'
 
 describe Puppet::Util::FileLocking do
-  it "should be able to keep file corruption from happening when there are multiple writers" do
-    file = Tempfile.new("puppetspec")
-    filepath = file.path
-    file.close!()
-    file = filepath
-    data = {:a => :b, :c => "A string", :d => "another string", :e => %w{an array of strings}}
-    File.open(file, "w") { |f| f.puts YAML.dump(data) }
+  before :each do
+    @file = Tempfile.new("puppetspec")
+    filepath = @file.path
+    @file.close!()
+    @file = filepath
+    @data = {:a => :b, :c => "A string", :d => "another string", :e => %w{an array of strings}}
+    File.open(@file, "w") { |f| f.puts YAML.dump(@data) }
+  end
 
+  it "should be able to keep file corruption from happening when there are multiple writers threads" do
     threads = []
     sync = Sync.new
     9.times { |a|
       threads << Thread.new {
         9.times { |b|
           sync.synchronize(Sync::SH) {
-            Puppet::Util::FileLocking.readlock(file) { |f|
-              YAML.load(f.read).should == data
+            Puppet::Util::FileLocking.readlock(@file) { |f|
+              YAML.load(f.read).should == @data
             }
           }
           sleep 0.01
           sync.synchronize(Sync::EX) {
-            Puppet::Util::FileLocking.writelock(file) { |f|
-              f.puts YAML.dump(data)
+            Puppet::Util::FileLocking.writelock(@file) { |f|
+              f.puts YAML.dump(@data)
             }
           }
         }
@@ -34,4 +36,22 @@ describe Puppet::Util::FileLocking do
     }
     threads.each { |th| th.join }
   end
+
+  it "should be able to keep file corruption from happening when there are multiple writers processes" do
+    unless Process.fork
+      50.times { |b|
+        Puppet::Util::FileLocking.writelock(@file) { |f|
+          f.puts YAML.dump(@data)
+        }
+        sleep 0.01
+      }
+      Kernel.exit!
+    end
+
+    50.times { |c|
+      Puppet::Util::FileLocking.readlock(@file) { |f|
+        YAML.load(f.read).should == @data
+      }
+    }
+  end
 end

data/spec/spec_helper.rb

@@ -20,7 +20,7 @@ module PuppetSpec
   FIXTURE_DIR = File.join(dir = File.expand_path(File.dirname(__FILE__)), "fixtures") unless defined?(FIXTURE_DIR)
 end
 
-require 'spec/lib/puppet_spec/files'
+require 'lib/puppet_spec/files'
 require 'monkey_patches/alias_should_to_must'
 require 'monkey_patches/add_confine_and_runnable_to_rspec_dsl'
 require 'monkey_patches/publicize_methods'

data/spec/unit/application/apply_spec.rb

@@ -312,7 +312,7 @@ describe Puppet::Application::Apply do
       end
 
       it "should apply the catalog" do
-        @catalog.expects(:apply).returns(stub_everything 'transaction')
+        @catalog.expects(:apply).returns(stub_everything('transaction'))
 
         @apply.main
       end

data/spec/unit/daemon_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby"
+#!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../spec_helper'
 require 'puppet/daemon'
@@ -142,11 +142,7 @@ describe Puppet::Daemon do
   describe "when creating its pidfile" do
     it "should use an exclusive mutex" do
       Puppet.settings.expects(:value).with(:name).returns "me"
-
-      sync = mock 'sync'
-      Puppet::Util.expects(:sync).with("me").returns sync
-
-      sync.expects(:synchronize).with(Sync::EX)
+      Puppet::Util.expects(:synchronize_on).with("me",Sync::EX)
       @daemon.create_pidfile
     end
 
@@ -180,10 +176,8 @@ describe Puppet::Daemon do
     it "should use an exclusive mutex" do
       Puppet.settings.expects(:value).with(:name).returns "me"
 
-      sync = mock 'sync'
-      Puppet::Util.expects(:sync).with("me").returns sync
+      Puppet::Util.expects(:synchronize_on).with("me",Sync::EX)
 
-      sync.expects(:synchronize).with(Sync::EX)
       @daemon.remove_pidfile
     end
 

data/spec/unit/indirector/catalog/compiler_spec.rb

@@ -6,6 +6,7 @@
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 require 'puppet/indirector/catalog/compiler'
+require 'puppet/rails'
 
 describe Puppet::Resource::Catalog::Compiler do
   before do
@@ -33,8 +34,8 @@ describe Puppet::Resource::Catalog::Compiler do
       Puppet::Node.stubs(:find).with('node1').returns(node1)
       Puppet::Node.stubs(:find).with('node2').returns(node2)
 
-      compiler.find(stub('request', :node => 'node1', :options => {}))
-      compiler.find(stub('node2request', :node => 'node2', :options => {}))
+      compiler.find(stub('request', :key => 'node1', :node => 'node1', :options => {}))
+      compiler.find(stub('node2request', :key => 'node2', :node => 'node2', :options => {}))
     end
 
     it "should provide a method for determining if the catalog is networked" do
@@ -70,7 +71,7 @@ describe Puppet::Resource::Catalog::Compiler do
       @node = Puppet::Node.new @name
       @node.stubs(:merge)
       Puppet::Node.stubs(:find).returns @node
-      @request = stub 'request', :key => "does not matter", :node => @name, :options => {}
+      @request = stub 'request', :key => @name, :node => @name, :options => {}
     end
 
     it "should directly use provided nodes" do
@@ -80,14 +81,14 @@ describe Puppet::Resource::Catalog::Compiler do
       @compiler.find(@request)
     end
 
-    it "should use the request's node name if no explicit node is provided" do
+    it "should use the authenticated node name if no request key is provided" do
+      @request.stubs(:key).returns(nil)
       Puppet::Node.expects(:find).with(@name).returns(@node)
       @compiler.expects(:compile).with(@node)
       @compiler.find(@request)
     end
 
-    it "should use the provided node name if no explicit node is provided and no authenticated node information is available" do
-      @request.expects(:node).returns nil
+    it "should use the provided node name by default" do
       @request.expects(:key).returns "my_node"
 
       Puppet::Node.expects(:find).with("my_node").returns @node
@@ -198,7 +199,7 @@ describe Puppet::Resource::Catalog::Compiler do
       @compiler = Puppet::Resource::Catalog::Compiler.new
       @name = "me"
       @node = mock 'node'
-      @request = stub 'request', :node => @name, :options => {}
+      @request = stub 'request', :key => @name, :options => {}
       @compiler.stubs(:compile)
     end
 
@@ -217,7 +218,7 @@ describe Puppet::Resource::Catalog::Compiler do
       @compiler = Puppet::Resource::Catalog::Compiler.new
       @name = "me"
       @node = mock 'node'
-      @request = stub 'request', :node => @name, :options => {}
+      @request = stub 'request', :key => @name, :options => {}
       @compiler.stubs(:compile)
       Puppet::Node.stubs(:find).with(@name).returns(@node)
     end

data/spec/unit/network/handler/fileserver_spec.rb

@@ -4,9 +4,8 @@ require File.dirname(__FILE__) + '/../../../spec_helper'
 
 require 'puppet/network/handler/fileserver'
 
-
 describe Puppet::Network::Handler::FileServer do
-  require 'tmpdir'
+  include PuppetSpec::Files
 
   def create_file(filename)
     File.open(filename, "w") { |f| f.puts filename}
@@ -20,8 +19,7 @@ describe Puppet::Network::Handler::FileServer do
   end
 
   before do
-    @basedir = File.join(Dir.tmpdir, "test_network_handler")
-    Dir.mkdir(@basedir)
+    @basedir = tmpdir("test_network_handler")
     @file = File.join(@basedir, "aFile")
     @link = File.join(@basedir, "aLink")
     create_file(@file)

data/spec/unit/network/server_spec.rb

@@ -5,6 +5,7 @@
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 require 'puppet/network/server'
+require 'puppet/network/handler'
 
 describe Puppet::Network::Server do
   before do
@@ -161,11 +162,7 @@ describe Puppet::Network::Server do
   describe "when creating its pidfile" do
     it "should use an exclusive mutex" do
       Puppet.settings.expects(:value).with(:name).returns "me"
-
-      sync = mock 'sync'
-      Puppet::Util.expects(:sync).with("me").returns sync
-
-      sync.expects(:synchronize).with(Sync::EX)
+      Puppet::Util.expects(:synchronize_on).with("me",Sync::EX)
       @server.create_pidfile
     end
 
@@ -198,11 +195,7 @@ describe Puppet::Network::Server do
   describe "when removing its pidfile" do
     it "should use an exclusive mutex" do
       Puppet.settings.expects(:value).with(:name).returns "me"
-
-      sync = mock 'sync'
-      Puppet::Util.expects(:sync).with("me").returns sync
-
-      sync.expects(:synchronize).with(Sync::EX)
+      Puppet::Util.expects(:synchronize_on).with("me",Sync::EX)
       @server.remove_pidfile
     end
 

data/spec/unit/parser/ast/collection_spec.rb

@@ -5,6 +5,8 @@ require File.dirname(__FILE__) + '/../../../spec_helper'
 describe Puppet::Parser::AST::Collection do
   before :each do
     @scope = stub_everything 'scope'
+    @mytype = stub_everything('mytype')
+    @scope.stubs(:find_resource_type).returns @mytype
     @compiler = stub_everything 'compile'
     @scope.stubs(:compiler).returns(@compiler)
 
@@ -24,6 +26,8 @@ describe Puppet::Parser::AST::Collection do
 
   it "should instantiate a Collector for this type" do
     collection = Puppet::Parser::AST::Collection.new :form => :virtual, :type => "test"
+    @test_type = stub 'type', :name => 'test'
+    @scope.expects(:find_resource_type).with('test').returns @test_type
 
     Puppet::Parser::Collector.expects(:new).with(@scope, "test", nil, nil, :virtual)
 

data/spec/unit/parser/ast/leaf_spec.rb

@@ -49,7 +49,7 @@ describe Puppet::Parser::AST::String do
     end
     it "should return a dup of its value" do
       value = ""
-      Puppet::Parser::AST::String.new( :value => value ).evaluate(stub 'scope').should_not be_equal(value)
+      Puppet::Parser::AST::String.new( :value => value ).evaluate(stub('scope')).should_not be_equal(value)
     end
   end
 end
@@ -136,6 +136,22 @@ describe Puppet::Parser::AST::HashOrArrayAccess do
       access.evaluate(@scope).should == "val2"
     end
 
+    it "should be able to return an array member when index is a stringified number" do
+      @scope.stubs(:lookupvar).with("a").returns(["val1", "val2", "val3"])
+
+      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "1" )
+
+      access.evaluate(@scope).should == "val2"
+    end
+
+    it "should raise an error when accessing an array with a key" do
+      @scope.stubs(:lookupvar).with("a").returns(["val1", "val2", "val3"])
+
+      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "get_me_the_second_element_please" )
+
+      lambda { access.evaluate(@scope) }.should raise_error
+    end
+
     it "should be able to return an hash value" do
       @scope.stubs(:lookupvar).with("a").returns({ "key1" => "val1", "key2" => "val2", "key3" => "val3" })
 
@@ -144,6 +160,14 @@ describe Puppet::Parser::AST::HashOrArrayAccess do
       access.evaluate(@scope).should == "val2"
     end
 
+    it "should be able to return an hash value with a numerical key" do
+      @scope.stubs(:lookupvar).with("a").returns({ "key1" => "val1", "key2" => "val2", "45" => "45", "key3" => "val3" })
+
+      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "45" )
+
+      access.evaluate(@scope).should == "45"
+    end
+
     it "should raise an error if the variable lookup didn't return an hash or an array" do
       @scope.stubs(:lookupvar).with("a").returns("I'm a string")
 
@@ -195,6 +219,24 @@ describe Puppet::Parser::AST::HashOrArrayAccess do
       scope.lookupvar("a").should be_include("b")
     end
 
+    it "should raise an error when assigning an array element with a key" do
+      @scope.stubs(:lookupvar).with("a").returns([])
+
+      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "get_me_the_second_element_please" )
+
+      lambda { access.assign(@scope, "test") }.should raise_error
+    end
+
+    it "should be able to return an array member when index is a stringified number" do
+      scope = Puppet::Parser::Scope.new
+      scope.setvar("a", [])
+
+      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "0" )
+
+      access.assign(scope, "val2")
+      scope.lookupvar("a").should == ["val2"]
+    end
+
     it "should raise an error when trying to overwrite an hash value" do
       @scope.stubs(:lookupvar).with("a").returns({ "key" => [ "a" , "b" ]})
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key")

data/spec/unit/parser/ast/resource_spec.rb

@@ -5,123 +5,168 @@ require File.dirname(__FILE__) + '/../../../spec_helper'
 describe Puppet::Parser::AST::Resource do
   ast = Puppet::Parser::AST
 
-  before :each do
-    @title = Puppet::Parser::AST::String.new(:value => "mytitle")
-    @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
-    @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
-    @scope.stubs(:resource).returns(stub_everything)
-    @resource = ast::Resource.new(:title => @title, :type => "file", :parameters => ast::ASTArray.new(:children => []) )
-    @resource.stubs(:qualified_type).returns("Resource")
-  end
-
-  it "should evaluate all its parameters" do
-    param = stub 'param'
-    param.expects(:safeevaluate).with(@scope).returns Puppet::Parser::Resource::Param.new(:name => "myparam", :value => "myvalue", :source => stub("source"))
-    @resource.stubs(:parameters).returns [param]
-
-    @resource.evaluate(@scope)
-  end
-
-  it "should evaluate its title" do
-    @resource.evaluate(@scope)[0].title.should == "mytitle"
-  end
-
-  it "should flatten the titles array" do
-    titles = []
-    %w{one two}.each do |title|
-      titles << Puppet::Parser::AST::String.new(:value => title)
+  describe "for builtin types" do
+    before :each do
+      @title = Puppet::Parser::AST::String.new(:value => "mytitle")
+      @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
+      @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
+      @scope.stubs(:resource).returns(stub_everything)
+      @resource = ast::Resource.new(:title => @title, :type => "file", :parameters => ast::ASTArray.new(:children => []) )
+      @resource.stubs(:qualified_type).returns("Resource")
     end
 
-    array = Puppet::Parser::AST::ASTArray.new(:children => titles)
+    it "should evaluate all its parameters" do
+      param = stub 'param'
+      param.expects(:safeevaluate).with(@scope).returns Puppet::Parser::Resource::Param.new(:name => "myparam", :value => "myvalue", :source => stub("source"))
+      @resource.stubs(:parameters).returns [param]
 
-    @resource.title = array
-    result = @resource.evaluate(@scope).collect { |r| r.title }
-    result.should be_include("one")
-    result.should be_include("two")
-  end
+      @resource.evaluate(@scope)
+    end
 
-  it "should create and return one resource objects per title" do
-    titles = []
-    %w{one two}.each do |title|
-      titles << Puppet::Parser::AST::String.new(:value => title)
+    it "should evaluate its title" do
+      @resource.evaluate(@scope)[0].title.should == "mytitle"
     end
 
-    array = Puppet::Parser::AST::ASTArray.new(:children => titles)
+    it "should flatten the titles array" do
+      titles = []
+      %w{one two}.each do |title|
+        titles << Puppet::Parser::AST::String.new(:value => title)
+      end
 
-    @resource.title = array
-    result = @resource.evaluate(@scope).collect { |r| r.title }
-    result.should be_include("one")
-    result.should be_include("two")
-  end
+      array = Puppet::Parser::AST::ASTArray.new(:children => titles)
 
-  it "should handover resources to the compiler" do
-    titles = []
-    %w{one two}.each do |title|
-      titles << Puppet::Parser::AST::String.new(:value => title)
+      @resource.title = array
+      result = @resource.evaluate(@scope).collect { |r| r.title }
+      result.should be_include("one")
+      result.should be_include("two")
     end
 
-    array = Puppet::Parser::AST::ASTArray.new(:children => titles)
+    it "should create and return one resource objects per title" do
+      titles = []
+      %w{one two}.each do |title|
+        titles << Puppet::Parser::AST::String.new(:value => title)
+      end
 
-    @resource.title = array
-    result = @resource.evaluate(@scope)
+      array = Puppet::Parser::AST::ASTArray.new(:children => titles)
 
-    result.each do |res|
-      @compiler.catalog.resource(res.ref).should be_instance_of(Puppet::Parser::Resource)
+      @resource.title = array
+      result = @resource.evaluate(@scope).collect { |r| r.title }
+      result.should be_include("one")
+      result.should be_include("two")
     end
-  end
-  it "should generate virtual resources if it is virtual" do
-    @resource.virtual = true
 
-    result = @resource.evaluate(@scope)
-    result[0].should be_virtual
-  end
+    it "should handover resources to the compiler" do
+      titles = []
+      %w{one two}.each do |title|
+        titles << Puppet::Parser::AST::String.new(:value => title)
+      end
 
-  it "should generate virtual and exported resources if it is exported" do
-    @resource.exported = true
+      array = Puppet::Parser::AST::ASTArray.new(:children => titles)
 
-    result = @resource.evaluate(@scope)
-    result[0].should be_virtual
-    result[0].should be_exported
-  end
+      @resource.title = array
+      result = @resource.evaluate(@scope)
 
-  # Related to #806, make sure resources always look up the full path to the resource.
-  describe "when generating qualified resources" do
-    before do
-      @scope = Puppet::Parser::Scope.new :compiler => Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
-      @parser = Puppet::Parser::Parser.new(Puppet::Node::Environment.new)
-      @parser.newdefine "one"
-      @parser.newdefine "one::two"
-      @parser.newdefine "three"
-      @twoscope = @scope.newscope(:namespace => "one")
-      @twoscope.resource = @scope.resource
+      result.each do |res|
+        @compiler.catalog.resource(res.ref).should be_instance_of(Puppet::Parser::Resource)
+      end
     end
 
-    def resource(type, params = nil)
-      params ||= Puppet::Parser::AST::ASTArray.new(:children => [])
-      Puppet::Parser::AST::Resource.new(:type => type, :title => Puppet::Parser::AST::String.new(:value => "myresource"), :parameters => params)
+    it "should generate virtual resources if it is virtual" do
+      @resource.virtual = true
+
+      result = @resource.evaluate(@scope)
+      result[0].should be_virtual
     end
 
-    it "should be able to generate resources with fully qualified type information" do
-      resource("two").evaluate(@twoscope)[0].type.should == "One::Two"
+    it "should generate virtual and exported resources if it is exported" do
+      @resource.exported = true
+
+      result = @resource.evaluate(@scope)
+      result[0].should be_virtual
+      result[0].should be_exported
     end
 
-    it "should be able to generate resources with unqualified type information" do
-      resource("one").evaluate(@twoscope)[0].type.should == "One"
+    # Related to #806, make sure resources always look up the full path to the resource.
+    describe "when generating qualified resources" do
+      before do
+        @scope = Puppet::Parser::Scope.new :compiler => Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
+        @parser = Puppet::Parser::Parser.new(Puppet::Node::Environment.new)
+        @parser.newdefine "one"
+        @parser.newdefine "one::two"
+        @parser.newdefine "three"
+        @twoscope = @scope.newscope(:namespace => "one")
+        @twoscope.resource = @scope.resource
+      end
+
+      def resource(type, params = nil)
+        params ||= Puppet::Parser::AST::ASTArray.new(:children => [])
+        Puppet::Parser::AST::Resource.new(:type => type, :title => Puppet::Parser::AST::String.new(:value => "myresource"), :parameters => params)
+      end
+
+      it "should be able to generate resources with fully qualified type information" do
+        resource("two").evaluate(@twoscope)[0].type.should == "One::Two"
+      end
+
+      it "should be able to generate resources with unqualified type information" do
+        resource("one").evaluate(@twoscope)[0].type.should == "One"
+      end
+
+      it "should correctly generate resources that can look up builtin types" do
+        resource("file").evaluate(@twoscope)[0].type.should == "File"
+      end
+
+      it "should correctly generate resources that can look up defined classes by title" do
+        @scope.known_resource_types.add_hostclass Puppet::Resource::Type.new(:hostclass, "Myresource", {})
+        @scope.compiler.stubs(:evaluate_classes)
+        res = resource("class").evaluate(@twoscope)[0]
+        res.type.should == "Class"
+        res.title.should == "Myresource"
+      end
+
+      it "should evaluate parameterized classes when they are instantiated" do
+        @scope.known_resource_types.add_hostclass Puppet::Resource::Type.new(:hostclass, "Myresource", {})
+        @scope.compiler.expects(:evaluate_classes).with(['myresource'],@twoscope,false)
+        resource("class").evaluate(@twoscope)[0]
+      end
+
+      it "should fail for resource types that do not exist" do
+        lambda { resource("nosuchtype").evaluate(@twoscope) }.should raise_error(Puppet::ParseError)
+      end
     end
+  end
 
-    it "should correctly generate resources that can look up builtin types" do
-      resource("file").evaluate(@twoscope)[0].type.should == "File"
+  describe "for class resources" do
+    before do
+      @title = Puppet::Parser::AST::String.new(:value => "classname")
+      @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
+      @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
+      @scope.stubs(:resource).returns(stub_everything)
+      @resource = ast::Resource.new(:title => @title, :type => "Class", :parameters => ast::ASTArray.new(:children => []) )
+      @resource.stubs(:qualified_type).returns("Resource")
+      @type = Puppet::Resource::Type.new(:hostclass, "classname")
+      @compiler.known_resource_types.add(@type)
     end
 
-    it "should correctly generate resources that can look up defined classes by title" do
-      @scope.known_resource_types.add_hostclass Puppet::Resource::Type.new(:hostclass, "Myresource", {})
-      res = resource("class").evaluate(@twoscope)[0]
-      res.type.should == "Class"
-      res.title.should == "Myresource"
+    it "should instantiate the class" do
+      @compiler.stubs(:evaluate_classes)
+      result = @resource.evaluate(@scope)
+      result.length.should == 1
+      result.first.ref.should == "Class[Classname]"
+      @compiler.catalog.resource("Class[Classname]").should equal(result.first)
     end
 
-    it "should fail for resource types that do not exist" do
-      lambda { resource("nosuchtype").evaluate(@twoscope) }.should raise_error(Puppet::ParseError)
+    it "should cause its parent to be evaluated" do
+      parent_type = Puppet::Resource::Type.new(:hostclass, "parentname")
+      @compiler.stubs(:evaluate_classes)
+      @compiler.known_resource_types.add(parent_type)
+      @type.parent = "parentname"
+      result = @resource.evaluate(@scope)
+      result.length.should == 1
+      result.first.ref.should == "Class[Classname]"
+      @compiler.catalog.resource("Class[Classname]").should equal(result.first)
+      @compiler.catalog.resource("Class[Parentname]").should be_instance_of(Puppet::Parser::Resource)
     end
+
   end
+
 end