puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/spec/integration/parser/conditionals_spec.rb

@@ -6,7 +6,7 @@ describe "Evaluation of Conditionals" do
   include PuppetSpec::Compiler
   include Matchers::Resource
 
-  shared_examples_for "a catalog built with conditionals" do
+  context "a catalog built with conditionals" do
     it "evaluates an if block correctly" do
       catalog = compile_to_catalog(<<-CODE)
       if( 1 == 1) {
@@ -76,32 +76,6 @@ describe "Evaluation of Conditionals" do
       CODE
       expect(catalog).to have_resource("Notify[undef]")
     end
-  end
-
-  context "current parser" do
-    before(:each) do
-      Puppet[:parser] = 'current'
-    end
-
-    it_behaves_like "a catalog built with conditionals"
-
-    it "evaluates empty string as false" do
-      catalog = compile_to_catalog(<<-CODE)
-      if '' {
-        notify { 'true': }
-      } else {
-        notify { 'empty': }
-      }
-      CODE
-      expect(catalog).to have_resource("Notify[empty]")
-    end
-  end
-
-  context "future parser" do
-    before(:each) do
-      Puppet[:parser] = 'future'
-    end
-    it_behaves_like "a catalog built with conditionals"
 
     it "evaluates empty string as true" do
       catalog = compile_to_catalog(<<-CODE)
@@ -114,4 +88,5 @@ describe "Evaluation of Conditionals" do
       expect(catalog).to have_resource("Notify[true]")
     end
   end
+
 end

data/spec/integration/parser/functions/require_spec.rb

@@ -18,10 +18,10 @@ describe "The require function" do
     @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "requiredclass")
 
     @scope.function_require(["requiredclass"])
-    @scope.resource["require"].should_not be_nil
+    expect(@scope.resource["require"]).not_to be_nil
     ref = @scope.resource["require"].shift
-    ref.type.should == "Class"
-    ref.title.should == "Requiredclass"
+    expect(ref.type).to eq("Class")
+    expect(ref.title).to eq("Requiredclass")
   end
 
   it "should queue relationships between the 'required' class and our classes" do
@@ -31,13 +31,13 @@ describe "The require function" do
     @scope.function_require(["requiredclass1"])
     @scope.function_require(["requiredclass2"])
 
-    @scope.resource["require"].should_not be_nil
+    expect(@scope.resource["require"]).not_to be_nil
 
     (ref1,ref2) = @scope.resource["require"]
-    ref1.type.should == "Class"
-    ref1.title.should == "Requiredclass1"
-    ref2.type.should == "Class"
-    ref2.title.should == "Requiredclass2"
+    expect(ref1.type).to eq("Class")
+    expect(ref1.title).to eq("Requiredclass1")
+    expect(ref2.type).to eq("Class")
+    expect(ref2.title).to eq("Requiredclass2")
   end
 
 end

data/spec/integration/parser/node_spec.rb

@@ -6,7 +6,7 @@ describe 'node statements' do
   include PuppetSpec::Compiler
   include Matchers::Resource
 
-  shared_examples_for 'nodes' do
+  context 'nodes' do
     it 'selects a node where the name is just a number' do
       # Future parser doesn't allow a number in this position
       catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("5"))
@@ -61,20 +61,43 @@ describe 'node statements' do
       expect(catalog).to have_resource('Notify[matched]')
     end
 
-    it 'errors when two nodes with regexes collide after some regex syntax is removed' do
+    it 'that have regex names should not collide with matching class names' do
+        catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("foo"))
+        class foo {
+          $bar = 'one'
+        }
+
+        node /foo/ {
+          $bar = 'two'
+          include foo
+          notify{"${::foo::bar}":}
+        }
+        MANIFEST
+        expect(catalog).to have_resource('Notify[one]')
+    end
+
+    it 'does not raise an error with regex and non-regex node names are the same' do
       expect do
         compile_to_catalog(<<-MANIFEST)
         node /a.*(c)?/ { }
         node 'a.c' { }
         MANIFEST
