puppet 3.5.1-x86-mingw32 → 3.6.0.rc1-x86-mingw32

data/lib/puppet/version.rb

@@ -7,7 +7,7 @@
 
 
 module Puppet
-  PUPPETVERSION = '3.5.1'
+  PUPPETVERSION = '3.6.0-rc1'
 
   ##
   # version is a public API method intended to always provide a fast and

data/spec/fixtures/unit/pops/loaders/loaders/dependent_modules_with_metadata/usee/lib/puppet/functions/usee/callee.rb

@@ -0,0 +1,5 @@
+Puppet::Functions.create_function(:'usee::callee') do
+  def callee(value)
+    "usee::callee() was told '#{value}'"
+  end
+end

data/spec/fixtures/unit/pops/loaders/loaders/dependent_modules_with_metadata/user/lib/puppet/functions/user/caller.rb

@@ -0,0 +1,5 @@
+Puppet::Functions.create_function(:'user::caller') do
+  def caller()
+    call_function('usee::callee', 'passed value') + " + I am user::caller()"
+  end
+end

data/spec/fixtures/unit/pops/loaders/loaders/dependent_modules_with_metadata/user/metadata.json

@@ -0,0 +1,9 @@
+{
+  "name": "test-user",
+  "author": "test",
+  "description": "",
+  "license": "",
+  "source": "",
+  "version": "1.0.0",
+  "dependencies": [{ "name": "test/usee" }]
+}

data/spec/fixtures/unit/pops/loaders/loaders/single_module/modules/modulea/lib/puppet/functions/modulea/rb_func_a.rb

@@ -0,0 +1,5 @@
+Puppet::Functions.create_function(:'modulea::rb_func_a') do
+  def rb_func_a()
+    "I am modulea::rb_func_a()"
+  end
+end

data/spec/fixtures/unit/pops/loaders/loaders/single_module/modules/modulea/lib/puppet/functions/rb_func_a.rb

@@ -0,0 +1,5 @@
+Puppet::Functions.create_function(:rb_func_a) do
+  def rb_func_a()
+    "I am rb_func_a()"
+  end
+end

data/spec/fixtures/unit/pops/loaders/loaders/single_module/modules/modulea/manifests/init.pp

@@ -0,0 +1,3 @@
+class modulea {
+
+}

data/spec/fixtures/unit/pops/loaders/loaders/single_module/modules/modulea/metadata.json

@@ -0,0 +1,19 @@
+{
+  "name": "test-modulea",
+  "author": "test",
+  "description": "",
+  "license": "",
+  "project_page": "",
+  "source": "",
+  "summary": "",
+  "version": "1.0.0",
+  "checksums": {
+    "Modulefile": "55ef13d250cf6c477561becd8f2edcbe",
+    "functions/func_a.pp": "4a1f48920cd37c487dbf7468a5e78364",
+    "functions/modulea/func_a.pp": "296a3330c602b919ae063d6d6fde2460",
+    "lib/puppet/functions/modulea/rb_func_a.rb": "d5b3b83f77b742292008cd06361d6673",
+    "lib/puppet/functions/rb_func_a.rb": "a255470197127a6e512c9ab9dbd914c1",
+    "manifests/init.pp": "e50d8b91b632fb8357f021e6e0b6e043"
+  },
+  "dependencies": []
+}

data/spec/fixtures/unit/pops/loaders/loaders/wo_metadata_module/modules/moduleb/lib/puppet/functions/moduleb/rb_func_b.rb

@@ -0,0 +1,6 @@
+Puppet::Functions.create_function(:'moduleb::rb_func_b') do
+  def rb_func_b()
+    # Should be able to call modulea::rb_func_a()
+    call_function('modulea::rb_func_a') + " + I am moduleb::rb_func_b()"
+  end
+end

data/spec/fixtures/unit/pops/loaders/loaders/wo_metadata_module/modules/moduleb/manifests/init.pp

@@ -0,0 +1,3 @@
+class moduleb {
+
+}

