puppet 4.1.0 → 5.0.0

data/spec/integration/parser/compiler_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'matchers/resource'
 
+# COPY OF UNIT TEST
 class CompilerTestResource
   attr_accessor :builtin, :virtual, :evaluated, :type, :title
 
@@ -11,7 +12,7 @@ class CompilerTestResource
   end
 
   def [](attr)
-    return nil if attr == :stage
+    return nil if (attr == :stage || attr == :alias)
     :main
   end
 
@@ -49,6 +50,10 @@ class CompilerTestResource
   def line
     "42"
   end
+
+  def resource_type
+    self.class
+  end
 end
 
 describe Puppet::Parser::Compiler do
@@ -79,435 +84,8 @@ describe Puppet::Parser::Compiler do
     @scope.resource = @scope_resource
   end
 
-  it "should fail intelligently when a class-level compile fails" do
-    Puppet::Parser::Compiler.expects(:new).raises ArgumentError
-    expect { Puppet::Parser::Compiler.compile(@node) }.to raise_error(Puppet::Error)
-  end
-
-  it "should use the node's environment as its environment" do
-    expect(@compiler.environment).to equal(@node.environment)
-  end
-
-  it "fails if the node's environment has validation errors" do
-    conflicted_environment = Puppet::Node::Environment.create(:testing, [], '/some/environment.conf/manifest.pp')
-    conflicted_environment.stubs(:validation_errors).returns(['bad environment'])
-    @node.environment = conflicted_environment
-    expect { Puppet::Parser::Compiler.compile(@node) }.to raise_error(Puppet::Error, /Compilation has been halted because.*bad environment/)
-  end
-
-  it "should include the resource type collection helper" do
-    expect(Puppet::Parser::Compiler.ancestors).to 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"
-
-    expect(@compiler.classlist.sort).to eq(%w{one two}.sort)
-  end
-
-  describe "when initializing" do
-
-    it "should set its node attribute" do
-      expect(@compiler.node).to equal(@node)
-    end
-    it "should detect when ast nodes are absent" do
-      expect(@compiler.ast_nodes?).to be_falsey
-    end
-
-    it "should detect when ast nodes are present" do
-      @known_resource_types.expects(:nodes?).returns true
-      expect(@compiler.ast_nodes?).to be_truthy
-    end
-
-    it "should copy the known_resource_types version to the catalog" do
-      expect(@compiler.catalog.version).to eq(@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)
-
-      expect(compiler.classlist).to match_array(['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)
-
-      expect(compiler.classlist).to match_array(['foo', 'bar'])
-    end
-
-    it "should add a 'main' stage to the catalog" do
-      expect(@compiler.catalog.resource(:stage, :main)).to be_instance_of(Puppet::Parser::Resource)
-    end
-  end
-
-  describe "when managing scopes" do
-
-    it "should create a top scope" do
-      expect(@compiler.topscope).to be_instance_of(Puppet::Parser::Scope)
-    end
-
-    it "should be able to create new scopes" do
-      expect(@compiler.newscope(@compiler.topscope)).to 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)
-
-      expect(newscope.parent).to 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)
-
-      expect(newscope.parent).to 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
-      expect(@compiler.topscope['a']).to eq("b")
-      expect(@compiler.topscope['c']).to eq("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
-      expect(@compiler.catalog.client_version).to eq("2")
-      expect(@compiler.catalog.server_version).to eq("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
-      expect(@known_resource_types.find_hostclass("")).to be_instance_of(Puppet::Resource::Type)
-    end
-
-    it "should add an edge between the main stage and main class" do
-      @compiler.compile
-      expect(stage = @compiler.catalog.resource(:stage, "main")).to be_instance_of(Puppet::Parser::Resource)
-      expect(klass = @compiler.catalog.resource(:class, "")).to be_instance_of(Puppet::Parser::Resource)
-
-      expect(@compiler.catalog.edge?(stage, klass)).to be_truthy
-    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)
-        expect(resource1[:noop]).to be_truthy
-      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)
-        expect(resource2[:noop]).to be_truthy
-      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)
-        expect(resource2[:noop]).to be_falsey
-      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)
-        expect(resource2.tags).to be_include("one")
-        expect(resource2.tags).to 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)
-        expect(resource2[:noop]).to be_truthy
-      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)
-
-      expect(@compiler.resources).to eq([resource1, resource2])
-    end
-
-    it "should add resources that do not conflict with existing resources" do
-      resource = resource(:file, "yay")
-      @compiler.add_resource(@scope, resource)
-
-      expect(@compiler.catalog).to 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)
-      expect { @compiler.add_resource(@scope, file2) }.to 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)
-
-      expect(@compiler.catalog).to 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)
-
-      expect(@compiler.catalog).not_to 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")
-
-      expect(@compiler.catalog.edge?(@scope.resource, stage)).to be_falsey
-    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"
-
-      expect(@compiler.catalog.edge?(other_stage, second_stage)).to be_falsey
-    end
-
-    it "should have a method for looking up resources" do
-      resource = resource(:yay, "foo")
-      @compiler.add_resource(@scope, resource)
-      expect(@compiler.findresource("Yay[foo]")).to 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)
-      expect(@compiler.findresource("Yay", "foo")).to 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
-
+  # NEW INTEGRATION TEST
   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(:unresolved_resources).returns(nil)