-      end.to raise_error(Puppet::Error, /Node 'a.c' is already defined/)
+      end.not_to raise_error
+    end
+
+    it 'errors when two nodes with regexes collide after some regex syntax is removed' do
+      expect do
+        compile_to_catalog(<<-MANIFEST)
+        node /a.*(c)?/ { }
+        node /a.*c/ { }
+        MANIFEST
+      end.to raise_error(Puppet::Error, /Node '__node_regexp__a.c' is already defined/)
     end
 
     it 'provides captures from the regex in the node body' do
       catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("nodename"))
       node /(.*)/ { notify { "$1": } }
       MANIFEST
-
       expect(catalog).to have_resource('Notify[nodename]')
     end
 
@@ -120,48 +143,11 @@ describe 'node statements' do
         MANIFEST
       end.to raise_error(Puppet::Error, /Node 'name' is already defined/)
     end
-  end
-
-  describe 'using classic parser' do
-    before :each do
-      Puppet[:parser] = 'current'
-    end
-
-    it_behaves_like 'nodes'
-
-    it 'includes the inherited nodes of the matching node' do
-      catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("nodename"))
-      node notmatched1 { notify { inherited: } }
-      node nodename inherits notmatched1 { notify { matched: } }
-      node notmatched2 { notify { ignored: } }
-      MANIFEST
-
-      expect(catalog).to have_resource('Notify[matched]')
-      expect(catalog).to have_resource('Notify[inherited]')
-    end
-
-    it 'raises deprecation warning for node inheritance for 3x parser' do
-      Puppet.expects(:warning).at_least_once
-      Puppet.expects(:warning).with(regexp_matches(/Deprecation notice\: Node inheritance is not supported in Puppet >= 4\.0\.0/))
-
-      catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("1.2.3.4"))
-        node default {}
-        node '1.2.3.4' inherits default {  }
-      MANIFEST
-    end
-  end
-
-  describe 'using future parser' do
-    before :each do
-      Puppet[:parser] = 'future'
-    end
-
-    it_behaves_like 'nodes'
 
     it 'is unable to parse a name that is an invalid number' do
       expect do
         compile_to_catalog('node 5name {} ')
-      end.to raise_error(Puppet::Error, /Illegal number/)
+      end.to raise_error(Puppet::Error, /Illegal number '5name'/)
     end
 
     it 'parses a node name that is dotted numbers' do
@@ -182,4 +168,5 @@ describe 'node statements' do
     end
 
   end
+
 end

data/spec/integration/parser/resource_expressions_spec.rb

@@ -4,13 +4,8 @@ require 'puppet_spec/language'
 describe "Puppet resource expressions" do
   extend PuppetSpec::Language
 