data/spec/fixtures/unit/provider/naginator/define_empty_param

@@ -0,0 +1,6 @@
+# fixture for the spec test for PUP-1041
+
+define host {
+  parents
+  use       linux-server
+}

data/spec/fixtures/unit/provider/service/systemd/list_unit_files_services

@@ -0,0 +1,7 @@
+UNIT FILE                                   STATE
+arp-ethers.service                          disabled
+auditd.service                              enabled
+autovt@.service                             disabled
+avahi-daemon.service                        enabled
+blk-availability.service                    disabled
+brandbot.service                            static

data/spec/fixtures/unit/type/user/authorized_keys

@@ -0,0 +1,5 @@
+# fixture for testing ssh key purging
+
+ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDTXvM7AslzjNUYrPLiNVBsF5VnqL2RmqrkzscdVdHzVxvieNwmLGeUkg8EfXPiz7j5F/Lr0J8oItTCWzyN2KmM+DhUMjvP4AbELO/VYbnVrZICRiUNYSO3EN9/uapKAuiev88d7ynbonCU0VZoTPg/ug4OondOrLCtcGri5ltF+mausGfAYiFAQVEWqXV+1tyejoawJ884etb3n4ilpsrH9JK6AtOkEWVD3TDrNi29O1mQQ/Cn88g472zAJ+DhsIn+iehtfX5nmOtDNN/1t1bGMIBzkSYEAYwUiRJbRXvbobT7qKZQPA3dh0m8AYQS5/hd4/c4pmlxL8kgr24SnBY5 key1 keyname1
+ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDTXvM7AslzjNUYrPLiNVBsF5VnqL2RmqrkzscdVdHzVxvieNwmLGeUkg8EfXPiz7j5F/Lr0J8oItTCWzyN2KmM+DhUMjvP4AbELO/VYbnVrZICRiUNYSO3EN9/uapKAuiev88d7ynbonCU0VZoTPg/ug4OondOrLCtcGri5ltF+mausGfAYiFAQVEWqXV+1tyejoawJ884etb3n4ilpsrH9JK6AtOkEWVD3TDrNi29O1mQQ/Cn88g472zAJ+DhsIn+iehtfX5nmOtDNN/1t1bGMIBzkSYEAYwUiRJbRXvbobT7qKZQPA3dh0m8AYQS5/hd4/c4pmlxL8kgr24SnBY5 keyname2
+#ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDTXvM7AslzjNUYrPLiNVBsF5VnqL2RmqrkzscdVdHzVxvieNwmLGeUkg8EfXPiz7j5F/Lr0J8oItTCWzyN2KmM+DhUMjvP4AbELO/VYbnVrZICRiUNYSO3EN9/uapKAuiev88d7ynbonCU0VZoTPg/ug4OondOrLCtcGri5ltF+mausGfAYiFAQVEWqXV+1tyejoawJ884etb3n4ilpsrH9JK6AtOkEWVD3TDrNi29O1mQQ/Cn88g472zAJ+DhsIn+iehtfX5nmOtDNN/1t1bGMIBzkSYEAYwUiRJbRXvbobT7qKZQPA3dh0m8AYQS5/hd4/c4pmlxL8kgr24SnBY5 keyname3

data/spec/integration/application/apply_spec.rb

@@ -13,14 +13,13 @@ describe "apply" do
   describe "when applying provided catalogs" do
     it "can apply catalogs provided in a file in pson" do
       file_to_create = tmpfile("pson_catalog")
-      catalog = Puppet::Resource::Catalog.new
+      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 = tmpfile("manifest")
 
       File.open(manifest, "w") { |f| f.print catalog.to_pson }
-
       puppet = Puppet::Application[:apply]
       puppet.options[:catalog] = manifest
 

data/spec/integration/configurer_spec.rb

@@ -16,13 +16,13 @@ describe Puppet::Configurer do
 
       configurer = Puppet::Configurer.new
       configurer.stubs(:download_plugins?).returns true
