diff --git a/lib/puppet/parser/compiler.rb b/lib/puppet/parser/compiler.rb
index 5df2916fc..125b8e9f2 100644
--- a/lib/puppet/parser/compiler.rb
+++ b/lib/puppet/parser/compiler.rb
@@ -1,626 +1,625 @@
 require 'forwardable'
 
 require 'puppet/node'
 require 'puppet/resource/catalog'
 require 'puppet/util/errors'
 
 require 'puppet/resource/type_collection_helper'
 
 # Maintain a graph of scopes, along with a bunch of data
 # about the individual catalog we're compiling.
 class Puppet::Parser::Compiler
   extend Forwardable
 
   include Puppet::Util
   include Puppet::Util::Errors
   include Puppet::Util::MethodHelper
   include Puppet::Resource::TypeCollectionHelper
 
   def self.compile(node)
     $env_module_directories = nil
     node.environment.check_for_reparse
 
     if node.environment.conflicting_manifest_settings?
       errmsg = [
         "The 'disable_per_environment_manifest' setting is true, and this '#{node.environment}'",
         "has an environment.conf manifest that conflicts with the 'default_manifest' setting.",
         "Compilation has been halted in order to avoid running a catalog which may be using",
         "unexpected manifests. For more information, see",
         "http://docs.puppetlabs.com/puppet/latest/reference/environments.html",
       ]
       raise(Puppet::Error, errmsg.join(' '))
     end
 
     new(node).compile.to_resource
   rescue => detail
     message = "#{detail} on node #{node.name}"
     Puppet.log_exception(detail, message)
     raise Puppet::Error, message, detail.backtrace
  end
 
   attr_reader :node, :facts, :collections, :catalog, :resources, :relationships, :topscope
 
   # The injector that provides lookup services, or nil if accessed before the compiler has started compiling and
   # bootstrapped. The injector is initialized and available before any manifests are evaluated.
   #
   # @return [Puppet::Pops::Binder::Injector, nil] The injector that provides lookup services for this compiler/environment
   # @api public
   #
   attr_accessor :injector
 
   # Access to the configured loaders for 4x
   # @return [Puppet::Pops::Loader::Loaders] the configured loaders
   # @api private
   attr_reader :loaders
 
   # The injector that provides lookup services during the creation of the {#injector}.
   # @return [Puppet::Pops::Binder::Injector, nil] The injector that provides lookup services during injector creation
   #   for this compiler/environment
   #
   # @api private
   #
   attr_accessor :boot_injector
 
   # Add a collection to the global list.
   def_delegator :@collections,   :<<, :add_collection
   def_delegator :@relationships, :<<, :add_relationship
 
   # Store a resource override.
   def add_override(override)
     # If possible, merge the override in immediately.
     if resource = @catalog.resource(override.ref)
       resource.merge(override)
     else
       # Otherwise, store the override for later; these
       # get evaluated in Resource#finish.
       @resource_overrides[override.ref] << override
     end
   end
 
   def add_resource(scope, resource)
     @resources << resource
 
     # Note that this will fail if the resource is not unique.
     @catalog.add_resource(resource)
 
     if not resource.class? and resource[:stage]
       raise ArgumentError, "Only classes can set 'stage'; normal resources like #{resource} cannot change run stage"
     end
 
     # Stages should not be inside of classes.  They are always a
     # top-level container, regardless of where they appear in the
     # manifest.
     return if resource.stage?
 
     # This adds a resource to the class it lexically appears in in the
     # manifest.
     unless resource.class?
       return @catalog.add_edge(scope.resource, resource)
     end
   end
 
   # Do we use nodes found in the code, vs. the external node sources?
   def_delegator :known_resource_types, :nodes?, :ast_nodes?
 
   # Store the fact that we've evaluated a class
   def add_class(name)
     @catalog.add_class(name) unless name == ""
   end
 
 
   # Return a list of all of the defined classes.
   def_delegator :@catalog, :classes, :classlist
 
   # Compiler our catalog.  This mostly revolves around finding and evaluating classes.
   # This is the main entry into our catalog.
   def compile
     Puppet.override( @context_overrides , "For compiling #{node.name}") do
       @catalog.environment_instance = environment
 
       # Set the client's parameters into the top scope.
       Puppet::Util::Profiler.profile("Compile: Set node parameters", [:compiler, :set_node_params]) { set_node_parameters }
 
       Puppet::Util::Profiler.profile("Compile: Created settings scope", [:compiler, :create_settings_scope]) { create_settings_scope }
 
       if is_binder_active?
         # create injector, if not already created - this is for 3x that does not trigger
         # lazy loading of injector via context
         Puppet::Util::Profiler.profile("Compile: Created injector", [:compiler, :create_injector]) { injector }
       end
 
       Puppet::Util::Profiler.profile("Compile: Evaluated main", [:compiler, :evaluate_main]) { evaluate_main }
 
       Puppet::Util::Profiler.profile("Compile: Evaluated AST node", [:compiler, :evaluate_ast_node]) { evaluate_ast_node }
 
       Puppet::Util::Profiler.profile("Compile: Evaluated node classes", [:compiler, :evaluate_node_classes]) { evaluate_node_classes }
 
       Puppet::Util::Profiler.profile("Compile: Evaluated generators", [:compiler, :evaluate_generators]) { evaluate_generators }
 
       Puppet::Util::Profiler.profile("Compile: Finished catalog", [:compiler, :finish_catalog]) { finish }
 
       fail_on_unevaluated
 
       @catalog
     end
   end
 
   # Constructs the overrides for the context
   def context_overrides()
     if Puppet[:parser] == 'future'
       require 'puppet/loaders'
       {
         :current_environment => environment,
         :global_scope => @topscope,             # 4x placeholder for new global scope
         :loaders  => lambda {|| loaders() },    # 4x loaders
         :injector => lambda {|| injector() }    # 4x API - via context instead of via compiler
       }
     else
       {
         :current_environment => environment,
       }
     end
   end
 
   def_delegator :@collections, :delete, :delete_collection
 
   # Return the node's environment.
   def environment
     node.environment
   end
 
   # Evaluate all of the classes specified by the node.
   # Classes with parameters are evaluated as if they were declared.
   # Classes without parameters or with an empty set of parameters are evaluated
   # as if they were included. This means classes with an empty set of
   # parameters won't conflict even if the class has already been included.
   def evaluate_node_classes
     if @node.classes.is_a? Hash
       classes_with_params, classes_without_params = @node.classes.partition {|name,params| params and !params.empty?}
 
       # The results from Hash#partition are arrays of pairs rather than hashes,
       # so we have to convert to the forms evaluate_classes expects (Hash, and
       # Array of class names)
       classes_with_params = Hash[classes_with_params]
       classes_without_params.map!(&:first)
     else
       classes_with_params = {}
       classes_without_params = @node.classes
     end
 