-
-      @compiler.add_collection(coll)
-
-      expect { @compiler.compile }.not_to 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(:unresolved_resources).returns(:something)
-
-      @compiler.add_collection(coll)
-
-      expect { @compiler.compile }.to 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(:unresolved_resources).returns([:one, :two])
-
-      @compiler.add_collection(coll)
-
-      expect { @compiler.compile }.to raise_error(Puppet::ParseError, 'Failed to realize virtual resources one, two')
-    end
-
     it 'matches on container inherited tags' do
       Puppet[:code] = <<-MANIFEST
       class xport_test {
@@ -535,364 +113,10 @@ describe Puppet::Parser::Compiler do
     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
-      expect { @compiler.evaluate_classes(%w{one two}, scope) }.to raise_error(Puppet::DevError)
-    end
-
-    it "should raise an error if a class is not found" do
-      @scope.expects(:find_hostclass).with("notfound").returns(nil)
-      expect{ @compiler.evaluate_classes(%w{notfound}, @scope) }.to 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').returns(nil)
-      expect{ @compiler.compile }.to 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").returns(@class)
-
-      @resource = stub 'resource', :ref => "Class[myclass]", :type => "file"
-    end
-
-    around do |example|
-      Puppet.override(
-        :environments => Puppet::Environments::Static.new(environment),
-        :description => "Static loader for specs"
-      ) do
-        example.run
-      end
-    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::Leaf.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| expect(@catalog.classes).to include(name) }
-      end
-
-      it "should provide default values for parameters that have no values specified" do
-        define_class('foo', {})
-        compile()
-        expect(@catalog.resource(:class, 'foo')['p1']).to eq("foo")
-      end
-
-      it "should use any provided values" do
-        define_class('foo', {'p1' => 'real_value'})
-        compile()
-        expect(@catalog.resource(:class, 'foo')['p1']).to eq("real_value")
-      end
-
-      it "should support providing some but not all values" do
-        define_class('foo', {'p1' => 'real_value'})
-        compile()
-        expect(@catalog.resource(:class, 'Foo')['p1']).to eq("real_value")
-        expect(@catalog.resource(:class, 'Foo')['p2']).to eq("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::Leaf.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' }
-        expect(r2.tags).to eq(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
-      expect { @compiler.compile }.to 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
-      expect { @compiler.compile }.to 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
-      expect(catalog.classes).to 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").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
-      expect { @compiler.send(:evaluate_ast_node) }.to 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)
-
-          expect(catalog.resource('Class', 'Something')).not_to 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)
-
-          expect(catalog.resource('Class', 'Something')).not_to 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)
-
-            expect(catalog.resource('Class', 'Something')).not_to 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)
-
-            expect(catalog.resource('Class', 'Something')).not_to 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')
-            expect(resource['configuron']).to eq('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
-
       it 'looks up default parameter values from inherited class (PUP-2532)' do
         catalog = compile_to_catalog(<<-CODE)
           class a {
@@ -914,47 +138,6 @@ describe Puppet::Parser::Compiler do
     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
-      expect { @compiler.add_override(@override) }.not_to 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)
-
-      expect { @compiler.compile }.to raise_error Puppet::ParseError, 'Could not find resource(s) File[/foo] for overriding'
-    end
-  end
-
-
   context "when converting catalog to resource" do
     it "the same environment is used for compilation as for transformation to resource form" do
         Puppet[:code] = <<-MANIFEST
@@ -970,64 +153,62 @@ describe Puppet::Parser::Compiler do
     end
   end
 
-  context 'when working with $server_facts' do
+  context 'when working with $settings name space' do
     include PuppetSpec::Compiler
-    context 'and have opted in to trusted_server_facts' do
-      before :each do
-        Puppet[:trusted_server_facts] = true
-      end
-
-      it 'should make $trusted available' do
-        node = Puppet::Node.new("testing")
-        node.add_server_facts({ "server_fact" => "foo" })
+    it 'makes $settings::strict available as string' do
+      node = Puppet::Node.new("testing")
+      catalog = compile_to_catalog(<<-MANIFEST, node)
+          notify { 'test': message => $settings::strict == 'warning' }
+      MANIFEST
+      expect(catalog).to have_resource("Notify[test]").with_parameter(:message, true)
+    end
 
-        catalog = compile_to_catalog(<<-MANIFEST, node)
-            notify { 'test': message => $server_facts[server_fact] }
-        MANIFEST
+    it 'can return boolean settings as Boolean' do
+      node = Puppet::Node.new("testing")
+      catalog = compile_to_catalog(<<-MANIFEST, node)
+          notify { 'test': message => $settings::storeconfigs == false }
+      MANIFEST
+      expect(catalog).to have_resource("Notify[test]").with_parameter(:message, true)
+    end
 
-        expect(catalog).to have_resource("Notify[test]").with_parameter(:message, "foo")
-      end
+    it 'makes all server settings available as $settings::all_local hash' do
+      node = Puppet::Node.new("testing")
+      catalog = compile_to_catalog(<<-MANIFEST, node)
+          notify { 'test': message => $settings::all_local['strict'] == 'warning' }
+      MANIFEST
+      expect(catalog).to have_resource("Notify[test]").with_parameter(:message, true)
+    end
 
-      it 'should not allow assignment to $server_facts' do
-        node = Puppet::Node.new("testing")
-        node.add_server_facts({ "server_fact" => "foo" })
+  end
 
-        expect do
-          compile_to_catalog(<<-MANIFEST, node)
-              $server_facts = 'changed'
-              notify { 'test': message => $server_facts == 'changed' }
-          MANIFEST
-        end.to raise_error(Puppet::PreformattedError, /Attempt to assign to a reserved variable name: '\$server_facts'.*/)
-      end
-    end
+  context 'when working with $server_facts' do
+    include PuppetSpec::Compiler
 
-    context 'and have not opted in to hashed_node_data' do
-      before :each do
-        Puppet[:trusted_server_facts] = false
-      end
+    it '$trusted is available' do
+      node = Puppet::Node.new("testing")
+      node.add_server_facts({ "server_fact" => "foo" })
 
-      it 'should not make $server_facts available' do
-        node = Puppet::Node.new("testing")
-        node.add_server_facts({ "server_fact" => "foo" })
+      catalog = compile_to_catalog(<<-MANIFEST, node)
+          notify { 'test': message => $server_facts[server_fact] }
+      MANIFEST
 
-        catalog = compile_to_catalog(<<-MANIFEST, node)
-            notify { 'test': message => ($server_facts == undef) }
-        MANIFEST
+      expect(catalog).to have_resource("Notify[test]").with_parameter(:message, "foo")
+    end
 
-        expect(catalog).to have_resource("Notify[test]").with_parameter(:message, true)
-      end
+    it 'does not allow assignment to $server_facts' do
+      node = Puppet::Node.new("testing")
+      node.add_server_facts({ "server_fact" => "foo" })
 
-      it 'should allow assignment to $server_facts' do
-        catalog = compile_to_catalog(<<-MANIFEST)
+      expect do
+        compile_to_catalog(<<-MANIFEST, node)
             $server_facts = 'changed'
             notify { 'test': message => $server_facts == 'changed' }
         MANIFEST
-
-        expect(catalog).to have_resource("Notify[test]").with_parameter(:message, true)
-      end
+      end.to raise_error(Puppet::PreformattedError, /Attempt to assign to a reserved variable name: '\$server_facts'.*/)
     end
   end
-  describe "the compiler when using future parser and evaluator" do
+
+  describe "the compiler when using 4.x language constructs" do
     include PuppetSpec::Compiler
 
     if Puppet.features.microsoft_windows?
@@ -1044,6 +225,37 @@ describe Puppet::Parser::Compiler do
       end
     end
 
+    it 'assigns multiple variables from a class' do
+      node = Puppet::Node.new("testnodex")
+      catalog = compile_to_catalog(<<-PP, node)
+      class foo::bar::example($x = 100)  {
+        $a = 10
+        $c = undef
+      }
+      include foo::bar::example
+
+      [$a, $x, $c] = Class['foo::bar::example']
+      notify{'check_me': message => "$a, $x, -${c}-" }
+      PP
+      expect(catalog).to have_resource("Notify[check_me]").with_parameter(:message, "10, 100, --")
+    end
+
+    it 'errors on attempt to assigns multiple variables from a class when variable does not exist' do
+      node = Puppet::Node.new("testnodex")
+      expect do
+        compile_to_catalog(<<-PP, node)
+        class foo::bar::example($x = 100)  {
+          $ah = 10
+          $c = undef
+        }
+        include foo::bar::example
+
+        [$a, $x, $c] = Class['foo::bar::example']
+        notify{'check_me': message => "$a, $x, -${c}-" }
+        PP
+      end.to raise_error(/No value for required variable '\$foo::bar::example::a'/)
+    end
+
     it "should not create duplicate resources when a class is referenced both directly and indirectly by the node classifier (4792)" do
       node = Puppet::Node.new("testnodex")
       node.classes = ['foo', 'bar']
@@ -1134,15 +346,47 @@ describe Puppet::Parser::Compiler do
       end.to raise_error(/Resource Override can only.*got: Class\[a\].*/)
     end
 
-    describe "when resolving class references" do
+    describe 'when resolving class references' do
       include Matchers::Resource
+
+      { 'string'             => 'myWay',
+        'class reference'    => 'Class["myWay"]',
+        'resource reference' => 'Resource["class", "myWay"]'
+      }.each do |label, code|
+        it "allows camel cased class name reference in 'include' using a #{label}" do
+          catalog = compile_to_catalog(<<-"PP")
+            class myWay {
+              notify { 'I did it': message => 'my way'}
+            }
+            include #{code}
+          PP
+          expect(catalog).to have_resource("Notify[I did it]")
+        end
+      end
+
+      describe 'and classname is a Resource Reference' do
+        # tested with strict == off since this was once conditional on strict
+        # can be removed in a later version.
+        before(:each) do
+          Puppet[:strict] = :off
+        end
+
+        it 'is reported as an error' do
+          expect { 
+            compile_to_catalog(<<-PP)
+              notice Class[ToothFairy]
+            PP
+          }.to raise_error(/Illegal Class name in class reference. A TypeReference\['ToothFairy'\]-Type cannot be used where a String is expected/)
+        end
+      end
+
       it "should not favor local scope (with class included in topscope)" do
         catalog = compile_to_catalog(<<-PP)
           class experiment {
             class baz {
             }
-            notify {"x" : require => Class[Baz] }
-            notify {"y" : require => Class[Experiment::Baz] }
+            notify {"x" : require => Class['baz'] }
+            notify {"y" : require => Class['experiment::baz'] }
           }
           class baz {
           }
@@ -1155,22 +399,21 @@ describe Puppet::Parser::Compiler do
         expect(catalog).to have_resource("Notify[y]").with_parameter(:require, be_resource("Class[Experiment::Baz]"))
       end
 
-      it "should not favor local scope, (with class not included in topscope)" do
-        catalog = compile_to_catalog(<<-PP)
-          class experiment {
+      it "should not favor local name scope" do
+        expect {
+          catalog = compile_to_catalog(<<-PP)
+            class experiment {
+              class baz {
+              }
+              notify {"x" : require => Class['baz'] }
+              notify {"y" : require => Class['experiment::baz'] }
+            }
             class baz {
             }
-            notify {"x" : require => Class[Baz] }
-            notify {"y" : require => Class[Experiment::Baz] }
-          }
-          class baz {
-          }
-          include experiment
-          include experiment::baz
-        PP
-
-        expect(catalog).to have_resource("Notify[x]").with_parameter(:require, be_resource("Class[Baz]"))
-        expect(catalog).to have_resource("Notify[y]").with_parameter(:require, be_resource("Class[Experiment::Baz]"))
+            include experiment
+            include experiment::baz
+          PP
+        }.to raise_error(/Could not find resource 'Class\[Baz\]' in parameter 'require'/)
       end
     end
 
@@ -1202,13 +445,15 @@ describe Puppet::Parser::Compiler do
 
     it 'should recompute the version after input files are re-parsed' do
       Puppet[:code] = 'class foo { }'
-      Time.stubs(:now).returns(1)
+      first_time = Time.at(1)
+      second_time = Time.at(200)
+      Time.stubs(:now).returns(first_time)
       node = Puppet::Node.new('mynode')
-      expect(Puppet::Parser::Compiler.compile(node).version).to eq(1)
-      Time.stubs(:now).returns(2)
-      expect(Puppet::Parser::Compiler.compile(node).version).to eq(1) # no change because files didn't change
+      expect(Puppet::Parser::Compiler.compile(node).version).to eq(first_time.to_i)
+      Time.stubs(:now).returns(second_time)
+      expect(Puppet::Parser::Compiler.compile(node).version).to eq(first_time.to_i) # no change because files didn't change
       Puppet[:code] = nil
-      expect(Puppet::Parser::Compiler.compile(node).version).to eq(2)
+      expect(Puppet::Parser::Compiler.compile(node).version).to eq(second_time.to_i)
     end
 
     ['define', 'class', 'node'].each do |thing|
@@ -1237,6 +482,46 @@ describe Puppet::Parser::Compiler do
       end
     end
 
+    describe "relationships to non existing resources (even with strict==off)" do
+      # At some point in the future, this test can be modified to simply ignore the strict flag,
+      # but since the current version is a change from being under control of strict, this is now
+      # explicit - the standard setting is strict == warning, here setting it to off
+      #
+      before(:each) do
+        Puppet[:strict] = :off
+      end
+
+      [ 'before',
+        'subscribe',
+        'notify',
+        'require'].each do |meta_param|
+        it "are reported as an error when formed via meta parameter #{meta_param}" do
+          expect { 
+            compile_to_catalog(<<-PP)
+              notify{ x : #{meta_param} => Notify[tooth_fairy] }
+            PP
+          }.to raise_error(/Could not find resource 'Notify\[tooth_fairy\]' in parameter '#{meta_param}'/)
+        end
+      end
+
+      it 'is not reported for virtual resources' do
+        expect { 
+          compile_to_catalog(<<-PP)
+            @notify{ x : require => Notify[tooth_fairy] }
+          PP
+        }.to_not raise_error
+      end
+
+      it 'is reported for a realized virtual resources' do
+        expect { 
+          compile_to_catalog(<<-PP)
+            @notify{ x : require => Notify[tooth_fairy] }
+            realize(Notify['x'])
+          PP
+        }.to raise_error(/Could not find resource 'Notify\[tooth_fairy\]' in parameter 'require'/)
+      end
+    end
+
     describe "relationships can be formed" do
       def extract_name(ref)
         ref.sub(/File\[(\w+)\]/, '\1')
@@ -1251,8 +536,8 @@ describe Puppet::Parser::Compiler do
             mode => '0755',
           }
         MANIFEST
-        catalog = compile_to_catalog(base_manifest + relationship_code)
 
+        catalog = compile_to_catalog(base_manifest + relationship_code)
         resources = catalog.resources.select { |res| res.type == 'File' }
 
         actual_relationships, actual_subscriptions = [:before, :notify].map do |relation|
@@ -1355,6 +640,34 @@ describe Puppet::Parser::Compiler do
           :relationships => [['a', 'b'], ['d', 'c']],
           :subscriptions => [['b', 'c'], ['e', 'd']])
       end