-      configurer.download_plugins
+      configurer.download_plugins(Puppet::Node::Environment.remote(:testing))
     end
   end
 
   describe "when running" do
     before(:each) do
-      @catalog = Puppet::Resource::Catalog.new
+      @catalog = Puppet::Resource::Catalog.new("testing", Puppet.lookup(:environments).get(Puppet[:environment]))
       @catalog.add_resource(Puppet::Type.type(:notify).new(:title => "testing"))
 
       # Make sure we don't try to persist the local state after the transaction ran,

data/spec/integration/faces/plugin_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'puppet/face'
+require 'puppet/file_serving/metadata'
+require 'puppet/file_serving/content'
+require 'puppet/indirector/memory'
+
+module PuppetFaceIntegrationSpecs
+describe "Puppet plugin face" do
+  INDIRECTORS = [
+    Puppet::Indirector::FileMetadata,
+    Puppet::Indirector::FileContent,
+  ]
+
+  INDIRECTED_CLASSES = [
+    Puppet::FileServing::Metadata,
+    Puppet::FileServing::Content,
+    Puppet::Node::Facts,
+  ]
+
+  INDIRECTORS.each do |indirector|
+    class indirector::Memory < Puppet::Indirector::Memory
+      def find(request)
+        model.new('/dev/null', { 'type' => 'directory' })
+      end
+    end
+  end
+
+  before do
+    FileUtils.mkdir(Puppet[:vardir])
+    FileUtils.mkdir(File.join(Puppet[:vardir], 'lib'))
+    FileUtils.mkdir(File.join(Puppet[:vardir], 'facts.d'))
+    @termini_classes = {}
+    INDIRECTED_CLASSES.each do |indirected|
+      @termini_classes[indirected] = indirected.indirection.terminus_class
+      indirected.indirection.terminus_class = :memory
+    end
+  end
+
+  after do
+    FileUtils.rmdir(File.join(Puppet[:vardir],'lib'))
+    FileUtils.rmdir(File.join(Puppet[:vardir],'facts.d'))
+    FileUtils.rmdir(Puppet[:vardir])
+    INDIRECTED_CLASSES.each do |indirected|
+      indirected.indirection.terminus_class = @termini_classes[indirected]
+      indirected.indirection.termini.clear
+    end
+  end
+
+  def init_cli_args_and_apply_app(args = ["download"])
+    Puppet::Application.find(:plugin).new(stub('command_line', :subcommand_name => :plugin, :args => args))
+  end
+
+  it "processes a download request" do
+    app = init_cli_args_and_apply_app
+    expect do
+      expect {
+        app.run
+      }.to exit_with(0)
+    end.to have_printed(/No plugins downloaded/)
+  end
+end
+end

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

@@ -8,7 +8,7 @@ Puppet::Resource::Catalog.indirection.terminus(:compiler)
 describe Puppet::Resource::Catalog::Compiler do
   before do
     Facter.stubs(:value).returns "something"
-    @catalog = Puppet::Resource::Catalog.new
+    @catalog = Puppet::Resource::Catalog.new("testing", Puppet::Node::Environment::NONE)
     @catalog.add_resource(@one = Puppet::Resource.new(:file, "/one"))
     @catalog.add_resource(@two = Puppet::Resource.new(:file, "/two"))
   end

data/spec/integration/indirector/catalog/queue_spec.rb

@@ -6,7 +6,7 @@ require 'puppet/resource/catalog'
 describe "Puppet::Resource::Catalog::Queue" do
   before do
     Puppet::Resource::Catalog.indirection.terminus(:queue)
-    @catalog = Puppet::Resource::Catalog.new("foo")
+    @catalog = Puppet::Resource::Catalog.new("foo", Puppet::Node::Environment::NONE)
 
     @one = Puppet::Resource.new(:file, "/one")
     @two = Puppet::Resource.new(:file, "/two")

data/spec/integration/node/environment_spec.rb

@@ -74,8 +74,8 @@ describe Puppet::Node::Environment do
 
       catalog = Puppet::Parser::Compiler.compile(node)
 