-    evaluate_classes(classes_without_params, @node_scope || topscope)
-
     evaluate_classes(classes_with_params, @node_scope || topscope)
+    evaluate_classes(classes_without_params, @node_scope || topscope)
   end
 
   # Evaluate each specified class in turn.  If there are any classes we can't
   # find, raise an error.  This method really just creates resource objects
   # that point back to the classes, and then the resources are themselves
   # evaluated later in the process.
   #
   # Sometimes we evaluate classes with a fully qualified name already, in which
   # case, we tell scope.find_hostclass we've pre-qualified the name so it
   # doesn't need to search its namespaces again.  This gets around a weird
   # edge case of duplicate class names, one at top scope and one nested in our
   # namespace and the wrong one (or both!) getting selected. See ticket #13349
   # for more detail.  --jeffweiss 26 apr 2012
   def evaluate_classes(classes, scope, lazy_evaluate = true, fqname = false)
     raise Puppet::DevError, "No source for scope passed to evaluate_classes" unless scope.source
     class_parameters = nil
     # if we are a param class, save the classes hash
     # and transform classes to be the keys
     if classes.class == Hash
       class_parameters = classes
       classes = classes.keys
     end
 
     hostclasses = classes.collect do |name|
       scope.find_hostclass(name, :assume_fqname => fqname) or raise Puppet::Error, "Could not find class #{name} for #{node.name}"
     end
 
     if class_parameters
       resources = ensure_classes_with_parameters(scope, hostclasses, class_parameters)
       if !lazy_evaluate
         resources.each(&:evaluate)
       end
 
       resources
     else
       already_included, newly_included = ensure_classes_without_parameters(scope, hostclasses)
       if !lazy_evaluate
         newly_included.each(&:evaluate)
       end
 
       already_included + newly_included
     end
   end
 
   def evaluate_relationships
     @relationships.each { |rel| rel.evaluate(catalog) }
   end
 
   # Return a resource by either its ref or its type and title.
   def_delegator :@catalog, :resource, :findresource
 
   def initialize(node, options = {})
     @node = node
     set_options(options)
     initvars
   end
 
   # Create a new scope, with either a specified parent scope or
   # using the top scope.
   def newscope(parent, options = {})
     parent ||= topscope
     scope = Puppet::Parser::Scope.new(self, options)
     scope.parent = parent
     scope
   end
 
   # Return any overrides for the given resource.
   def resource_overrides(resource)
     @resource_overrides[resource.ref]
   end
 
   def injector
     create_injector if @injector.nil?
     @injector
   end
 
   def loaders
     @loaders ||= Puppet::Pops::Loaders.new(environment)
   end
 
   def boot_injector
     create_boot_injector(nil) if @boot_injector.nil?
     @boot_injector
   end
 
   # Creates the boot injector from registered system, default, and injector config.
   # @return [Puppet::Pops::Binder::Injector] the created boot injector
   # @api private Cannot be 'private' since it is called from the BindingsComposer.
   #
   def create_boot_injector(env_boot_bindings)
     assert_binder_active()
     pb = Puppet::Pops::Binder
     boot_contribution = pb::SystemBindings.injector_boot_contribution(env_boot_bindings)
     final_contribution = pb::SystemBindings.final_contribution
     binder = pb::Binder.new(pb::BindingsFactory.layered_bindings(final_contribution, boot_contribution))
     @boot_injector = pb::Injector.new(binder)
   end
 
   # Answers if Puppet Binder should be active or not, and if it should and is not active, then it is activated.
   # @return [Boolean] true if the Puppet Binder should be activated
   def is_binder_active?
     should_be_active = Puppet[:binder] || Puppet[:parser] == 'future'
     if should_be_active
       # TODO: this should be in a central place, not just for ParserFactory anymore...
       Puppet::Parser::ParserFactory.assert_rgen_installed()
       @@binder_loaded ||= false
       unless @@binder_loaded
         require 'puppet/pops'
         require 'puppetx'
         @@binder_loaded = true
       end
     end
     should_be_active
   end
 
   private
 
   def ensure_classes_with_parameters(scope, hostclasses, parameters)
     hostclasses.collect do |klass|
       klass.ensure_in_catalog(scope, parameters[klass.name] || {})
     end
   end
 
   def ensure_classes_without_parameters(scope, hostclasses)
     already_included = []
     newly_included = []
     hostclasses.each do |klass|
       class_scope = scope.class_scope(klass)
       if class_scope
         already_included << class_scope.resource
       else
         newly_included << klass.ensure_in_catalog(scope)
       end
     end
 
     [already_included, newly_included]
   end
 
   # If ast nodes are enabled, then see if we can find and evaluate one.
   def evaluate_ast_node
     return unless ast_nodes?
 
     # Now see if we can find the node.
     astnode = nil
     @node.names.each do |name|
       break if astnode = known_resource_types.node(name.to_s.downcase)
     end
 
     unless (astnode ||= known_resource_types.node("default"))
       raise Puppet::ParseError, "Could not find default node or by name with '#{node.names.join(", ")}'"
     end
 
     # Create a resource to model this node, and then add it to the list
     # of resources.
     resource = astnode.ensure_in_catalog(topscope)
 
     resource.evaluate
 
     @node_scope = topscope.class_scope(astnode)
   end
 
   # Evaluate our collections and return true if anything returned an object.
   # The 'true' is used to continue a loop, so it's important.
   def evaluate_collections
     return false if @collections.empty?
 
     exceptwrap do
       # We have to iterate over a dup of the array because
       # collections can delete themselves from the list, which
       # changes its length and causes some collections to get missed.
       Puppet::Util::Profiler.profile("Evaluated collections", [:compiler, :evaluate_collections]) do
         found_something = false
         @collections.dup.each do |collection|
           found_something = true if collection.evaluate
         end
         found_something
       end
     end
   end
 
   # Make sure all of our resources have been evaluated into native resources.
   # We return true if any resources have, so that we know to continue the
   # evaluate_generators loop.
   def evaluate_definitions
     exceptwrap do
       Puppet::Util::Profiler.profile("Evaluated definitions", [:compiler, :evaluate_definitions]) do
         !unevaluated_resources.each do |resource|
           Puppet::Util::Profiler.profile("Evaluated resource #{resource}", [:compiler, :evaluate_resource, resource]) do
             resource.evaluate
           end
         end.empty?
       end
     end
   end
 
   # Iterate over collections and resources until we're sure that the whole
   # compile is evaluated.  This is necessary because both collections
   # and defined resources can generate new resources, which themselves could
   # be defined resources.
   def evaluate_generators
     count = 0
     loop do
       done = true
 
       Puppet::Util::Profiler.profile("Iterated (#{count + 1}) on generators", [:compiler, :iterate_on_generators]) do
         # Call collections first, then definitions.
         done = false if evaluate_collections
         done = false if evaluate_definitions
       end
 
       break if done
 
       count += 1
 
       if count > 1000
         raise Puppet::ParseError, "Somehow looped more than 1000 times while evaluating host catalog"
       end
     end
   end
 
   # Find and evaluate our main object, if possible.
   def evaluate_main
     @main = known_resource_types.find_hostclass([""], "") || known_resource_types.add(Puppet::Resource::Type.new(:hostclass, ""))
     @topscope.source = @main
     @main_resource = Puppet::Parser::Resource.new("class", :main, :scope => @topscope, :source => @main)
     @topscope.resource = @main_resource
 
     add_resource(@topscope, @main_resource)
 
     @main_resource.evaluate
   end
 
   # Make sure the entire catalog is evaluated.
   def fail_on_unevaluated
     fail_on_unevaluated_overrides
     fail_on_unevaluated_resource_collections
   end
 
   # If there are any resource overrides remaining, then we could
   # not find the resource they were supposed to override, so we
   # want to throw an exception.
   def fail_on_unevaluated_overrides
     remaining = @resource_overrides.values.flatten.collect(&:ref)
 
     if !remaining.empty?
       fail Puppet::ParseError,
         "Could not find resource(s) #{remaining.join(', ')} for overriding"
     end
   end
 
   # Make sure we don't have any remaining collections that specifically
   # look for resources, because we want to consider those to be
   # parse errors.
   def fail_on_unevaluated_resource_collections
     remaining = @collections.collect(&:resources).flatten.compact
 
     if !remaining.empty?
       raise Puppet::ParseError, "Failed to realize virtual resources #{remaining.join(', ')}"
     end
   end
 
   # Make sure all of our resources and such have done any last work
   # necessary.
   def finish
     evaluate_relationships
 
     resources.each do |resource|
       # Add in any resource overrides.
       if overrides = resource_overrides(resource)
         overrides.each do |over|
           resource.merge(over)
         end
 
         # Remove the overrides, so that the configuration knows there
         # are none left.
         overrides.clear
       end
 
       resource.finish if resource.respond_to?(:finish)
     end
 
     add_resource_metaparams
   end
 
   def add_resource_metaparams
     unless main = catalog.resource(:class, :main)
       raise "Couldn't find main"
     end
 
     names = Puppet::Type.metaparams.select do |name|
       !Puppet::Parser::Resource.relationship_parameter?(name)
     end
 
     data = {}
     catalog.walk(main, :out) do |source, target|
       if source_data = data[source] || metaparams_as_data(source, names)
         # only store anything in the data hash if we've actually got
         # data
         data[source] ||= source_data
         source_data.each do |param, value|
           target[param] = value if target[param].nil?
         end
         data[target] = source_data.merge(metaparams_as_data(target, names))
       end
 
       target.tag(*(source.tags))
     end
   end
 
   def metaparams_as_data(resource, params)
     data = nil
     params.each do |param|
       unless resource[param].nil?
         # Because we could be creating a hash for every resource,
         # and we actually probably don't often have any data here at all,
         # we're optimizing a bit by only creating a hash if there's
         # any data to put in it.
         data ||= {}
         data[param] = resource[param]
       end
     end
     data
   end
 
   # Set up all of our internal variables.
   def initvars
     # The list of overrides.  This is used to cache overrides on objects
     # that don't exist yet.  We store an array of each override.
     @resource_overrides = Hash.new do |overs, ref|
       overs[ref] = []
     end
 
     # The list of collections that have been created.  This is a global list,
     # but they each refer back to the scope that created them.
     @collections = []
 
     # The list of relationships to evaluate.
     @relationships = []
 
     # For maintaining the relationship between scopes and their resources.
     @catalog = Puppet::Resource::Catalog.new(@node.name, @node.environment)
 
     # MOVED HERE - SCOPE IS NEEDED (MOVE-SCOPE)
     # Create the initial scope, it is needed early
     @topscope = Puppet::Parser::Scope.new(self)
 
     # Need to compute overrides here, and remember them, because we are about to
     # enter the magic zone of known_resource_types and intial import.
     # Expensive entries in the context are bound lazily.
     @context_overrides = context_overrides()
 
     # This construct ensures that initial import (triggered by instantiating
     # the structure 'known_resource_types') has a configured context
     # It cannot survive the initvars method, and is later reinstated
     # as part of compiling...
     #
     Puppet.override( @context_overrides , "For initializing compiler") do
       # THE MAGIC STARTS HERE ! This triggers parsing, loading etc.
       @catalog.version = known_resource_types.version
     end
 
     @catalog.add_resource(Puppet::Parser::Resource.new("stage", :main, :scope => @topscope))
 
     # local resource array to maintain resource ordering
     @resources = []
 
     # Make sure any external node classes are in our class list
     if @node.classes.class == Hash
       @catalog.add_class(*@node.classes.keys)
     else
       @catalog.add_class(*@node.classes)
     end
   end
 
   # Set the node's parameters into the top-scope as variables.
   def set_node_parameters
     node.parameters.each do |param, value|
       @topscope[param.to_s] = value
     end
     # These might be nil.
     catalog.client_version = node.parameters["clientversion"]
     catalog.server_version = node.parameters["serverversion"]
     if Puppet[:trusted_node_data]
       @topscope.set_trusted(node.trusted_data)
     end
     if(Puppet[:immutable_node_data])
       facts_hash = node.facts.nil? ? {} : node.facts.values
       @topscope.set_facts(facts_hash)
     end
   end
 
   def create_settings_scope
     settings_type = Puppet::Resource::Type.new :hostclass, "settings"
     environment.known_resource_types.add(settings_type)
 
     settings_resource = Puppet::Parser::Resource.new("class", "settings", :scope => @topscope)
 
     @catalog.add_resource(settings_resource)
 
     settings_type.evaluate_code(settings_resource)
 
     scope = @topscope.class_scope(settings_type)
 
     env = environment
     Puppet.settings.each do |name, setting|
       next if name == :name
       scope[name.to_s] = env[name]
     end
   end
 
   # Return an array of all of the unevaluated resources.  These will be definitions,
   # which need to get evaluated into native resources.
   def unevaluated_resources
     # The order of these is significant for speed due to short-circuting
     resources.reject { |resource| resource.evaluated? or resource.virtual? or resource.builtin_type? }
   end
 
   # Creates the injector from bindings found in the current environment.
   # @return [void]
   # @api private
   #
   def create_injector
     assert_binder_active()
     composer = Puppet::Pops::Binder::BindingsComposer.new()
     layered_bindings = composer.compose(topscope)
     @injector = Puppet::Pops::Binder::Injector.new(Puppet::Pops::Binder::Binder.new(layered_bindings))
   end
 
   def assert_binder_active
     unless is_binder_active?
       raise ArgumentError, "The Puppet Binder is only available when either '--binder true' or '--parser future' is used"
     end
   end
 end