+
+      it 'should close the gap created by an intermediate empty set produced by collection' do
+        source = "file { [aa, bb]: } [File[a], File[aa]] -> Notify<| tag == 'na' |> ~> [File[b], File[bb]]"
+        assert_creates_relationships(source,
+          :relationships => [ ],
+          :subscriptions => [['a', 'b'],['aa', 'b'],['a', 'bb'], ['aa', 'bb']])
+      end
+
+      it 'should close the gap created by empty set followed by empty collection' do
+        source = "file { [aa, bb]: } [File[a], File[aa]] -> [] -> Notify<| tag == 'na' |> ~> [File[b], File[bb]]"
+        assert_creates_relationships(source,
+          :relationships => [ ],
+          :subscriptions => [['a', 'b'],['aa', 'b'],['a', 'bb'], ['aa', 'bb']])
+      end
+
+      it 'should close the gap created by empty collection surrounded by empty sets' do
+        source = "file { [aa, bb]: } [File[a], File[aa]] -> [] -> Notify<| tag == 'na' |> -> [] ~> [File[b], File[bb]]"
+        assert_creates_relationships(source,
+          :relationships => [ ],
+          :subscriptions => [['a', 'b'],['aa', 'b'],['a', 'bb'], ['aa', 'bb']])
+      end
+
+      it 'should close the gap created by several intermediate empty sets produced by collection' do
+        source = "file { [aa, bb]: } [File[a], File[aa]] -> Notify<| tag == 'na' |> -> Notify<| tag == 'na' |> ~> [File[b], File[bb]]"
+        assert_creates_relationships(source,
+          :relationships => [ ],
+          :subscriptions => [['a', 'b'],['aa', 'b'],['a', 'bb'], ['aa', 'bb']])
+      end
     end
 
     context "when dealing with variable references" do