-      expect(catalog).to have_resource('Class[a]')
-      expect(catalog).to have_resource('Class[b]')
+      expect(catalog).to have_resource('Class[A]')
+      expect(catalog).to have_resource('Class[B]')
       expect(catalog).to have_resource('Notify[variables]').with_parameter(:message, "a: 10, b: 10")
     end
   end

data/spec/integration/parser/future_compiler_spec.rb

@@ -1,28 +1,19 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
 require 'puppet/parser/parser_factory'
 require 'puppet_spec/compiler'
 require 'puppet_spec/pops'
 require 'puppet_spec/scope'
+require 'matchers/resource'
 require 'rgen/metamodel_builder'
 
 # Test compilation using the future evaluator
-#
 describe "Puppet::Parser::Compiler" do
   include PuppetSpec::Compiler
+  include Matchers::Resource
 
   before :each do
     Puppet[:parser] = 'future'
-
-    # This is in the original test - what is this for? Does not seem to make a difference at all
-    @scope_resource = stub 'scope_resource', :builtin? => true, :finish => nil, :ref => 'Class[main]'
-    @scope = stub 'scope', :resource => @scope_resource, :source => mock("source")
-  end
-
-
-  after do
-    Puppet.settings.clear
   end
 
   describe "the compiler when using future parser and evaluator" do
@@ -34,14 +25,15 @@ describe "Puppet::Parser::Compiler" do
 
         Puppet.settings[:config_version] = 'git rev-parse HEAD'
 
-        parser = Puppet::Parser::ParserFactory.parser "development"
         compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("testnode"))
         compiler.catalog.version.should == version
       end
     end
 
     it "should not create duplicate resources when a class is referenced both directly and indirectly by the node classifier (4792)" do
-      Puppet[:code] = <<-PP
+      node = Puppet::Node.new("testnodex")
+      node.classes = ['foo', 'bar']
+      catalog = compile_to_catalog(<<-PP, node)
         class foo
         {
           notify { foo_notify: }
@@ -53,17 +45,25 @@ describe "Puppet::Parser::Compiler" do
         }
       PP
 
-      node = Puppet::Node.new("testnodex")
-      node.classes = ['foo', 'bar']
       catalog = Puppet::Parser::Compiler.compile(node)
-      node.classes = nil
-      catalog.resource("Notify[foo_notify]").should_not be_nil
-      catalog.resource("Notify[bar_notify]").should_not be_nil
+
+      expect(catalog).to have_resource("Notify[foo_notify]")
+      expect(catalog).to have_resource("Notify[bar_notify]")
+    end
+
+    it 'applies defaults for defines with qualified names (PUP-2302)' do
+      catalog = compile_to_catalog(<<-CODE)
+        define my::thing($msg = 'foo') { notify {'check_me': message => $msg } }
+        My::Thing { msg => 'evoe' }
+        my::thing { 'name': }
+      CODE
+
+      expect(catalog).to have_resource("Notify[check_me]").with_parameter(:message, "evoe")
     end
 
     describe "when resolving class references" do
       it "should favor local scope, even if there's an included class in topscope" do