diff --git a/spec/unit/parser/compiler_spec.rb b/spec/unit/parser/compiler_spec.rb
index 0ca01f521..74cb326d9 100755
--- a/spec/unit/parser/compiler_spec.rb
+++ b/spec/unit/parser/compiler_spec.rb
@@ -1,910 +1,928 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
+require 'matchers/resource'
 
 class CompilerTestResource
   attr_accessor :builtin, :virtual, :evaluated, :type, :title
 
   def initialize(type, title)
     @type = type
     @title = title
   end
 
   def [](attr)
     return nil if attr == :stage
     :main
   end
 
   def ref
     "#{type.to_s.capitalize}[#{title}]"
   end
 
   def evaluated?
     @evaluated
   end
 
   def builtin_type?
     @builtin
   end
 
   def virtual?
     @virtual
   end
 
   def class?
     false
   end
 
   def stage?
     false
   end
 
   def evaluate
   end
 
   def file
     "/fake/file/goes/here"
   end
 
   def line
     "42"
   end
 end
 
 describe Puppet::Parser::Compiler do
   include PuppetSpec::Files
+  include Matchers::Resource
 
   def resource(type, title)
     Puppet::Parser::Resource.new(type, title, :scope => @scope)
   end
 
   before :each do
     # Push me faster, I wanna go back in time!  (Specifically, freeze time
     # across the test since we have a bunch of version == timestamp code
     # hidden away in the implementation and we keep losing the race.)
     # --daniel 2011-04-21
     now = Time.now
     Time.stubs(:now).returns(now)
 
     environment = Puppet::Node::Environment.create(:testing, [])
     @node = Puppet::Node.new("testnode",
                              :facts => Puppet::Node::Facts.new("facts", {}),
                              :environment => environment)
     @known_resource_types = environment.known_resource_types
     @compiler = Puppet::Parser::Compiler.new(@node)
     @scope = Puppet::Parser::Scope.new(@compiler, :source => stub('source'))
     @scope_resource = Puppet::Parser::Resource.new(:file, "/my/file", :scope => @scope)
     @scope.resource = @scope_resource
   end
 
   it "should have a class method that compiles, converts, and returns a catalog" do
     compiler = stub 'compiler'
     Puppet::Parser::Compiler.expects(:new).with(@node).returns compiler
     catalog = stub 'catalog'
     compiler.expects(:compile).returns catalog
     converted_catalog = stub 'converted_catalog'
     catalog.expects(:to_resource).returns converted_catalog
 
     Puppet::Parser::Compiler.compile(@node).should equal(converted_catalog)
   end
 
   it "should fail intelligently when a class-level compile fails" do
     Puppet::Parser::Compiler.expects(:new).raises ArgumentError
     lambda { Puppet::Parser::Compiler.compile(@node) }.should raise_error(Puppet::Error)
   end
 
   it "should use the node's environment as its environment" do
     @compiler.environment.should equal(@node.environment)
   end
 
   it "fails if the node's environment has conflicting manifest settings" do
     conflicted_environment = Puppet::Node::Environment.create(:testing, [], '/some/environment.conf/manifest.pp')
     conflicted_environment.stubs(:conflicting_manifest_settings?).returns(true)
     @node.environment = conflicted_environment
     expect { Puppet::Parser::Compiler.compile(@node) }.to raise_error(Puppet::Error, /disable_per_environment_manifest.*true.*environment.conf.*manifest.*conflict/)
   end
 
   it "should include the resource type collection helper" do
     Puppet::Parser::Compiler.ancestors.should be_include(Puppet::Resource::TypeCollectionHelper)
   end
 
   it "should be able to return a class list containing all added classes" do
     @compiler.add_class ""
     @compiler.add_class "one"
     @compiler.add_class "two"
 
     @compiler.classlist.sort.should == %w{one two}.sort
   end
 
   it "should clear the global caches before compile" do
     compiler = stub 'compiler'
     Puppet::Parser::Compiler.expects(:new).with(@node).returns compiler
     catalog = stub 'catalog'
     compiler.expects(:compile).returns catalog
     catalog.expects(:to_resource)
 
     $known_resource_types = "rspec"
     $env_module_directories = "rspec"
 
     Puppet::Parser::Compiler.compile(@node)
 
     $known_resource_types = nil
     $env_module_directories = nil
   end
 
   describe "when initializing" do
 
     it "should set its node attribute" do
       @compiler.node.should equal(@node)
     end
     it "should detect when ast nodes are absent" do
       @compiler.ast_nodes?.should be_false
     end
 
     it "should detect when ast nodes are present" do
       @known_resource_types.expects(:nodes?).returns true
       @compiler.ast_nodes?.should be_true
     end
 
     it "should copy the known_resource_types version to the catalog" do
       @compiler.catalog.version.should == @known_resource_types.version
     end
 
     it "should copy any node classes into the class list" do
       node = Puppet::Node.new("mynode")
       node.classes = %w{foo bar}
       compiler = Puppet::Parser::Compiler.new(node)
 
       compiler.classlist.should =~ ['foo', 'bar']
     end
 
     it "should transform node class hashes into a class list" do
       node = Puppet::Node.new("mynode")
       node.classes = {'foo'=>{'one'=>'p1'}, 'bar'=>{'two'=>'p2'}}
       compiler = Puppet::Parser::Compiler.new(node)
 
       compiler.classlist.should =~ ['foo', 'bar']
     end
 
     it "should add a 'main' stage to the catalog" do
       @compiler.catalog.resource(:stage, :main).should be_instance_of(Puppet::Parser::Resource)
     end
   end
 
   describe "when managing scopes" do
 
     it "should create a top scope" do
       @compiler.topscope.should be_instance_of(Puppet::Parser::Scope)
     end
 
     it "should be able to create new scopes" do
       @compiler.newscope(@compiler.topscope).should be_instance_of(Puppet::Parser::Scope)
     end
 
     it "should set the parent scope of the new scope to be the passed-in parent" do
       scope = mock 'scope'
       newscope = @compiler.newscope(scope)
 
       newscope.parent.should equal(scope)
     end
 
     it "should set the parent scope of the new scope to its topscope if the parent passed in is nil" do
       scope = mock 'scope'
       newscope = @compiler.newscope(nil)
 
       newscope.parent.should equal(@compiler.topscope)
     end
   end
 
   describe "when compiling" do
 
     def compile_methods
       [:set_node_parameters, :evaluate_main, :evaluate_ast_node, :evaluate_node_classes, :evaluate_generators, :fail_on_unevaluated,
         :finish, :store, :extract, :evaluate_relationships]
     end
 
     # Stub all of the main compile methods except the ones we're specifically interested in.
     def compile_stub(*except)
       (compile_methods - except).each { |m| @compiler.stubs(m) }
     end
 
     it "should set node parameters as variables in the top scope" do
       params = {"a" => "b", "c" => "d"}
       @node.stubs(:parameters).returns(params)
       compile_stub(:set_node_parameters)
       @compiler.compile
       @compiler.topscope['a'].should == "b"
       @compiler.topscope['c'].should == "d"
     end
 
     it "should set the client and server versions on the catalog" do
       params = {"clientversion" => "2", "serverversion" => "3"}
       @node.stubs(:parameters).returns(params)
       compile_stub(:set_node_parameters)
       @compiler.compile
       @compiler.catalog.client_version.should == "2"
       @compiler.catalog.server_version.should == "3"
     end
 
     it "should evaluate the main class if it exists" do
       compile_stub(:evaluate_main)
       main_class = @known_resource_types.add Puppet::Resource::Type.new(:hostclass, "")
       main_class.expects(:evaluate_code).with { |r| r.is_a?(Puppet::Parser::Resource) }
       @compiler.topscope.expects(:source=).with(main_class)
 
       @compiler.compile
     end
 
     it "should create a new, empty 'main' if no main class exists" do
       compile_stub(:evaluate_main)
       @compiler.compile
       @known_resource_types.find_hostclass([""], "").should be_instance_of(Puppet::Resource::Type)
     end
 
     it "should add an edge between the main stage and main class" do
       @compiler.compile
       (stage = @compiler.catalog.resource(:stage, "main")).should be_instance_of(Puppet::Parser::Resource)
       (klass = @compiler.catalog.resource(:class, "")).should be_instance_of(Puppet::Parser::Resource)
 
       @compiler.catalog.edge?(stage, klass).should be_true
     end
 
     it "should evaluate all added collections" do
       colls = []
       # And when the collections fail to evaluate.
       colls << mock("coll1-false")
       colls << mock("coll2-false")
       colls.each { |c| c.expects(:evaluate).returns(false) }
 
       @compiler.add_collection(colls[0])
       @compiler.add_collection(colls[1])
 
       compile_stub(:evaluate_generators)
       @compiler.compile
     end
 
     it "should ignore builtin resources" do
       resource = resource(:file, "testing")
 
       @compiler.add_resource(@scope, resource)
       resource.expects(:evaluate).never
 
       @compiler.compile
     end
 
     it "should evaluate unevaluated resources" do
       resource = CompilerTestResource.new(:file, "testing")
 
       @compiler.add_resource(@scope, resource)
 
       # We have to now mark the resource as evaluated
       resource.expects(:evaluate).with { |*whatever| resource.evaluated = true }
 
       @compiler.compile
     end
 
     it "should not evaluate already-evaluated resources" do
       resource = resource(:file, "testing")
       resource.stubs(:evaluated?).returns true
 
       @compiler.add_resource(@scope, resource)
       resource.expects(:evaluate).never
 
       @compiler.compile
     end
 
     it "should evaluate unevaluated resources created by evaluating other resources" do
       resource = CompilerTestResource.new(:file, "testing")
       @compiler.add_resource(@scope, resource)
 
       resource2 = CompilerTestResource.new(:file, "other")
 
       # We have to now mark the resource as evaluated
       resource.expects(:evaluate).with { |*whatever| resource.evaluated = true; @compiler.add_resource(@scope, resource2) }
       resource2.expects(:evaluate).with { |*whatever| resource2.evaluated = true }
 
 
       @compiler.compile
     end
 
     describe "when finishing" do
       before do
         @compiler.send(:evaluate_main)
         @catalog = @compiler.catalog
       end
 
       def add_resource(name, parent = nil)
         resource = Puppet::Parser::Resource.new "file", name, :scope => @scope
         @compiler.add_resource(@scope, resource)
         @catalog.add_edge(parent, resource) if parent
         resource
       end
 
       it "should call finish() on all resources" do
         # Add a resource that does respond to :finish
         resource = Puppet::Parser::Resource.new "file", "finish", :scope => @scope
         resource.expects(:finish)
 
         @compiler.add_resource(@scope, resource)
 
         # And one that does not
         dnf_resource = stub_everything "dnf", :ref => "File[dnf]", :type => "file"
 
         @compiler.add_resource(@scope, dnf_resource)
 
         @compiler.send(:finish)
       end
 
       it "should call finish() in add_resource order" do
         resources = sequence('resources')
 
         resource1 = add_resource("finish1")
         resource1.expects(:finish).in_sequence(resources)
 
         resource2 = add_resource("finish2")
         resource2.expects(:finish).in_sequence(resources)
 
         @compiler.send(:finish)
       end
 
       it "should add each container's metaparams to its contained resources" do
         main = @catalog.resource(:class, :main)
         main[:noop] = true
 
         resource1 = add_resource("meh", main)
 
         @compiler.send(:finish)
         resource1[:noop].should be_true
       end
 
       it "should add metaparams recursively" do
         main = @catalog.resource(:class, :main)
         main[:noop] = true
 
         resource1 = add_resource("meh", main)
         resource2 = add_resource("foo", resource1)
 
         @compiler.send(:finish)
         resource2[:noop].should be_true
       end
 
       it "should prefer metaparams from immediate parents" do
         main = @catalog.resource(:class, :main)
         main[:noop] = true
 
         resource1 = add_resource("meh", main)
         resource2 = add_resource("foo", resource1)
 
         resource1[:noop] = false
 
         @compiler.send(:finish)
         resource2[:noop].should be_false
       end
 
       it "should merge tags downward" do
         main = @catalog.resource(:class, :main)
         main.tag("one")
 
         resource1 = add_resource("meh", main)
         resource1.tag "two"
         resource2 = add_resource("foo", resource1)
 
         @compiler.send(:finish)
         resource2.tags.should be_include("one")
         resource2.tags.should be_include("two")
       end
 
       it "should work if only middle resources have metaparams set" do
         main = @catalog.resource(:class, :main)
 
         resource1 = add_resource("meh", main)
         resource1[:noop] = true
         resource2 = add_resource("foo", resource1)
 
         @compiler.send(:finish)
         resource2[:noop].should be_true
       end
     end
 
     it "should return added resources in add order" do
       resource1 = resource(:file, "yay")
       @compiler.add_resource(@scope, resource1)
       resource2 = resource(:file, "youpi")
       @compiler.add_resource(@scope, resource2)
 
       @compiler.resources.should == [resource1, resource2]
     end
 
     it "should add resources that do not conflict with existing resources" do
       resource = resource(:file, "yay")
       @compiler.add_resource(@scope, resource)
 
       @compiler.catalog.should be_vertex(resource)
     end
 
     it "should fail to add resources that conflict with existing resources" do
       path = make_absolute("/foo")
       file1 = resource(:file, path)
       file2 = resource(:file, path)
 
       @compiler.add_resource(@scope, file1)
       lambda { @compiler.add_resource(@scope, file2) }.should raise_error(Puppet::Resource::Catalog::DuplicateResourceError)
     end
 
     it "should add an edge from the scope resource to the added resource" do
       resource = resource(:file, "yay")
       @compiler.add_resource(@scope, resource)
 
       @compiler.catalog.should be_edge(@scope.resource, resource)
     end
 
     it "should not add non-class resources that don't specify a stage to the 'main' stage" do
       main = @compiler.catalog.resource(:stage, :main)
       resource = resource(:file, "foo")
       @compiler.add_resource(@scope, resource)
 
       @compiler.catalog.should_not be_edge(main, resource)
     end
 
     it "should not add any parent-edges to stages" do
       stage = resource(:stage, "other")
       @compiler.add_resource(@scope, stage)
 
       @scope.resource = resource(:class, "foo")
 
       @compiler.catalog.edge?(@scope.resource, stage).should be_false
     end
 
     it "should not attempt to add stages to other stages" do
       other_stage = resource(:stage, "other")
       second_stage = resource(:stage, "second")
       @compiler.add_resource(@scope, other_stage)
       @compiler.add_resource(@scope, second_stage)
 
       second_stage[:stage] = "other"
 
       @compiler.catalog.edge?(other_stage, second_stage).should be_false
     end
 
     it "should have a method for looking up resources" do
       resource = resource(:yay, "foo")
       @compiler.add_resource(@scope, resource)
       @compiler.findresource("Yay[foo]").should equal(resource)
     end
 
     it "should be able to look resources up by type and title" do
       resource = resource(:yay, "foo")
       @compiler.add_resource(@scope, resource)
       @compiler.findresource("Yay", "foo").should equal(resource)
     end
 
     it "should not evaluate virtual defined resources" do
       resource = resource(:file, "testing")
       resource.virtual = true
       @compiler.add_resource(@scope, resource)
 
       resource.expects(:evaluate).never
 
       @compiler.compile
     end
   end
 
   describe "when evaluating collections" do
 
     it "should evaluate each collection" do
       2.times { |i|
         coll = mock 'coll%s' % i
         @compiler.add_collection(coll)
 
         # This is the hard part -- we have to emulate the fact that
         # collections delete themselves if they are done evaluating.
         coll.expects(:evaluate).with do
           @compiler.delete_collection(coll)
         end
       }
 
       @compiler.compile
     end
 
     it "should not fail when there are unevaluated resource collections that do not refer to specific resources" do
       coll = stub 'coll', :evaluate => false
       coll.expects(:resources).returns(nil)
 
       @compiler.add_collection(coll)
 
       lambda { @compiler.compile }.should_not raise_error
     end
 
     it "should fail when there are unevaluated resource collections that refer to a specific resource" do
       coll = stub 'coll', :evaluate => false
       coll.expects(:resources).returns(:something)
 
       @compiler.add_collection(coll)
 
       lambda { @compiler.compile }.should raise_error Puppet::ParseError, 'Failed to realize virtual resources something'
     end
 
     it "should fail when there are unevaluated resource collections that refer to multiple specific resources" do
       coll = stub 'coll', :evaluate => false
       coll.expects(:resources).returns([:one, :two])
 
       @compiler.add_collection(coll)
 
       lambda { @compiler.compile }.should raise_error Puppet::ParseError, 'Failed to realize virtual resources one, two'
     end
   end
 
   describe "when evaluating relationships" do
     it "should evaluate each relationship with its catalog" do
       dep = stub 'dep'
       dep.expects(:evaluate).with(@compiler.catalog)
       @compiler.add_relationship dep
       @compiler.evaluate_relationships
     end
   end
 
   describe "when told to evaluate missing classes" do
 
     it "should fail if there's no source listed for the scope" do
       scope = stub 'scope', :source => nil
       proc { @compiler.evaluate_classes(%w{one two}, scope) }.should raise_error(Puppet::DevError)
     end
 
     it "should raise an error if a class is not found" do
       @scope.expects(:find_hostclass).with("notfound", {:assume_fqname => false}).returns(nil)
       lambda{ @compiler.evaluate_classes(%w{notfound}, @scope) }.should raise_error(Puppet::Error, /Could not find class/)
     end
 
     it "should raise an error when it can't find class" do
       klasses = {'foo'=>nil}
       @node.classes = klasses
       @compiler.topscope.expects(:find_hostclass).with('foo', {:assume_fqname => false}).returns(nil)
       lambda{ @compiler.compile }.should raise_error(Puppet::Error, /Could not find class foo for testnode/)
     end
   end
 
   describe "when evaluating found classes" do
 
     before do
       Puppet.settings[:data_binding_terminus] = "none"
       @class = stub 'class', :name => "my::class"
       @scope.stubs(:find_hostclass).with("myclass", {:assume_fqname => false}).returns(@class)
 
       @resource = stub 'resource', :ref => "Class[myclass]", :type => "file"
     end
 
     it "should evaluate each class" do
       @compiler.catalog.stubs(:tag)
 
       @class.expects(:ensure_in_catalog).with(@scope)
       @scope.stubs(:class_scope).with(@class)
 
       @compiler.evaluate_classes(%w{myclass}, @scope)
     end
 
     describe "and the classes are specified as a hash with parameters" do
       before do
         @node.classes = {}
         @ast_obj = Puppet::Parser::AST::String.new(:value => 'foo')
       end
 
       # Define the given class with default parameters
       def define_class(name, parameters)
         @node.classes[name] = parameters
         klass = Puppet::Resource::Type.new(:hostclass, name, :arguments => {'p1' => @ast_obj, 'p2' => @ast_obj})
         @compiler.topscope.known_resource_types.add klass
       end
 
       def compile
         @catalog = @compiler.compile
       end
 
       it "should record which classes are evaluated" do
         classes = {'foo'=>{}, 'bar::foo'=>{}, 'bar'=>{}}
         classes.each { |c, params| define_class(c, params) }
         compile()
         classes.each { |name, p| @catalog.classes.should include(name) }
       end
 
       it "should provide default values for parameters that have no values specified" do
         define_class('foo', {})
         compile()
         @catalog.resource(:class, 'foo')['p1'].should == "foo"
       end
 
       it "should use any provided values" do
         define_class('foo', {'p1' => 'real_value'})
         compile()
         @catalog.resource(:class, 'foo')['p1'].should == "real_value"
       end
 
       it "should support providing some but not all values" do
         define_class('foo', {'p1' => 'real_value'})
         compile()
         @catalog.resource(:class, 'Foo')['p1'].should == "real_value"
         @catalog.resource(:class, 'Foo')['p2'].should == "foo"
       end
 
       it "should ensure each node class is in catalog and has appropriate tags" do
         klasses = ['bar::foo']
         @node.classes = klasses
         ast_obj = Puppet::Parser::AST::String.new(:value => 'foo')
         klasses.each do |name|
           klass = Puppet::Resource::Type.new(:hostclass, name, :arguments => {'p1' => ast_obj, 'p2' => ast_obj})
           @compiler.topscope.known_resource_types.add klass
         end
         catalog = @compiler.compile
 
         r2 = catalog.resources.detect {|r| r.title == 'Bar::Foo' }
         r2.tags.should == Puppet::Util::TagSet.new(['bar::foo', 'class', 'bar', 'foo'])
       end
     end
 
     it "should fail if required parameters are missing" do
       klass = {'foo'=>{'a'=>'one'}}
       @node.classes = klass
       klass = Puppet::Resource::Type.new(:hostclass, 'foo', :arguments => {'a' => nil, 'b' => nil})
       @compiler.topscope.known_resource_types.add klass
       lambda { @compiler.compile }.should raise_error(Puppet::ParseError, "Must pass b to Class[Foo]")
     end
 
     it "should fail if invalid parameters are passed" do
       klass = {'foo'=>{'3'=>'one'}}
       @node.classes = klass
       klass = Puppet::Resource::Type.new(:hostclass, 'foo', :arguments => {})
       @compiler.topscope.known_resource_types.add klass
       lambda { @compiler.compile }.should raise_error(Puppet::ParseError, "Invalid parameter 3 on Class[Foo]")
     end
 
     it "should ensure class is in catalog without params" do
       @node.classes = klasses = {'foo'=>nil}
       foo = Puppet::Resource::Type.new(:hostclass, 'foo')
       @compiler.topscope.known_resource_types.add foo
       catalog = @compiler.compile
       catalog.classes.should include 'foo'
     end
 
     it "should not evaluate the resources created for found classes unless asked" do
       @compiler.catalog.stubs(:tag)
 
       @resource.expects(:evaluate).never
 
       @class.expects(:ensure_in_catalog).returns(@resource)
       @scope.stubs(:class_scope).with(@class)
 
       @compiler.evaluate_classes(%w{myclass}, @scope)
     end
 
     it "should immediately evaluate the resources created for found classes when asked" do
       @compiler.catalog.stubs(:tag)
 
       @resource.expects(:evaluate)
       @class.expects(:ensure_in_catalog).returns(@resource)
       @scope.stubs(:class_scope).with(@class)
 
       @compiler.evaluate_classes(%w{myclass}, @scope, false)
     end
 
     it "should skip classes that have already been evaluated" do
       @compiler.catalog.stubs(:tag)
 
       @scope.stubs(:class_scope).with(@class).returns(@scope)
 
       @compiler.expects(:add_resource).never
 
       @resource.expects(:evaluate).never
 
       Puppet::Parser::Resource.expects(:new).never
       @compiler.evaluate_classes(%w{myclass}, @scope, false)
     end
 
     it "should skip classes previously evaluated with different capitalization" do
       @compiler.catalog.stubs(:tag)
       @scope.stubs(:find_hostclass).with("MyClass",{:assume_fqname => false}).returns(@class)
       @scope.stubs(:class_scope).with(@class).returns(@scope)
       @compiler.expects(:add_resource).never
       @resource.expects(:evaluate).never
       Puppet::Parser::Resource.expects(:new).never
       @compiler.evaluate_classes(%w{MyClass}, @scope, false)
     end
   end
 
   describe "when evaluating AST nodes with no AST nodes present" do
 
     it "should do nothing" do
       @compiler.expects(:ast_nodes?).returns(false)
       @compiler.known_resource_types.expects(:nodes).never
       Puppet::Parser::Resource.expects(:new).never
 
       @compiler.send(:evaluate_ast_node)
     end
   end
 
   describe "when evaluating AST nodes with AST nodes present" do
 
     before do
       @compiler.known_resource_types.stubs(:nodes?).returns true
 
       # Set some names for our test
       @node.stubs(:names).returns(%w{a b c})
       @compiler.known_resource_types.stubs(:node).with("a").returns(nil)
       @compiler.known_resource_types.stubs(:node).with("b").returns(nil)
       @compiler.known_resource_types.stubs(:node).with("c").returns(nil)
 
       # It should check this last, of course.
       @compiler.known_resource_types.stubs(:node).with("default").returns(nil)
     end
 
     it "should fail if the named node cannot be found" do
       proc { @compiler.send(:evaluate_ast_node) }.should raise_error(Puppet::ParseError)
     end
 
     it "should evaluate the first node class matching the node name" do
       node_class = stub 'node', :name => "c", :evaluate_code => nil
       @compiler.known_resource_types.stubs(:node).with("c").returns(node_class)
 
       node_resource = stub 'node resource', :ref => "Node[c]", :evaluate => nil, :type => "node"
       node_class.expects(:ensure_in_catalog).returns(node_resource)
 
       @compiler.compile
     end
 
     it "should match the default node if no matching node can be found" do
       node_class = stub 'node', :name => "default", :evaluate_code => nil
       @compiler.known_resource_types.stubs(:node).with("default").returns(node_class)
 
       node_resource = stub 'node resource', :ref => "Node[default]", :evaluate => nil, :type => "node"
       node_class.expects(:ensure_in_catalog).returns(node_resource)
 
       @compiler.compile
     end
 
     it "should evaluate the node resource immediately rather than using lazy evaluation" do
       node_class = stub 'node', :name => "c"
       @compiler.known_resource_types.stubs(:node).with("c").returns(node_class)
 
       node_resource = stub 'node resource', :ref => "Node[c]", :type => "node"
       node_class.expects(:ensure_in_catalog).returns(node_resource)
 
       node_resource.expects(:evaluate)
 
       @compiler.send(:evaluate_ast_node)
     end
   end
 
   describe "when evaluating node classes" do
     include PuppetSpec::Compiler
 
     describe "when provided classes in array format" do
       let(:node) { Puppet::Node.new('someone', :classes => ['something']) }
 
       describe "when the class exists" do
         it "should succeed if the class is already included" do
           manifest = <<-MANIFEST
           class something {}
           include something
           MANIFEST
 
           catalog = compile_to_catalog(manifest, node)
 
           catalog.resource('Class', 'Something').should_not be_nil
         end
 
         it "should evaluate the class without parameters if it's not already included" do
           manifest = "class something {}"
 
           catalog = compile_to_catalog(manifest, node)
 
           catalog.resource('Class', 'Something').should_not be_nil
         end
       end
 
       it "should fail if the class doesn't exist" do
         expect { compile_to_catalog('', node) }.to raise_error(Puppet::Error, /Could not find class something/)
       end
     end
 
     describe "when provided classes in hash format" do
       describe "for classes without parameters" do
         let(:node) { Puppet::Node.new('someone', :classes => {'something' => {}}) }
 
         describe "when the class exists" do
           it "should succeed if the class is already included" do
             manifest = <<-MANIFEST
             class something {}
             include something
             MANIFEST
 
             catalog = compile_to_catalog(manifest, node)
 
             catalog.resource('Class', 'Something').should_not be_nil
           end
 
           it "should evaluate the class if it's not already included" do
             manifest = <<-MANIFEST
             class something {}
             MANIFEST
 
             catalog = compile_to_catalog(manifest, node)
 
             catalog.resource('Class', 'Something').should_not be_nil
           end
         end
 
         it "should fail if the class doesn't exist" do
           expect { compile_to_catalog('', node) }.to raise_error(Puppet::Error, /Could not find class something/)
         end
       end
 
       describe "for classes with parameters" do
         let(:node) { Puppet::Node.new('someone', :classes => {'something' => {'configuron' => 'defrabulated'}}) }
 
         describe "when the class exists" do
           it "should fail if the class is already included" do
             manifest = <<-MANIFEST
             class something($configuron=frabulated) {}
             include something
             MANIFEST
 
             expect { compile_to_catalog(manifest, node) }.to raise_error(Puppet::Error, /Class\[Something\] is already declared/)
           end
 
           it "should evaluate the class if it's not already included" do
             manifest = <<-MANIFEST
             class something($configuron=frabulated) {}
             MANIFEST
 
             catalog = compile_to_catalog(manifest, node)
 
             resource = catalog.resource('Class', 'Something')
             resource['configuron'].should == 'defrabulated'
           end
         end
 
         it "should fail if the class doesn't exist" do
           expect { compile_to_catalog('', node) }.to raise_error(Puppet::Error, /Could not find class something/)
         end
