puppet 4.10.12-x86-mingw32 → 5.0.0-x86-mingw32

data/spec/fixtures/unit/functions/lookup_fixture/environments/production/modules/abc/metadata.json

@@ -0,0 +1,9 @@
+{
+    "name": "example/abc",
+    "version": "0.0.2",
+    "source": "git@github.com/example/example-abc.git",
+    "dependencies": [],
+    "author": "Bob the Builder",
+    "license": "Apache-2.0",
+    "data_provider": "function"
+}

data/spec/fixtures/unit/functions/lookup_fixture/environments/production/modules/bad_data/metadata.json

@@ -0,0 +1,9 @@
+{
+    "name": "example/bad_data",
+    "version": "0.0.2",
+    "source": "git@github.com/example/example-bad_data.git",
+    "dependencies": [],
+    "author": "Bob the Builder",
+    "license": "Apache-2.0",
+    "data_provider": "function"
+}

data/spec/fixtures/unit/functions/lookup_fixture/environments/production/modules/bca/metadata.json

@@ -0,0 +1,9 @@
+{
+    "name": "example/bca",
+    "version": "0.0.2",
+    "source": "git@github.com/example/example-bca.git",
+    "dependencies": [],
+    "author": "Bob the Builder",
+    "license": "Apache-2.0",
+    "data_provider": "function"
+}

data/spec/integration/agent/logging_spec.rb

@@ -71,8 +71,6 @@ describe 'agent logging' do
     before(:each) do
       # Don't actually run the agent, bypassing cert checks, forking and the puppet run itself
       Puppet::Application::Agent.any_instance.stubs(:run_command)
-      # Let exceptions be raised instead of exiting
-      Puppet::Application::Agent.any_instance.stubs(:exit_on_fail).yields
     end
 
     def double_of_bin_puppet_agent_call(argv)

data/spec/integration/application/apply_spec.rb

@@ -10,13 +10,13 @@ describe "apply" do
   end
 
   describe "when applying provided catalogs" do
-    it "can apply catalogs provided in a file in pson" do
-      file_to_create = tmpfile("pson_catalog")
+    it "can apply catalogs provided in a file in json" do
+      file_to_create = tmpfile("json_catalog")
       catalog = Puppet::Resource::Catalog.new('mine', Puppet.lookup(:environments).get(Puppet[:environment]))
       resource = Puppet::Resource.new(:file, file_to_create, :parameters => {:content => "my stuff"})
       catalog.add_resource resource
 
-      manifest = file_containing("manifest", catalog.to_pson)
+      manifest = file_containing("manifest", catalog.to_json)
 
       puppet = Puppet::Application[:apply]
       puppet.options[:catalog] = manifest
@@ -94,7 +94,7 @@ end
       it 'does not load the pcore type' do
         catalog = compile_to_catalog('applytest { "applytest was here":}', node)
         apply = Puppet::Application[:apply]
-        apply.options[:catalog] = file_containing('manifest', catalog.to_pson)
+        apply.options[:catalog] = file_containing('manifest', catalog.to_json)
 
         Puppet[:environmentpath] = envdir
         Puppet::Pops::Loader::Runtime3TypeLoader.any_instance.expects(:find).never
@@ -220,12 +220,11 @@ end
     end
 
     it 'can apply the catalog' do
-      pending('awaits PUP-7423') # test no longer functional when Object types are serialized by reference
       catalog = compile_to_catalog('include mod', node)
 
       Puppet[:environment] = env_name
       apply = Puppet::Application[:apply]
-      apply.options[:catalog] = file_containing('manifest', catalog.to_pson)
+      apply.options[:catalog] = file_containing('manifest', catalog.to_json)
       expect { apply.run_command; exit(0) }.to exit_with(0)
       expect(@logs.map(&:to_s)).to include('The Street 23')
     end
@@ -245,9 +244,8 @@ end
     expect(@logs.map(&:to_s)).to include('it was applied')
   end
 