-        Puppet[:code] = <<-PP
+        catalog = compile_to_catalog(<<-PP)
           class experiment {
             class baz {
             }
@@ -76,15 +76,11 @@ describe "Puppet::Parser::Compiler" do
           include experiment::baz
         PP
 
-        catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
-
-        notify_resource = catalog.resource( "Notify[x]" )
-
-        notify_resource[:require].title.should == "Experiment::Baz"
+        expect(catalog).to have_resource("Notify[x]").with_parameter(:require, be_resource("Class[Experiment::Baz]"))
       end
 
       it "should favor local scope, even if there's an unincluded class in topscope" do
-        Puppet[:code] = <<-PP
+        catalog = compile_to_catalog(<<-PP)
           class experiment {
             class baz {
             }
@@ -96,18 +92,15 @@ describe "Puppet::Parser::Compiler" do
           include experiment::baz
         PP
 
-        catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
-
-        notify_resource = catalog.resource( "Notify[x]" )
-
-        notify_resource[:require].title.should == "Experiment::Baz"
+        expect(catalog).to have_resource("Notify[x]").with_parameter(:require, be_resource("Class[Experiment::Baz]"))
       end
     end
+
     describe "(ticket #13349) when explicitly specifying top scope" do
       ["class {'::bar::baz':}", "include ::bar::baz"].each do |include|
         describe "with #{include}" do
           it "should find the top level class" do
-            Puppet[:code] = <<-MANIFEST
+            catalog = compile_to_catalog(<<-MANIFEST)
               class { 'foo::test': }
               class foo::test {
               	#{include}
@@ -120,12 +113,10 @@ describe "Puppet::Parser::Compiler" do
               }
             MANIFEST
 
-            catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
-
-            catalog.resource("Class[Bar::Baz]").should_not be_nil
-            catalog.resource("Notify[good!]").should_not be_nil
-            catalog.resource("Class[Foo::Bar::Baz]").should be_nil
-            catalog.resource("Notify[bad!]").should be_nil
+            expect(catalog).to have_resource("Class[Bar::Baz]")
+            expect(catalog).to have_resource("Notify[good!]")
+            expect(catalog).to_not have_resource("Class[Foo::Bar::Baz]")
+            expect(catalog).to_not have_resource("Notify[bad!]")
           end
         end
       end
@@ -144,39 +135,27 @@ describe "Puppet::Parser::Compiler" do
 
     ['define', 'class', 'node'].each do |thing|
       it "'#{thing}' is not allowed inside evaluated conditional constructs" do
-        Puppet[:code] = <<-PP
-          if true {
-            #{thing} foo {
+        expect do
+          compile_to_catalog(<<-PP)
+            if true {
+              #{thing} foo {
+              }
+              notify { decoy: }
             }
-            notify { decoy: }
-          }
-        PP
-
-        begin
-          catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
-          raise "compilation should have raised Puppet::Error"
-        rescue Puppet::Error => e
-          e.message.should =~ /Classes, definitions, and nodes may only appear at toplevel/
-        end
+          PP
+        end.to raise_error(Puppet::Error, /Classes, definitions, and nodes may only appear at toplevel/)
       end
-    end
 
-    ['define', 'class', 'node'].each do |thing|
       it "'#{thing}' is not allowed inside un-evaluated conditional constructs" do
-        Puppet[:code] = <<-PP
-          if false {
-            #{thing} foo {
+        expect do
+          compile_to_catalog(<<-PP)
+            if false {
+              #{thing} foo {
+              }
+              notify { decoy: }
             }
-            notify { decoy: }
-          }
-        PP
-
-        begin
-          catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
-          raise "compilation should have raised Puppet::Error"
-        rescue Puppet::Error => e
-          e.message.should =~ /Classes, definitions, and nodes may only appear at toplevel/
-        end
+          PP
+        end.to raise_error(Puppet::Error, /Classes, definitions, and nodes may only appear at toplevel/)
       end
     end
 
@@ -185,9 +164,8 @@ describe "Puppet::Parser::Compiler" do
         ref.sub(/File\[(\w+)\]/, '\1')
       end
 
-      let(:node) { Puppet::Node.new('mynode') }
-      let(:code) do
-        <<-MANIFEST
+      def assert_creates_relationships(relationship_code, expectations)
+        base_manifest = <<-MANIFEST
           file { [a,b,c]:
             mode => 0644,
           }
@@ -195,17 +173,7 @@ describe "Puppet::Parser::Compiler" do
             mode => 0755,
           }
         MANIFEST
-      end
-      let(:expected_relationships) { [] }
-      let(:expected_subscriptions) { [] }
-
-      before :each do
-        Puppet[:parser] = 'future'
-        Puppet[:code] = code
-      end
-
-      after :each do
-        catalog = Puppet::Parser::Compiler.compile(node)
+        catalog = compile_to_catalog(base_manifest + relationship_code)
 
         resources = catalog.resources.select { |res| res.type == 'File' }
 