@@ -1389,6 +702,25 @@ describe Puppet::Parser::Compiler do
       end
     end
 
+    context "when dealing with resources (e.g. File) that modifies its name from title" do
+      [['', ''],
+       ['', '/'],
+       ['/', ''],
+       ['/', '/']].each do |t, r|
+        it "a circular reference can be compiled with endings: title='#{t}' and ref='#{r}'" do
+          expect {
+            node = Puppet::Node.new("testing")
+            compile_to_catalog(<<-"MANIFEST", node)
+            file { '/tmp/bazinga.txt#{t}':
+              content => 'henrik testing',
+              require => File['/tmp/bazinga.txt#{r}']
+            }
+          MANIFEST
+          }.not_to raise_error
+        end
+      end
+    end
+
     context 'when working with the trusted data hash' do
       context 'and have opted in to hashed_node_data' do
         it 'should make $trusted available' do
@@ -1450,7 +782,7 @@ describe Puppet::Parser::Compiler do
             define foo(Integer $x) { }
             foo { 'test': x =>'say friend' }
           MANIFEST
-        end.to raise_error(/type Integer, got String/)
+        end.to raise_error(/Foo\[test\]: parameter 'x' expects an Integer value, got String/)
       end
 
       it 'denies undef for a non-optional type' do