+
+        it 'evaluates classes declared with parameters before unparameterized classes' do
+          node = Puppet::Node.new('someone', :classes => { 'app::web' => {}, 'app' => { 'port' => 8080 } })
+          manifest = <<-MANIFEST
+          class app($port = 80) { }
+
+          class app::web($port = $app::port) inherits app {
+            notify { expected: message => "$port" }
+          }
+          MANIFEST
+
+          catalog = compile_to_catalog(manifest, node)
+
+          expect(catalog).to have_resource("Class[App]").with_parameter(:port, 8080)
+          expect(catalog).to have_resource("Class[App::Web]")
+          expect(catalog).to have_resource("Notify[expected]").with_parameter(:message, "8080")
+        end
       end
     end
   end
 
   describe "when managing resource overrides" do
 
     before do
       @override = stub 'override', :ref => "File[/foo]", :type => "my"
       @resource = resource(:file, "/foo")
     end
 
     it "should be able to store overrides" do
       lambda { @compiler.add_override(@override) }.should_not raise_error
     end
 
     it "should apply overrides to the appropriate resources" do
       @compiler.add_resource(@scope, @resource)
       @resource.expects(:merge).with(@override)
 
       @compiler.add_override(@override)
 
       @compiler.compile
     end
 
     it "should accept overrides before the related resource has been created" do
       @resource.expects(:merge).with(@override)
 
       # First store the override
       @compiler.add_override(@override)
 
       # Then the resource
       @compiler.add_resource(@scope, @resource)
 
       # And compile, so they get resolved
       @compiler.compile
     end
 
     it "should fail if the compile is finished and resource overrides have not been applied" do
       @compiler.add_override(@override)
 
       lambda { @compiler.compile }.should raise_error Puppet::ParseError, 'Could not find resource(s) File[/foo] for overriding'
     end
   end
 end