@@ -216,63 +184,53 @@ describe "Puppet::Parser::Compiler" do
           end.inject(&:concat)
         end
 
-        actual_relationships.should =~ expected_relationships
-        actual_subscriptions.should =~ expected_subscriptions
+        actual_relationships.should =~ (expectations[:relationships] || [])
+        actual_subscriptions.should =~ (expectations[:subscriptions] || [])
       end
 
       it "of regular type" do
-        code << "File[a] -> File[b]"
-
-        expected_relationships << ['a','b']
+        assert_creates_relationships("File[a] -> File[b]",
+                                     :relationships => [['a','b']])
       end
 
       it "of subscription type" do
-        code << "File[a] ~> File[b]"
-
-        expected_subscriptions << ['a', 'b']
+        assert_creates_relationships("File[a] ~> File[b]",
+                                     :subscriptions => [['a', 'b']])
       end
 
       it "between multiple resources expressed as resource with multiple titles" do
-        code << "File[a,b] -> File[c,d]"
-
-        expected_relationships.concat [
-          ['a', 'c'],
-          ['b', 'c'],
-          ['a', 'd'],
-          ['b', 'd'],
-        ]
+        assert_creates_relationships("File[a,b] -> File[c,d]",
+                                     :relationships => [['a', 'c'],
+                                                        ['b', 'c'],
+                                                        ['a', 'd'],
+                                                        ['b', 'd']])
       end
 
       it "between collection expressions" do
-        code << "File <| mode == 0644 |> -> File <| mode == 0755 |>"
-
-        expected_relationships.concat [
-          ['a', 'd'],
-          ['b', 'd'],
-          ['c', 'd'],
-          ['a', 'e'],
-          ['b', 'e'],
-          ['c', 'e'],
-        ]
+        assert_creates_relationships("File <| mode == 0644 |> -> File <| mode == 0755 |>",
+                                     :relationships => [['a', 'd'],
+                                                        ['b', 'd'],
+                                                        ['c', 'd'],
+                                                        ['a', 'e'],
+                                                        ['b', 'e'],
+                                                        ['c', 'e']])
       end
 
       it "between resources expressed as Strings" do
-        code << "'File[a]' -> 'File[b]'"
-
-        expected_relationships << ['a', 'b']
+        assert_creates_relationships("'File[a]' -> 'File[b]'",
+                                     :relationships => [['a', 'b']])
       end
 
       it "between resources expressed as variables" do
-        code << <<-MANIFEST
+        assert_creates_relationships(<<-MANIFEST, :relationships => [['a', 'b']])
           $var = File[a]
           $var -> File[b]
         MANIFEST
 
-        expected_relationships << ['a', 'b']
       end
 
       it "between resources expressed as case statements" do
-        code << <<-MANIFEST
+        assert_creates_relationships(<<-MANIFEST, :relationships => [['s1', 't2']])
           $var = 10
           case $var {
             10: {
@@ -292,63 +250,63 @@ describe "Puppet::Parser::Compiler" do
             }
           }
         MANIFEST
-
-        expected_relationships << ['s1', 't2']
       end
 
       it "using deep access in array" do
-        code << <<-MANIFEST
+        assert_creates_relationships(<<-MANIFEST, :relationships => [['a', 'b']])
           $var = [ [ [ File[a], File[b] ] ] ]
           $var[0][0][0] -> $var[0][0][1]
         MANIFEST
 
-        expected_relationships << ['a', 'b']
       end
 
       it "using deep access in hash" do
-        code << <<-MANIFEST
+        assert_creates_relationships(<<-MANIFEST, :relationships => [['a', 'b']])
           $var = {'foo' => {'bar' => {'source' => File[a], 'target' => File[b]}}}
           $var[foo][bar][source] -> $var[foo][bar][target]
         MANIFEST
 
-        expected_relationships << ['a', 'b']
       end
 
       it "using resource declarations" do