@@ -1459,7 +791,7 @@ describe Puppet::Parser::Compiler do
             define foo(Integer $x) { }
             foo { 'test': x => undef }
           MANIFEST
-        end.to raise_error(/type Integer, got Undef/)
+        end.to raise_error(/Foo\[test\]: parameter 'x' expects an Integer value, got Undef/)
       end
 
       it 'denies non type compliant default argument' do
@@ -1468,7 +800,7 @@ describe Puppet::Parser::Compiler do
             define foo(Integer $x = 'pow') { }
             foo { 'test':  }
           MANIFEST
-        end.to raise_error(/type Integer, got String/)
+        end.to raise_error(/Foo\[test\]: parameter 'x' expects an Integer value, got String/)
       end
 
       it 'denies undef as the default for a non-optional type' do
@@ -1477,15 +809,15 @@ describe Puppet::Parser::Compiler do
             define foo(Integer $x = undef) { }
             foo { 'test':  }
           MANIFEST
-        end.to raise_error(/type Integer, got Undef/)
+        end.to raise_error(/Foo\[test\]: parameter 'x' expects an Integer value, got Undef/)
       end
 
       it 'accepts a Resource as a Type' do
         catalog = compile_to_catalog(<<-MANIFEST)
+          define bar($text) { }
           define foo(Type[Bar] $x) {
             notify { 'test': message => $x[text] }
           }