-  it "adds environment to the $server_facts variable if trusted_server_facts is true" do
+  it "adds environment to the $server_facts variable" do
     manifest = file_containing("manifest.pp", "notice(\"$server_facts\")")
-    Puppet[:trusted_server_facts] = true
 
     puppet = Puppet::Application[:apply]
     puppet.stubs(:command_line).returns(stub('command_line', :args => [manifest]))
@@ -471,7 +469,7 @@ class amod::bad_type {
       it 'will notify a string that is the result of Regexp#inspect (from Runtime3xConverter)' do
         catalog = compile_to_catalog(execute, node)
         apply = Puppet::Application[:apply]
-        apply.options[:catalog] = file_containing('manifest', catalog.to_pson)
+        apply.options[:catalog] = file_containing('manifest', catalog.to_json)
         apply.expects(:apply_catalog).with do |catalog|
           catalog.resource(:notify, 'rx')['message'].is_a?(String)
           catalog.resource(:notify, 'bin')['message'].is_a?(String)
@@ -484,14 +482,7 @@ class amod::bad_type {
       end
 
       it 'will notify a string that is the result of to_s on uknown data types' do
-        logs = []
-        json = Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
-           compile_to_catalog('include amod::bad_type', node).to_pson
-        end
-        logs = logs.select { |log| log.level == :warning }.map { |log| log.message }
-        expect(logs.empty?).to be_falsey
-        expect(logs[0]).to eql("Resource 'Notify[bogus]' contains a Time value. It will be converted to the String '2016-10-06 23:51:14 +0200'")
-
+        json = compile_to_catalog('include amod::bad_type', node).to_json
         apply = Puppet::Application[:apply]
         apply.options[:catalog] = file_containing('manifest', json)
         apply.expects(:apply_catalog).with do |catalog|
@@ -499,6 +490,16 @@ class amod::bad_type {
         end
         apply.run
       end
+
+      it 'will log a warning that a value of unknown type is converted into a string' do
+        logs = []
+        json = Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+          compile_to_catalog('include amod::bad_type', node).to_json
+        end
+        logs = logs.select { |log| log.level == :warning }.map { |log| log.message }
+        expect(logs.empty?).to be_falsey
+        expect(logs[0]).to eql("Notify[bogus]['message'] contains a Time value. It will be converted to the String '2016-10-06 23:51:14 +0200'")
+      end
     end
 
     context 'and rich_data is set to true during compile' do
@@ -507,7 +508,7 @@ class amod::bad_type {
       it 'will notify a regexp using Regexp#to_s' do
         catalog = compile_to_catalog(execute, node)
         apply = Puppet::Application[:apply]
-        apply.options[:catalog] = file_containing('manifest', catalog.to_pson)
+        apply.options[:catalog] = file_containing('manifest', catalog.to_json)
         apply.expects(:apply_catalog).with do |catalog|
           catalog.resource(:notify, 'rx')['message'].is_a?(Regexp)
           catalog.resource(:notify, 'bin')['message'].is_a?(Puppet::Pops::Types::PBinaryType::Binary)
@@ -518,11 +519,6 @@ class amod::bad_type {
         end
         apply.run
       end
-
-      it 'will raise an error on uknown data types' do
-        catalog = compile_to_catalog('include amod::bad_type', node)
-        expect { catalog.to_pson }.to raise_error(/No Puppet Type found for Time/)
-      end
     end
 
   end

data/spec/integration/application/lookup_spec.rb

@@ -90,27 +90,6 @@ describe 'lookup' do
       expect(lookup('a')).to eql('value a')
     end
 
-    context 'uses node_terminus' do
-      require 'puppet/indirector/node/exec'
-      require 'puppet/indirector/node/plain'
-
-      let(:node) { Puppet::Node.new('testnode', :environment => env) }
-
-      it ':plain without --compile' do
-        Puppet.settings[:node_terminus] = 'exec'
-        Puppet::Node::Plain.any_instance.expects(:find).returns(node)
-        Puppet::Node::Exec.any_instance.expects(:find).never
-        expect(lookup('a')).to eql('value a')
-      end
-
-      it 'configured in Puppet settings with --compile' do
-        Puppet.settings[:node_terminus] = 'exec'
-        Puppet::Node::Plain.any_instance.expects(:find).never
-        Puppet::Node::Exec.any_instance.expects(:find).returns(node)
-        expect(lookup('a', :compile => true)).to eql('value a')
-      end
-    end
-
     context 'configured with the wrong environment' do
       let(:env) { Puppet::Node::Environment.create(env_name.to_sym, [File.join(populated_env_dir, env_name, 'modules')]) }
       it 'does not find data in non-existing environment' do

data/spec/integration/configurer_spec.rb

@@ -32,7 +32,7 @@ describe Puppet::Configurer do
     end
 
     it "should save a correct last run summary" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       Puppet::Transaction::Report.indirection.stubs(:save)
 
       Puppet[:lastrunfile] = tmpfile("lastrunfile")

data/spec/integration/defaults_spec.rb

@@ -137,8 +137,8 @@ describe "Puppet defaults" do
     end
   end
 
-  it "should default to pson for the preferred serialization format" do
-    expect(Puppet.settings.value(:preferred_serialization_format)).to eq("pson")
+  it "should default to json for the preferred serialization format" do
+    expect(Puppet.settings.value(:preferred_serialization_format)).to eq("json")
   end
 
   it "should have a setting for determining the configuration version and should default to an empty string" do

data/spec/integration/file_bucket/file_spec.rb

@@ -43,27 +43,12 @@ describe Puppet::FileBucket::File do
   end
 
   describe "saving binary files" do
-    context "given multiple backups of identical files" do
-      it "does not error given content with binary external encoding" do
-        binary = "\xD1\xF2\r\n\x81NuSc\x00".force_encoding(Encoding::ASCII_8BIT)
-        bucket_file = Puppet::FileBucket::File.new(binary)
-        Puppet::FileBucket::File.indirection.save(bucket_file, bucket_file.name)
-        Puppet::FileBucket::File.indirection.save(bucket_file, bucket_file.name)
-      end
+    let(:binary) { "\xD1\xF2\r\n\x81NuSc\x00".force_encoding(Encoding::ASCII_8BIT) }
 
-      it "also does not error if the content is reported with UTF-8 external encoding" do
-        # PUP-7951 - ensure accurate size comparison across encodings If binary
-        # content arrives as a string with UTF-8 default external encoding, its
-        # character count might be different than the same bytes with binary
-        # external encoding. Ensure our equality comparison does not fail due to this.
-        # As would be the case with our friend snowman:
-        # Unicode snowman \u2603 - \xE2 \x98 \x83
-        # character size 1, if interpreted as UTF-8, 3 "characters" if interpreted as binary
-        utf8 = "\u2603".force_encoding(Encoding::UTF_8)
-        bucket_file = Puppet::FileBucket::File.new(utf8)
-        Puppet::FileBucket::File.indirection.save(bucket_file, bucket_file.name)
-        Puppet::FileBucket::File.indirection.save(bucket_file, bucket_file.name)
-      end
+    it "does not error when the same contents are saved twice" do
+      bucket_file = Puppet::FileBucket::File.new(binary)
+      Puppet::FileBucket::File.indirection.save(bucket_file, bucket_file.name)
+      Puppet::FileBucket::File.indirection.save(bucket_file, bucket_file.name)
     end
   end
 end

data/spec/integration/indirector/file_content/file_server_spec.rb

@@ -70,6 +70,7 @@ describe Puppet::Indirector::FileContent::FileServer, " when finding files" do
 
     # Use a real mount, so the integration is a bit deeper.
     mount1 = Puppet::FileServing::Configuration::Mount::File.new("one")
+    mount1.stubs(:globalallow?).returns true
     mount1.stubs(:allowed?).returns true
     mount1.path = File.join(path, "%h")
 

data/spec/integration/indirector/file_metadata/file_server_spec.rb

@@ -50,6 +50,7 @@ describe Puppet::Indirector::FileMetadata::FileServer, " when finding files" do
 
         # Use a real mount, so the integration is a bit deeper.
         mount1 = Puppet::FileServing::Configuration::Mount::File.new("one")
+        mount1.stubs(:globalallow?).returns true
         mount1.stubs(:allowed?).returns true
         mount1.path = File.join(env_path, "%h")
 

data/spec/integration/parser/catalog_spec.rb

@@ -96,7 +96,7 @@ describe "A catalog" do
   def master_and_agent_catalogs_for(manifest)
     compiler = Puppet::Resource::Catalog::Compiler.new
     master_catalog = compiler.filter(compile_to_catalog(manifest, node))
-    agent_catalog = Puppet::Resource::Catalog.convert_from(:pson, master_catalog.render(:pson))
+    agent_catalog = Puppet::Resource::Catalog.convert_from(:json, master_catalog.render(:json))
     [master_catalog, agent_catalog]
   end
 

data/spec/integration/parser/class_spec.rb

@@ -5,15 +5,15 @@ describe "Class expressions" do
   extend PuppetSpec::Language
 
   produces(
-    "class hi { }"                                       => '!defined(Class[Hi])',
+    "class hi { }"                                       => '!defined(Class[hi])',
 
-    "class hi { } include hi"                            => 'defined(Class[Hi])',
-    "include(hi) class hi { }"                           => 'defined(Class[Hi])',
+    "class hi { } include hi"                            => 'defined(Class[hi])',
+    "include(hi) class hi { }"                           => 'defined(Class[hi])',
 
-    "class hi { } class { hi: }"                         => 'defined(Class[Hi])',
-    "class { hi: } class hi { }"                         => 'defined(Class[Hi])',
+    "class hi { } class { hi: }"                         => 'defined(Class[hi])',
+    "class { hi: } class hi { }"                         => 'defined(Class[hi])',
 
-    "class bye { } class hi inherits bye { } include hi" => 'defined(Class[Hi]) and defined(Class[Bye])')
+    "class bye { } class hi inherits bye { } include hi" => 'defined(Class[hi]) and defined(Class[bye])')
 
   produces(<<-EXAMPLE => 'defined(Notify[foo]) and defined(Notify[bar]) and !defined(Notify[foo::bar])')
     class bar { notify { 'bar': } }

data/spec/integration/parser/compiler_spec.rb

@@ -12,7 +12,7 @@ class CompilerTestResource
   end
 
   def [](attr)
-    return nil if attr == :stage
+    return nil if (attr == :stage || attr == :alias)
     :main
   end
 
@@ -170,74 +170,44 @@ describe Puppet::Parser::Compiler do
       MANIFEST
       expect(catalog).to have_resource("Notify[test]").with_parameter(:message, true)
     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
+
   end
 
   context 'when working with $server_facts' 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" })
-
-        catalog = compile_to_catalog(<<-MANIFEST, node)
-            notify { 'test': message => $server_facts[server_fact] }
-        MANIFEST
 
-        expect(catalog).to have_resource("Notify[test]").with_parameter(:message, "foo")
-      end
+    it '$trusted is available' do
+      node = Puppet::Node.new("testing")
+      node.add_server_facts({ "server_fact" => "foo" })
 
-      it 'should not allow assignment to $server_facts' 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
 
-        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
+      expect(catalog).to have_resource("Notify[test]").with_parameter(:message, "foo")
     end
 
-    context 'and have not opted in to hashed_node_data' do
-      before :each do
-        Puppet[:trusted_server_facts] = false
-      end
-
-      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 == undef) }
-        MANIFEST
-
-        expect(catalog).to have_resource("Notify[test]").with_parameter(:message, true)
-      end
-
-      it 'should allow assignment to $server_facts' do
-        catalog = compile_to_catalog(<<-MANIFEST)
-            $server_facts = 'changed'
-            notify { 'test': message => $server_facts == 'changed' }
-        MANIFEST
+    it 'does not allow assignment to $server_facts' do
+      node = Puppet::Node.new("testing")
+      node.add_server_facts({ "server_fact" => "foo" })
 
-        expect(catalog).to have_resource("Notify[test]").with_parameter(:message, true)
-      end
-      it 'should warn about 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(@logs).to have_matching_log(/Assignment to \$server_facts is deprecated/)
-
-        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 4.x language constructs" do
     include PuppetSpec::Compiler
 
@@ -394,9 +364,11 @@ describe Puppet::Parser::Compiler do
         end
       end
 
-      describe 'and classname is a Resource Reference and strict == :error' do
+      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] = :error
+          Puppet[:strict] = :off
         end
 
         it 'is reported as an error' do
@@ -408,38 +380,6 @@ describe Puppet::Parser::Compiler do
         end
       end
 
-      describe 'and classname is a Resource Reference and strict == :warning' do
-        before(:each) do
-          Puppet[:strict] = :warning
-        end
-
-        it 'is reported as a deprecation warning' do
-          expect { 
-            compile_to_catalog(<<-PP)
-              notice Class[ToothFairy]
-            PP
-            expect(@logs).to have_matching_log(/Upper cased class-name in a Class\[<class-name>\] is deprecated, class-name should be a lowercase string/)
-
-          }.to_not raise_error()
-        end
-      end
-
-      describe 'and classname is a Resource Reference and strict == :off' do
-        before(:each) do
-          Puppet[:strict] = :off
-        end
-
-        it 'is not reported' do
-          expect { 
-            compile_to_catalog(<<-PP)
-              notice Class[ToothFairy]
-            PP
-            expect(@logs).to_not have_matching_log(/Warning: Upper cased class-name in a Class\[<class-name>\] is deprecated, class-name should be a lowercase string/)
-
-          }.to_not raise_error()
-        end
-      end
-
       it "should not favor local scope (with class included in topscope)" do
         catalog = compile_to_catalog(<<-PP)
           class experiment {
@@ -459,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
 
@@ -543,9 +482,13 @@ describe Puppet::Parser::Compiler do
       end
     end
 
-    describe "relationships to non existing resources when strict == :error" do
+    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] = :error
+        Puppet[:strict] = :off
       end
 
       [ 'before',
@@ -560,46 +503,22 @@ describe Puppet::Parser::Compiler do
           }.to raise_error(/Could not find resource 'Notify\[tooth_fairy\]' in parameter '#{meta_param}'/)
         end
       end
-    end
 
-    describe "relationships to non existing resources when strict == :warning" do
-      before(:each) do
-        Puppet[:strict] = :warning
-      end
-
-      [ 'before',
-        'subscribe',
-        'notify',
-        'require'].each do |meta_param|
-        it "are reported as a warning when formed via meta parameter #{meta_param}" do
-          expect { 
-            compile_to_catalog(<<-PP)
-              notify{ x : #{meta_param} => Notify[tooth_fairy] }
-            PP
-            expect(@logs).to have_matching_log(/Could not find resource 'Notify\[tooth_fairy\]' in parameter '#{meta_param}'/)
-
-          }.to_not raise_error()
-        end
-      end
-    end
-
-    describe "relationships to non existing resources when strict == :off" do
-      before(:each) do
-        Puppet[:strict] = :off
+      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
 
-      [ 'before',
-        'subscribe',
-        'notify',
-        'require'].each do |meta_param|
-        it "does not log an error for meta parameter #{meta_param}" do
-          expect { 
-            compile_to_catalog(<<-PP)
-              notify{ x : #{meta_param} => Notify[tooth_fairy] }
-            PP
-            expect(@logs).to_not have_matching_log(/Could not find resource 'Notify\[tooth_fairy\]' in parameter '#{meta_param}'/)
-          }.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
 
@@ -617,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|
@@ -721,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
@@ -755,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
@@ -1135,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