-        code << "file { l: } -> file { r: }"
-
-        expected_relationships << ['l', 'r']
+        assert_creates_relationships("file { l: } -> file { r: }", :relationships => [['l', 'r']])
       end
 
       it "between entries in a chain of relationships" do
-        code << "File[a] -> File[b] ~> File[c] <- File[d] <~ File[e]"
-
-        expected_relationships << ['a', 'b'] << ['d', 'c']
-        expected_subscriptions << ['b', 'c'] << ['e', 'd']
+        assert_creates_relationships("File[a] -> File[b] ~> File[c] <- File[d] <~ File[e]",
+                                     :relationships => [['a', 'b'], ['d', 'c']],
+                                     :subscriptions => [['b', 'c'], ['e', 'd']])
       end
     end
 
     context "when dealing with variable references" do
       it 'an initial underscore in a variable name is ok' do
-        node = Puppet::Node.new("testing_x")
-        catalog = compile_to_catalog(<<-MANIFEST, node)
+        catalog = compile_to_catalog(<<-MANIFEST)
           class a { $_a = 10}
           include a
           notify { 'test': message => $a::_a }
         MANIFEST
 
-        catalog.resource("Notify[test]")[:message].should == 10
+        expect(catalog).to have_resource("Notify[test]").with_parameter(:message, 10)
       end
 
       it 'an initial underscore in not ok if elsewhere than last segment' do
-        node = Puppet::Node.new("testing_x")
-        expect { 
-          catalog = compile_to_catalog(<<-MANIFEST, node)
-          class a { $_a = 10}
+        expect do
+          catalog = compile_to_catalog(<<-MANIFEST)
+            class a { $_a = 10}
+            include a
+            notify { 'test': message => $_a::_a }
+          MANIFEST
+        end.to raise_error(/Illegal variable name/)
+      end
+
+      it 'a missing variable as default value becomes undef' do
+        catalog = compile_to_catalog(<<-MANIFEST)
+          class a ($b=$x) { notify {$b: message=>'meh'} }
           include a
-          notify { 'test': message => $_a::_a }
         MANIFEST
-          }.to raise_error(/Illegal variable name/)
+
+        expect(catalog).to have_resource("Notify[undef]").with_parameter(:message, "meh")
       end
     end
 
@@ -366,7 +324,7 @@ describe "Puppet::Parser::Compiler" do
             notify { 'test': message => $trusted[data] }
           MANIFEST
 
-          catalog.resource("Notify[test]")[:message].should == "value"
+          expect(catalog).to have_resource("Notify[test]").with_parameter(:message, "value")
         end
 
         it 'should not allow assignment to $trusted' do
@@ -374,11 +332,10 @@ describe "Puppet::Parser::Compiler" do
           node.trusted_data = { "data" => "value" }
 
           expect do
-            catalog = compile_to_catalog(<<-MANIFEST, node)
+            compile_to_catalog(<<-MANIFEST, node)
               $trusted = 'changed'
               notify { 'test': message => $trusted == 'changed' }
             MANIFEST
-            catalog.resource("Notify[test]")[:message].should == true
           end.to raise_error(Puppet::Error, /Attempt to assign to a reserved variable name: 'trusted'/)
         end
       end
@@ -396,21 +353,18 @@ describe "Puppet::Parser::Compiler" do
             notify { 'test': message => ($trusted == undef) }
           MANIFEST
 
-          catalog.resource("Notify[test]")[:message].should == true
+          expect(catalog).to have_resource("Notify[test]").with_parameter(:message, true)
         end
 
         it 'should allow assignment to $trusted' do
-          node = Puppet::Node.new("testing")
-
-          catalog = compile_to_catalog(<<-MANIFEST, node)
+          catalog = compile_to_catalog(<<-MANIFEST)
             $trusted = 'changed'
             notify { 'test': message => $trusted == 'changed' }
           MANIFEST
 
-          catalog.resource("Notify[test]")[:message].should == true
+          expect(catalog).to have_resource("Notify[test]").with_parameter(:message, true)
         end
       end
     end
   end
-
 end