-          define bar($text) { }
           bar { 'joke': text => 'knock knock' }
           foo { 'test': x => Bar[joke] }
         MANIFEST
@@ -1498,7 +830,7 @@ describe Puppet::Parser::Compiler do
             define foo(Struct[{b => Integer, d=>String}] $a) { }
             foo{ bar: a => {b => 5, c => 'stuff'}}
           MANIFEST
-        end.to raise_error(/got Struct\[\{'b'=>Integer, 'c'=>String\}\]/)
+        end.to raise_error(/Foo\[bar\]:\s+parameter 'a' expects a value for key 'd'\s+parameter 'a' unrecognized key 'c'/m)
       end
     end
 
@@ -1536,7 +868,7 @@ describe Puppet::Parser::Compiler do
             class foo(Integer $x) { }
             class { 'foo': x =>'say friend' }
           MANIFEST
-        end.to raise_error(/type Integer, got String/)
+        end.to raise_error(/Class\[Foo\]: parameter 'x' expects an Integer value, got String/)
       end
 
       it 'denies undef for a non-optional type' do
@@ -1545,7 +877,7 @@ describe Puppet::Parser::Compiler do
             class foo(Integer $x) { }
             class { 'foo': x => undef }
           MANIFEST
-        end.to raise_error(/type Integer, got Undef/)
+        end.to raise_error(/Class\[Foo\]: parameter 'x' expects an Integer value, got Undef/)
       end
 
       it 'denies non type compliant default argument' do