-  describe "future parser" do
-    before :each do
-      Puppet[:parser] = 'future'
-    end
-
-    produces(
-      "$a = notify
+  produces(
+  "$a = notify
        $b = example
        $c = { message => hello }
        @@Resource[$a] {
@@ -20,136 +15,135 @@ describe "Puppet resource expressions" do
        realize(Resource[$a, $b])
        " => "Notify[example][message] == 'hello'")
 
+  context "resource titles" do
+    produces(
+    "notify { thing: }"                     => "defined(Notify[thing])",
+    "$x = thing notify { $x: }"             => "defined(Notify[thing])",
 
-    context "resource titles" do
-      produces(
-        "notify { thing: }"                     => "defined(Notify[thing])",
-        "$x = thing notify { $x: }"             => "defined(Notify[thing])",
-
-        "notify { [thing]: }"                   => "defined(Notify[thing])",
-        "$x = [thing] notify { $x: }"           => "defined(Notify[thing])",
+    "notify { [thing]: }"                   => "defined(Notify[thing])",
+    "$x = [thing] notify { $x: }"           => "defined(Notify[thing])",
 
-        "notify { [[nested, array]]: }"         => "defined(Notify[nested]) and defined(Notify[array])",
-        "$x = [[nested, array]] notify { $x: }" => "defined(Notify[nested]) and defined(Notify[array])",
+    "notify { [[nested, array]]: }"         => "defined(Notify[nested]) and defined(Notify[array])",
+    "$x = [[nested, array]] notify { $x: }" => "defined(Notify[nested]) and defined(Notify[array])",
 
-        "notify { []: }"                        => [], # this asserts nothing added
-        "$x = [] notify { $x: }"                => [], # this asserts nothing added
+    "notify { []: }"                        => [], # this asserts nothing added
+    "$x = [] notify { $x: }"                => [], # this asserts nothing added
 
-        "notify { default: }"                   => "!defined(Notify['default'])", # nothing created because this is just a local default
-        "$x = default notify { $x: }"           => "!defined(Notify['default'])")
+    "notify { default: }"                   => "!defined(Notify['default'])", # nothing created because this is just a local default
+    "$x = default notify { $x: }"           => "!defined(Notify['default'])")
 
-      fails(
-        "notify { '': }"                         => /Empty string title/,
-        "$x = '' notify { $x: }"                 => /Empty string title/,
+    fails(
+    "notify { '': }"                         => /Empty string title/,
+    "$x = '' notify { $x: }"                 => /Empty string title/,
 
-        "notify { 1: }"                          => /Illegal title type.*Expected String, got Integer/,
-        "$x = 1 notify { $x: }"                  => /Illegal title type.*Expected String, got Integer/,
+    "notify { 1: }"                          => /Illegal title type.*Expected String, got Integer/,
+    "$x = 1 notify { $x: }"                  => /Illegal title type.*Expected String, got Integer/,
 
-        "notify { [1]: }"                        => /Illegal title type.*Expected String, got Integer/,
-        "$x = [1] notify { $x: }"                => /Illegal title type.*Expected String, got Integer/,
+    "notify { [1]: }"                        => /Illegal title type.*Expected String, got Integer/,
+    "$x = [1] notify { $x: }"                => /Illegal title type.*Expected String, got Integer/,
 
-        "notify { 3.0: }"                        => /Illegal title type.*Expected String, got Float/,
-        "$x = 3.0 notify { $x: }"                => /Illegal title type.*Expected String, got Float/,
+    "notify { 3.0: }"                        => /Illegal title type.*Expected String, got Float/,
+    "$x = 3.0 notify { $x: }"                => /Illegal title type.*Expected String, got Float/,
 
-        "notify { [3.0]: }"                      => /Illegal title type.*Expected String, got Float/,
-        "$x = [3.0] notify { $x: }"              => /Illegal title type.*Expected String, got Float/,
+    "notify { [3.0]: }"                      => /Illegal title type.*Expected String, got Float/,
+    "$x = [3.0] notify { $x: }"              => /Illegal title type.*Expected String, got Float/,
 
-        "notify { true: }"                       => /Illegal title type.*Expected String, got Boolean/,
-        "$x = true notify { $x: }"               => /Illegal title type.*Expected String, got Boolean/,
+    "notify { true: }"                       => /Illegal title type.*Expected String, got Boolean/,
+    "$x = true notify { $x: }"               => /Illegal title type.*Expected String, got Boolean/,
 
-        "notify { [true]: }"                     => /Illegal title type.*Expected String, got Boolean/,
-        "$x = [true] notify { $x: }"             => /Illegal title type.*Expected String, got Boolean/,
+    "notify { [true]: }"                     => /Illegal title type.*Expected String, got Boolean/,
+    "$x = [true] notify { $x: }"             => /Illegal title type.*Expected String, got Boolean/,
 
-        "notify { [false]: }"                    => /Illegal title type.*Expected String, got Boolean/,
-        "$x = [false] notify { $x: }"            => /Illegal title type.*Expected String, got Boolean/,
+    "notify { [false]: }"                    => /Illegal title type.*Expected String, got Boolean/,
+    "$x = [false] notify { $x: }"            => /Illegal title type.*Expected String, got Boolean/,
 
-        "notify { undef: }"                      => /Missing title.*undef/,
-        "$x = undef notify { $x: }"              => /Missing title.*undef/,
+    "notify { undef: }"                      => /Missing title.*undef/,
+    "$x = undef notify { $x: }"              => /Missing title.*undef/,
 
-        "notify { [undef]: }"                    => /Missing title.*undef/,
-        "$x = [undef] notify { $x: }"            => /Missing title.*undef/,
+    "notify { [undef]: }"                    => /Missing title.*undef/,
+    "$x = [undef] notify { $x: }"            => /Missing title.*undef/,
 
-        "notify { {nested => hash}: }"           => /Illegal title type.*Expected String, got Hash/,
-        "$x = {nested => hash} notify { $x: }"   => /Illegal title type.*Expected String, got Hash/,
+    "notify { {nested => hash}: }"           => /Illegal title type.*Expected String, got Hash/,
+    "$x = {nested => hash} notify { $x: }"   => /Illegal title type.*Expected String, got Hash/,
 
-        "notify { [{nested => hash}]: }"         => /Illegal title type.*Expected String, got Hash/,
-        "$x = [{nested => hash}] notify { $x: }" => /Illegal title type.*Expected String, got Hash/,
+    "notify { [{nested => hash}]: }"         => /Illegal title type.*Expected String, got Hash/,
+    "$x = [{nested => hash}] notify { $x: }" => /Illegal title type.*Expected String, got Hash/,
 
-        "notify { /regexp/: }"                   => /Illegal title type.*Expected String, got Regexp/,
-        "$x = /regexp/ notify { $x: }"           => /Illegal title type.*Expected String, got Regexp/,
+    "notify { /regexp/: }"                   => /Illegal title type.*Expected String, got Regexp/,
+    "$x = /regexp/ notify { $x: }"           => /Illegal title type.*Expected String, got Regexp/,
 
-        "notify { [/regexp/]: }"                 => /Illegal title type.*Expected String, got Regexp/,
-        "$x = [/regexp/] notify { $x: }"         => /Illegal title type.*Expected String, got Regexp/,
+    "notify { [/regexp/]: }"                 => /Illegal title type.*Expected String, got Regexp/,
+    "$x = [/regexp/] notify { $x: }"         => /Illegal title type.*Expected String, got Regexp/,
 
-        "notify { [dupe, dupe]: }"               => /The title 'dupe' has already been used/,
-        "notify { dupe:; dupe: }"                => /The title 'dupe' has already been used/,
-        "notify { [dupe]:; dupe: }"              => /The title 'dupe' has already been used/,
-        "notify { [default, default]:}"          => /The title 'default' has already been used/,
-        "notify { default:; default:}"           => /The title 'default' has already been used/,
-        "notify { [default]:; default:}"         => /The title 'default' has already been used/)
-    end
+    "notify { [dupe, dupe]: }"               => /The title 'dupe' has already been used/,
+    "notify { dupe:; dupe: }"                => /The title 'dupe' has already been used/,
+    "notify { [dupe]:; dupe: }"              => /The title 'dupe' has already been used/,
+    "notify { [default, default]:}"          => /The title 'default' has already been used/,
+    "notify { default:; default:}"           => /The title 'default' has already been used/,
+    "notify { [default]:; default:}"         => /The title 'default' has already been used/)
+  end
 
-    context "type names" do
-      produces( "notify { testing: }"                            => "defined(Notify[testing])")
-      produces( "$a = notify; Resource[$a] { testing: }"         => "defined(Notify[testing])")
-      produces( "Resource['notify'] { testing: }"                => "defined(Notify[testing])")
-      produces( "Resource[sprintf('%s', 'notify')] { testing: }" => "defined(Notify[testing])")
-      produces( "$a = ify; Resource[\"not$a\"] { testing: }"     => "defined(Notify[testing])")
+  context "type names" do
+    produces( "notify { testing: }"                            => "defined(Notify[testing])")
+    produces( "$a = notify; Resource[$a] { testing: }"         => "defined(Notify[testing])")
+    produces( "Resource['notify'] { testing: }"                => "defined(Notify[testing])")
+    produces( "Resource[sprintf('%s', 'notify')] { testing: }" => "defined(Notify[testing])")
+    produces( "$a = ify; Resource[\"not$a\"] { testing: }"     => "defined(Notify[testing])")
 
-      produces( "Notify { testing: }"           => "defined(Notify[testing])")
-      produces( "Resource[Notify] { testing: }" => "defined(Notify[testing])")
-      produces( "Resource['Notify'] { testing: }"         => "defined(Notify[testing])")
+    produces( "Notify { testing: }"           => "defined(Notify[testing])")
+    produces( "Resource[Notify] { testing: }" => "defined(Notify[testing])")
+    produces( "Resource['Notify'] { testing: }"         => "defined(Notify[testing])")
 
-      produces( "class a { notify { testing: } } class { a: }"   => "defined(Notify[testing])")
-      produces( "class a { notify { testing: } } Class { a: }"   => "defined(Notify[testing])")
-      produces( "class a { notify { testing: } } Resource['class'] { a: }" => "defined(Notify[testing])")
+    produces( "class a { notify { testing: } } class { a: }"   => "defined(Notify[testing])")
+    produces( "class a { notify { testing: } } Class { a: }"   => "defined(Notify[testing])")
+    produces( "class a { notify { testing: } } Resource['class'] { a: }" => "defined(Notify[testing])")
 
-      produces( "define a::b { notify { testing: } } a::b { title: }" => "defined(Notify[testing])")
-      produces( "define a::b { notify { testing: } } A::B { title: }" => "defined(Notify[testing])")
-      produces( "define a::b { notify { testing: } } Resource['a::b'] { title: }" => "defined(Notify[testing])")
+    produces( "define a::b { notify { testing: } } a::b { title: }" => "defined(Notify[testing])")
+    produces( "define a::b { notify { testing: } } A::B { title: }" => "defined(Notify[testing])")
+    produces( "define a::b { notify { testing: } } Resource['a::b'] { title: }" => "defined(Notify[testing])")
 
-      fails( "'class' { a: }"              => /Illegal Resource Type expression.*got String/)
-      fails( "'' { testing: }"             => /Illegal Resource Type expression.*got String/)
-      fails( "1 { testing: }"              => /Illegal Resource Type expression.*got Integer/)
-      fails( "3.0 { testing: }"            => /Illegal Resource Type expression.*got Float/)
-      fails( "true { testing: }"           => /Illegal Resource Type expression.*got Boolean/)
-      fails( "'not correct' { testing: }"  => /Illegal Resource Type expression.*got String/)
+    fails( "'class' { a: }"              => /Illegal Resource Type expression.*got String/)
+    fails( "'' { testing: }"             => /Illegal Resource Type expression.*got String/)
+    fails( "1 { testing: }"              => /Illegal Resource Type expression.*got Integer/)
+    fails( "3.0 { testing: }"            => /Illegal Resource Type expression.*got Float/)
+    fails( "true { testing: }"           => /Illegal Resource Type expression.*got Boolean/)
+    fails( "'not correct' { testing: }"  => /Illegal Resource Type expression.*got String/)
 
-      fails( "Notify[hi] { testing: }"     => /Illegal Resource Type expression.*got Notify\['hi'\]/)
-      fails( "[Notify, File] { testing: }" => /Illegal Resource Type expression.*got Array\[Type\[Resource\]\]/)
+    fails( "Notify[hi] { testing: }"     => /Illegal Resource Type expression.*got Notify\['hi'\]/)
+    fails( "[Notify, File] { testing: }" => /Illegal Resource Type expression.*got Array\[Type\[Resource\]\]/)
 
-      fails( "define a::b { notify { testing: } } 'a::b' { title: }" => /Illegal Resource Type expression.*got String/)
+    fails( "define a::b { notify { testing: } } 'a::b' { title: }" => /Illegal Resource Type expression.*got String/)
 
-      fails( "Does::Not::Exist { title: }" => /Invalid resource type does::not::exist/)
-    end
+    fails( "Does::Not::Exist { title: }" => /Invalid resource type does::not::exist/)
+  end
 
-    context "local defaults" do
-      produces(
-        "notify { example:;                     default: message => defaulted }" => "Notify[example][message] == 'defaulted'",
-        "notify { example: message => specific; default: message => defaulted }" => "Notify[example][message] == 'specific'",
-        "notify { example: message => undef;    default: message => defaulted }" => "Notify[example][message] == undef",
-        "notify { [example, other]: ;           default: message => defaulted }" => "Notify[example][message] == 'defaulted' and Notify[other][message] == 'defaulted'",
-        "notify { [example, default]: message => set; other: }"                  => "Notify[example][message] == 'set' and Notify[other][message] == 'set'")
-    end
+  context "local defaults" do
+    produces(
+    "notify { example:;                     default: message => defaulted }" => "Notify[example][message] == 'defaulted'",
+    "notify { example: message => specific; default: message => defaulted }" => "Notify[example][message] == 'specific'",
+    "notify { example: message => undef;    default: message => defaulted }" => "Notify[example][message] == undef",
+    "notify { [example, other]: ;           default: message => defaulted }" => "Notify[example][message] == 'defaulted' and Notify[other][message] == 'defaulted'",
+    "notify { [example, default]: message => set; other: }"                  => "Notify[example][message] == 'set' and Notify[other][message] == 'set'")
+  end
 
-    context "order of evaluation" do
-      fails("notify { hi: message => value; bye: message => Notify[hi][message] }" => /Resource not found: Notify\['hi'\]/)
+  context "order of evaluation" do
+    fails("notify { hi: message => value; bye: message => Notify[hi][message] }" => /Resource not found: Notify\['hi'\]/)
 
-      produces("notify { hi: message => (notify { param: message => set }); bye: message => Notify[param][message] }" => "defined(Notify[hi]) and Notify[bye][message] == 'set'")
-      fails("notify { bye: message => Notify[param][message]; hi: message => (notify { param: message => set }) }" => /Resource not found: Notify\['param'\]/)
-    end
+    produces("notify { hi: message => (notify { param: message => set }); bye: message => Notify[param][message] }" => "defined(Notify[hi]) and Notify[bye][message] == 'set'")
+    fails("notify { bye: message => Notify[param][message]; hi: message => (notify { param: message => set }) }" => /Resource not found: Notify\['param'\]/)
+  end
 
-    context "parameters" do
-      produces(
-        "notify { title: message => set }"                   => "Notify[title][message] == 'set'",
-        "$x = set notify { title: message => $x }"           => "Notify[title][message] == 'set'",
+  context "parameters" do
+    produces(
+    "notify { title: message => set }"                   => "Notify[title][message] == 'set'",
+    "$x = set notify { title: message => $x }"           => "Notify[title][message] == 'set'",
 
-        "notify { title: *=> { message => set } }"           => "Notify[title][message] == 'set'",
+    "notify { title: *=> { message => set } }"           => "Notify[title][message] == 'set'",
 
-        "$x = { message => set } notify { title: * => $x }"  => "Notify[title][message] == 'set'",
+    "$x = { message => set } notify { title: * => $x }"  => "Notify[title][message] == 'set'",
 
-        # picks up defaults
-        "$x = { owner => the_x }
+    # picks up defaults
+    "$x = { owner => the_x }
          $y = { mode =>  '0666' }
          $t = '/tmp/x'
          file {
@@ -159,8 +153,8 @@ describe "Puppet resource expressions" do
              path => '/somewhere',
              * => $y }"  => "File[$t][mode] == '0666' and File[$t][owner] == 'the_x' and File[$t][path] == '/somewhere'",
 
-        # explicit wins over default - no error
-        "$x = { owner => the_x, mode => '0777' }
+    # explicit wins over default - no error
+    "$x = { owner => the_x, mode => '0777' }
          $y = { mode =>  '0666' }
          $t = '/tmp/x'
          file {
@@ -170,49 +164,46 @@ describe "Puppet resource expressions" do
              path => '/somewhere',
              * => $y }"  => "File[$t][mode] == '0666' and File[$t][owner] == 'the_x' and File[$t][path] == '/somewhere'")
 
-      produces("notify{title:}; Notify[title] { * => { message => set}}" => "Notify[title][message] == 'set'")
-      produces("Notify { * => { message => set}}; notify{title:}"      => "Notify[title][message] == 'set'")
-
-      fails("notify { title: unknown => value }" => /Invalid parameter unknown/)
+    fails("notify { title: unknown => value }" => /Invalid parameter: 'unknown'/)
 
-        # this really needs to be a better error message.
-        fails("notify { title: * => { hash => value }, message => oops }" => /Invalid parameter hash/)
+    # this really needs to be a better error message.
+    fails("notify { title: * => { hash => value }, message => oops }" => /Invalid parameter: 'hash'/)
 
-        # should this be a better error message?
-        fails("notify { title: message => oops, * => { hash => value } }" => /Invalid parameter hash/)
+    # should this be a better error message?
+    fails("notify { title: message => oops, * => { hash => value } }" => /Invalid parameter: 'hash'/)
 
-        fails("notify { title: * => { unknown => value } }" => /Invalid parameter unknown/)
-        fails("
+    fails("notify { title: * => { unknown => value } }" => /Invalid parameter: 'unknown'/)
+    fails("
          $x = { mode => '0666' }
          $y = { owner => the_y }
          $t = '/tmp/x'
          file { $t:
            * => $x,
            * => $y }"  => /Unfolding of attributes from Hash can only be used once per resource body/)
-    end
+  end
 
-    context "virtual" do
-      produces(
-        "@notify { example: }"                     => "!defined(Notify[example])",
+  context "virtual" do
+    produces(
+    "@notify { example: }"                     => "!defined(Notify[example])",
 
-        "@notify { example: }
+    "@notify { example: }
          realize(Notify[example])"                 => "defined(Notify[example])",
 
-        "@notify { virtual: message => set }
+    "@notify { virtual: message => set }
          notify { real:
            message => Notify[virtual][message] }"  => "Notify[real][message] == 'set'")
-    end
-
-    context "exported" do
-      produces(
-        "@@notify { example: }" => "!defined(Notify[example])",
-        "@@notify { example: } realize(Notify[example])" => "defined(Notify[example])",
-        "@@notify { exported: message => set } notify { real: message => Notify[exported][message] }" => "Notify[real][message] == 'set'")
-    end
-
-    context "explicit undefs" do
-      # PUP-3505
-      produces("
+  end
+
+  context "exported" do
+    produces(
+    "@@notify { example: }" => "!defined(Notify[example])",
+    "@@notify { example: } realize(Notify[example])" => "defined(Notify[example])",
+    "@@notify { exported: message => set } notify { real: message => Notify[exported][message] }" => "Notify[real][message] == 'set'")
+  end
+
+  context "explicit undefs" do
+    # PUP-3505
+    produces("
         $x = 10
         define foo($x = undef) {
           notify { example:
@@ -221,82 +212,6 @@ describe "Puppet resource expressions" do
         }
         foo {'blah': x => undef }
       " => "Notify[example][message] == \"''\"")
-    end
-  end
-
-  describe "current parser" do
-    before :each do
-      Puppet[:parser] = 'current'
-    end
-
-    produces(
-      "notify { thing: }"                     => ["Notify[thing]"],
-      "$x = thing notify { $x: }"             => ["Notify[thing]"],
-
-      "notify { [thing]: }"                   => ["Notify[thing]"],
-      "$x = [thing] notify { $x: }"           => ["Notify[thing]"],
-
-      "notify { [[nested, array]]: }"         => ["Notify[nested]", "Notify[array]"],
-      "$x = [[nested, array]] notify { $x: }" => ["Notify[nested]", "Notify[array]"],
-
-      # deprecate?
-      "notify { 1: }"                         => ["Notify[1]"],
-      "$x = 1 notify { $x: }"                 => ["Notify[1]"],
-
-      # deprecate?
-      "notify { [1]: }"                       => ["Notify[1]"],
-      "$x = [1] notify { $x: }"               => ["Notify[1]"],
-
-      # deprecate?
-      "notify { 3.0: }"                       => ["Notify[3.0]"],
-      "$x = 3.0 notify { $x: }"               => ["Notify[3.0]"],
-
-      # deprecate?
-      "notify { [3.0]: }"                     => ["Notify[3.0]"],
-      "$x = [3.0] notify { $x: }"             => ["Notify[3.0]"])
-
-    # :(
-    fails(   "notify { true: }"         => /Syntax error/)
-    produces("$x = true notify { $x: }" => ["Notify[true]"])
-
-    # this makes no sense given the [false] case
-    produces(
-      "notify { [true]: }"         => ["Notify[true]"],
-      "$x = [true] notify { $x: }" => ["Notify[true]"])
-
-    # *sigh*
-    fails(
-      "notify { false: }"           => /Syntax error/,
-      "$x = false notify { $x: }"   => /No title provided and :notify is not a valid resource reference/,
-
-      "notify { [false]: }"         => /No title provided and :notify is not a valid resource reference/,
-      "$x = [false] notify { $x: }" => /No title provided and :notify is not a valid resource reference/)
-
-    # works for variable value, not for literal. deprecate?
-    fails("notify { undef: }"         => /Syntax error/)
-    produces(
-      "$x = undef notify { $x: }" => ["Notify[undef]"],
-
-      # deprecate?
-      "notify { [undef]: }"         => ["Notify[undef]"],
-      "$x = [undef] notify { $x: }" => ["Notify[undef]"])
-
-    fails("notify { {nested => hash}: }" => /Syntax error/)
-    #produces("$x = {nested => hash} notify { $x: }" => ["Notify[{nested => hash}]"]) #it is created, but isn't possible to reference the resource. deprecate?
-    #produces("notify { [{nested => hash}]: }" => ["Notify[{nested => hash}]"]) #it is created, but isn't possible to reference the resource. deprecate?
-    #produces("$x = [{nested => hash}] notify { $x: }" => ["Notify[{nested => hash}]"]) #it is created, but isn't possible to reference the resource. deprecate?
-
-    fails(
-      "notify { /regexp/: }" => /Syntax error/,
-      "$x = /regexp/ notify { $x: }" => /Syntax error/,
-
-      "notify { [/regexp/]: }" => /Syntax error/,
-      "$x = [/regexp/] notify { $x: }" => /Syntax error/,
-
-      "notify { default: }" => /Syntax error/,
-      "$x = default notify { $x: }" => /Syntax error/,
-
-      "notify { [default]: }" => /Syntax error/,
-      "$x = [default] notify { $x: }" => /Syntax error/)
   end
 end
+