@@ -1554,7 +886,7 @@ describe Puppet::Parser::Compiler do
             class foo(Integer $x = 'pow') { }
             class { 'foo':  }
           MANIFEST
-        end.to raise_error(/type Integer, got String/)
+        end.to raise_error(/Class\[Foo\]: parameter 'x' expects an Integer value, got String/)
       end
 
       it 'denies undef as the default for a non-optional type' do
@@ -1563,15 +895,15 @@ describe Puppet::Parser::Compiler do
             class foo(Integer $x = undef) { }
             class { 'foo':  }
           MANIFEST
-        end.to raise_error(/type Integer, got Undef/)
+        end.to raise_error(/Class\[Foo\]: parameter 'x' expects an Integer value, got Undef/)
       end
 
       it 'accepts a Resource as a Type' do
         catalog = compile_to_catalog(<<-MANIFEST)
+          define bar($text) { }
           class foo(Type[Bar] $x) {
             notify { 'test': message => $x[text] }
           }
-          define bar($text) { }
           bar { 'joke': text => 'knock knock' }
           class { 'foo': x => Bar[joke] }
         MANIFEST
@@ -1594,17 +926,12 @@ describe Puppet::Parser::Compiler do
         expect(catalog).to have_resource("Notify[value second]")
       end
 
-      # Conditinoally left out for Ruby 1.8.x since the Proc created for the expected number of arguments will accept
-      # a call with fewer arguments and then pass all arguments to the closure. The closure then receives an argument
-      # array of correct size with nil values instead of an array with too few arguments
-      unless RUBY_VERSION[0,3] == '1.8'
-        it 'denies when missing required arguments' do
-          expect do
-            compile_to_catalog(<<-MANIFEST)
-              with(1) |$x, $y| { }
-            MANIFEST
-          end.to raise_error(/Parameter \$y is required but no value was given/m)
-        end
+      it 'denies when missing required arguments' do
+        expect do
+          compile_to_catalog(<<-MANIFEST)
+            with(1) |$x, $y| { }
+          MANIFEST
+        end.to raise_error(/Parameter \$y is required but no value was given/m)
       end
 
       it 'accepts anything when parameters are untyped' do
@@ -1630,7 +957,7 @@ describe Puppet::Parser::Compiler do
           compile_to_catalog(<<-MANIFEST)
             with(1) |String $x| { }
           MANIFEST
-        end.to raise_error(/expected.*String.*actual.*Integer/m)
+        end.to raise_error(/block parameter 'x' expects a String value, got Integer/m)
       end
 
       it 'denies non-type-compliant, slurped arguments' do
@@ -1638,7 +965,7 @@ describe Puppet::Parser::Compiler do
           compile_to_catalog(<<-MANIFEST)
             with(1, "hello") |Integer *$x| { }
           MANIFEST
-        end.to raise_error(/called with mis-matched arguments.*expected.*Integer.*actual.*Integer, String/m)
+        end.to raise_error(/block parameter 'x' expects an Integer value, got String/m)
       end
 
       it 'denies non-type-compliant default argument' do
@@ -1646,7 +973,7 @@ describe Puppet::Parser::Compiler do
           compile_to_catalog(<<-MANIFEST)
             with(1) |$x, String $defaulted = 1| { notify { "${$x + $defaulted}": }}
           MANIFEST
-        end.to raise_error(/expected.*Any.*String.*actual.*Integer.*Integer/m)
+        end.to raise_error(/block parameter 'defaulted' expects a String value, got Integer/m)
       end
 
       it 'raises an error when a default argument value is an incorrect type and there are no arguments passed' do
@@ -1654,7 +981,7 @@ describe Puppet::Parser::Compiler do
           compile_to_catalog(<<-MANIFEST)
             with() |String $defaulted = 1| {}
           MANIFEST
-        end.to raise_error(/expected.*String.*actual.*Integer/m)
+        end.to raise_error(/block parameter 'defaulted' expects a String value, got Integer/m)
       end
 
       it 'raises an error when the default argument for a slurped parameter is an incorrect type' do
@@ -1662,7 +989,7 @@ describe Puppet::Parser::Compiler do
           compile_to_catalog(<<-MANIFEST)
             with() |String *$defaulted = 1| {}
           MANIFEST
-        end.to raise_error(/expected.*String.*actual.*Integer/m)
+        end.to raise_error(/block parameter 'defaulted' expects a String value, got Integer/m)
       end
 
       it 'allows using an array as the default slurped value' do
@@ -1694,7 +1021,7 @@ describe Puppet::Parser::Compiler do
           compile_to_catalog(<<-MANIFEST)
             with() |Array[String, 2] *$defaulted = hi| { }
           MANIFEST
-        end.to raise_error(/expected.*arg count \{2,\}.*actual.*arg count \{1\}/m)
+        end.to raise_error(/block expects at least 2 arguments, got 1/m)
       end
 
       it 'raises an error when the number of passed values does not match the parameter\'s size specification' do
@@ -1702,7 +1029,7 @@ describe Puppet::Parser::Compiler do
           compile_to_catalog(<<-MANIFEST)
             with(hi) |Array[String, 2] *$passed| { }
           MANIFEST
-        end.to raise_error(/expected.*arg count \{2,\}.*actual.*arg count \{1\}/m)
+        end.to raise_error(/block expects at least 2 arguments, got 1/m)
       end
 
       it 'matches when the number of arguments passed for a slurp parameter match the size specification' do
@@ -1721,7 +1048,7 @@ describe Puppet::Parser::Compiler do
           compile_to_catalog(<<-MANIFEST)
             with(hi, bye) |Array[String, 1, 1] *$passed| { }
           MANIFEST
-        end.to raise_error(/expected.*arg count \{1\}.*actual.*arg count \{2\}/m)
+        end.to raise_error(/block expects 1 argument, got 2/m)
       end
 
       it 'allows passing slurped arrays by specifying an array of arrays' do
@@ -1774,4 +1101,80 @@ describe Puppet::Parser::Compiler do
     end
   end
 
+  describe "the compiler when handling aliases" do
+    include PuppetSpec::Compiler
+
+    def extract_name(ref)
+      ref.sub(/.*\[(\w+)\]/, '\1')
+    end
+
+    def assert_created_relationships(catalog, type_name, expectations)
+      resources = catalog.resources.select { |res| res.type == type_name }
+
+      actual_relationships, actual_subscriptions = [:before, :notify].map do |relation|
+        resources.map do |res|
+          dependents = Array(res[relation])
+          dependents.map { |ref| [res.title, extract_name(ref)] }
+        end.inject(&:concat)
+      end
+
+      expect(actual_relationships).to match_array(expectations[:relationships] || [])
+      expect(actual_subscriptions).to match_array(expectations[:subscriptions] || [])
+    end
+
+    it 'allows a relationship to be formed using metaparam relationship' do
+      node = Puppet::Node.new("testnodex")
+      catalog = compile_to_catalog(<<-PP, node)
+        notify { 'actual_2':  before => 'Notify[alias_1]' }
+        notify { 'actual_1': alias => 'alias_1' }
+      PP
+      assert_created_relationships(catalog, 'Notify', { :relationships => [['actual_2', 'alias_1']] })
+    end
+
+    it 'allows a relationship to be formed using -> operator and alias' do
+      node = Puppet::Node.new("testnodex")
+      catalog = compile_to_catalog(<<-PP, node)
+        notify { 'actual_2':  }
+        notify { 'actual_1': alias => 'alias_1' }
+        Notify[actual_2] -> Notify[alias_1]
+      PP
+      assert_created_relationships(catalog, 'Notify', { :relationships => [['actual_2', 'alias_1']] })
+    end
+
+    it 'errors when an alias cannot be found when relationship is formed with -> operator' do
+      node = Puppet::Node.new("testnodex")
+      expect {
+        catalog = compile_to_catalog(<<-PP, node)
+          notify { 'actual_2':  }
+          notify { 'actual_1': alias => 'alias_1' }
+          Notify[actual_2] -> Notify[alias_2]
+        PP
+      }.to raise_error(/Could not find resource 'Notify\[alias_2\]'/)
+    end
+  end
+
+  describe 'the compiler when using collection and override' do
+    include PuppetSpec::Compiler
+
+    it 'allows an override when there is a default present' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        Package { require => Class['bar'] }
+        class bar { }
+        class foo {
+          package { 'python': }
+          package { 'pip': require => Package['python'] }
+
+          Package <| title == 'pip' |> {
+            name     => "python-pip",
+            category => undef,
+          }
+        }
+        include foo
+        include bar
+      MANIFEST
+      package = catalog.resource('Package', 'pip')
+      expect(catalog.resource('Package', 'pip')[:require].to_s).to eql('Package[python]')
+    end
+
+  end
 end