puppet 4.0.0-x64-mingw32 → 4.1.0-x64-mingw32

data/spec/unit/functions/hiera_spec.rb

@@ -26,18 +26,20 @@ describe 'when calling' do
       expect(hiera.call(scope, 'key')).to eql('foo_result')
     end
 
-    it 'should propagate optional default' do
-      dflt = 'the_default'
-      Hiera.any_instance.expects(:lookup).with { |*args| expect(args[1]).to be(dflt) }.returns('foo_result')
-      expect(hiera.call(scope, 'key', dflt)).to eql('foo_result')
-    end
-
     it 'should propagate optional override' do
       ovr = 'the_override'
       Hiera.any_instance.expects(:lookup).with { |*args| expect(args[3]).to be(ovr) }.returns('foo_result')
       expect(hiera.call(scope, 'key', nil, ovr)).to eql('foo_result')
     end
 
+    it 'should return default value nil when key is not found' do
+       expect(hiera.call(scope, 'foo', nil)).to be_nil
+    end
+
+    it "should return default value '' when key is not found" do
+      expect(hiera.call(scope, 'foo', '')).to eq('')
+    end
+
     it 'should use default block' do
       #expect(hiera.call(scope, 'foo', lambda_1(scope, loader) { |k| "default for key '#{k}'" })).to eql("default for key 'foo'")
       expect(hiera.call(scope, 'foo') { |k| "default for key '#{k}'" }).to eql("default for key 'foo'")

data/spec/unit/functions/regsubst_spec.rb

@@ -66,6 +66,10 @@ describe 'the regsubst function' do
     it 'should accept Type[Regexp]' do
       expect(regsubst('abc', type_parser.parse("Regexp['b']"), '_')).to eql('a_c')
     end
+
+    it 'should treat Regexp as Regexp[//]' do
+      expect(regsubst('abc', type_parser.parse("Regexp"), '_', 'G')).to eql('_a_b_c_')
+    end
   end
 
   context 'when using an array target' do

data/spec/unit/functions/split_spec.rb

@@ -43,4 +43,12 @@ describe 'the split function' do
   it 'should handle pattern in Regexp Type form' do
     expect(split('a,b',type_parser.parse('Regexp[/,/]'))).to eql(['a', 'b'])
   end
+
+  it 'should handle pattern in Regexp Type form with empty regular expression' do
+    expect(split('ab',type_parser.parse('Regexp[//]'))).to eql(['a', 'b'])
+  end
+
+  it 'should handle pattern in Regexp Type form with missing regular expression' do
+    expect(split('ab',type_parser.parse('Regexp'))).to eql(['a', 'b'])
+  end
 end

data/spec/unit/functions4_spec.rb

@@ -177,7 +177,7 @@ actual:
     end
 
     it 'an error includes optional indicators and count for last element when defined via dispatch' do
-      f = create_function_with_optionals_and_varargs_via_dispatch()
+      f = create_function_with_optionals_and_repeated_via_dispatch()
       # TODO: Bogus parameters, not yet used
       func = f.new(:closure_scope, :loader)
       expect(func.is_a?(Puppet::Functions::Function)).to be_truthy
@@ -191,6 +191,39 @@ actual:
   min(Integer) - arg count {1}")
     end
 
+    it 'can create optional repeated parameter' do
+      f = create_function_with_repeated
+      func = f.new(:closure_scope, :loader)
+      expect(func.call({})).to eql(0)
+      expect(func.call({}, 1)).to eql(1)
+      expect(func.call({}, 1, 2)).to eql(2)
+
+      f = create_function_with_optional_repeated
+      func = f.new(:closure_scope, :loader)
+      expect(func.call({})).to eql(0)
+      expect(func.call({}, 1)).to eql(1)
+      expect(func.call({}, 1, 2)).to eql(2)
+    end
+
+    it 'can create required repeated parameter' do
+      f = create_function_with_required_repeated
+      func = f.new(:closure_scope, :loader)
+      expect(func.call({}, 1)).to eql(1)
+      expect(func.call({}, 1, 2)).to eql(2)
+      expect { func.call({}) }.to raise_error(ArgumentError,
+"function 'count_args' called with mis-matched arguments
+expected:
+  count_args(Any c{1,}) - arg count {1,}
+actual:
+  count_args(Undef{0}) - arg count {0}")
+    end
+
+    it 'can create scope_param followed by repeated  parameter' do
+      f = create_function_with_scope_param_required_repeat
+      func = f.new(:closure_scope, :loader)
+      expect(func.call({}, 'yay', 1,2,3)).to eql([{}, 'yay',1,2,3])
+    end
+
     it 'a function can use inexact argument mapping' do
       f = create_function_with_inexact_dispatch
       func = f.new(:closure_scope, :loader)
@@ -213,6 +246,10 @@ actual:
       expect { create_function_with_rq_after_opt }.to raise_error(ArgumentError, 'A required parameter cannot be added after an optional parameter')
     end
 
+    it 'a function can not be created with required repeated parameters declared after optional ones' do
+      expect { create_function_with_rq_repeated_after_opt }.to raise_error(ArgumentError, 'A required repeated parameter cannot be added after an optional parameter')
+    end
+
     it 'an error is raised with reference to multiple methods when called with mis-matched arguments' do
       f = create_min_function_class_disptaching_to_two_methods()
       # TODO: Bogus parameters, not yet used
@@ -553,7 +590,7 @@ actual:
     end
   end
 
-  def create_function_with_optionals_and_varargs_via_dispatch
+  def create_function_with_optionals_and_repeated_via_dispatch
     f = Puppet::Functions.create_function('min') do
       dispatch :min do
         param 'Numeric', :x
@@ -568,6 +605,39 @@ actual:
     end
   end
 
+  def create_function_with_repeated
+    f = Puppet::Functions.create_function('count_args') do
+      dispatch :count_args do
+        repeated_param 'Any', :c
+      end
+      def count_args(*c)
+        c.size
+      end
+    end
+  end
+
+  def create_function_with_optional_repeated
+    f = Puppet::Functions.create_function('count_args') do
+      dispatch :count_args do
+        optional_repeated_param 'Any', :c
+      end
+      def count_args(*c)
+        c.size
+      end
+    end
+  end
+
+  def create_function_with_required_repeated
+    f = Puppet::Functions.create_function('count_args') do
+      dispatch :count_args do
+        required_repeated_param 'Any', :c
+      end
+      def count_args(*c)
+        c.size
+      end
+    end
+  end
+
   def create_function_with_inexact_dispatch
     f = Puppet::Functions.create_function('t1') do
       dispatch :t1 do
@@ -598,6 +668,18 @@ actual:
     end
   end
 
+  def create_function_with_rq_repeated_after_opt
+    f = Puppet::Functions.create_function('t1') do
+      dispatch :t1 do
+        optional_param 'Numeric', :x
+        required_repeated_param 'Numeric', :y
+      end
+      def t1(x, *y)
+        x
+      end
+    end
+  end
+
   def create_function_with_param_after_repeated
     f = Puppet::Functions.create_function('t1') do
       dispatch :t1 do
@@ -682,6 +764,19 @@ actual:
     end
   end
 
+  def create_function_with_scope_param_required_repeat
+    f = Puppet::Functions.create_function('test', Puppet::Functions::InternalFunction) do
+      dispatch :test do
+        scope_param
+        param 'Any', :extra
+        repeated_param 'Any', :the_block
+      end
+      def test(scope, *args)
+        [scope, *args]
+      end
+    end
+  end
+
   def create_function_with_required_block_given_type
     f = Puppet::Functions.create_function('test') do
       dispatch :test do

data/spec/unit/indirector/facts/facter_spec.rb

@@ -43,6 +43,13 @@ describe Puppet::Node::Facts::Facter do
       @facter.find(@request)
     end
 
+    it 'should add the puppetversion fact' do
+      reset = sequence 'reset'
+      Facter.expects(:reset).in_sequence(reset)
+      Facter.expects(:add).with(:puppetversion)
+      @facter.find(@request)
+    end
+
     it 'should include external facts when feature is present' do
       reset = sequence 'reset'
       Puppet.features.stubs(:external_facts?).returns true

data/spec/unit/node_spec.rb

@@ -219,6 +219,12 @@ describe Puppet::Node, "when merging facts" do
     expect(@node.parameters["two"]).to eq("b")
   end
 
+  it "warns when a parameter value is not updated" do
+    @node = Puppet::Node.new("testnode", :parameters => {"one" => "a"})
+    Puppet.expects(:warning).with('The node parameter \'one\' for node \'testnode\' was already set to \'a\'. It could not be set to \'b\'')
+    @node.merge "one" => "b"
+  end
+
   it "accepts arbitrary parameters to merge into its parameters" do
     @node = Puppet::Node.new("testnode", :parameters => {"one" => "a"})
     @node.merge "two" => "three"

data/spec/unit/parser/functions/file_spec.rb

@@ -15,7 +15,7 @@ describe "the 'file' function" do
 
   def with_file_content(content)
     path = tmpfile('file-function')
-    file = File.new(path, 'w')
+    file = File.new(path, 'wb')
     file.sync = true
     file.print content
     yield path
@@ -27,6 +27,12 @@ describe "the 'file' function" do
     end
   end
 
+  it "should read a file keeping line endings intact" do
+    with_file_content("file content\r\n") do |name|
+      expect(scope.function_file([name])).to eq("file content\r\n")
+    end
+  end
+
   it "should read a file from a module path" do
     with_file_content('file content') do |name|
       mod = mock 'module'

data/spec/unit/parser/functions/template_spec.rb

@@ -82,7 +82,7 @@ describe "the template function" do
   end
 
   def eval_template(content)
-    File.stubs(:read).with("template").returns(content)
+    Puppet::FileSystem.stubs(:read_preserve_line_endings).with("template").returns(content)
     Puppet::Parser::Files.stubs(:find_template).returns("template")
     scope.function_template(['template'])
   end

data/spec/unit/parser/scope_spec.rb

@@ -192,7 +192,7 @@ describe Puppet::Parser::Scope do
       @scope["var"] = "childval"
       expect {
         @scope["var"] = "change"
-      }.to raise_error(Puppet::Error, "Cannot reassign variable var")
+      }.to raise_error(Puppet::Error, "Cannot reassign variable '$var'")
     end
 
     it "should be able to detect when variables are not set" do
@@ -305,7 +305,7 @@ describe Puppet::Parser::Scope do
         @scope.setvar("var", "1", :append => true)
       }.to raise_error(
         Puppet::ParseError,
-        "Cannot append, variable var is defined in this scope"
+        "Cannot append, variable '$var' is defined in this scope"
       )
     end
 

data/spec/unit/parser/templatewrapper_spec.rb

@@ -94,7 +94,7 @@ describe Puppet::Parser::TemplateWrapper do
     Puppet::Parser::Files.stubs(:find_template).
       with(name, anything()).
       returns(full_name)
-    File.stubs(:read).with(full_name).returns(contents)
+    Puppet::FileSystem.stubs(:read_preserve_line_endings).with(full_name).returns(contents)
 
     full_name
   end

data/spec/unit/pops/evaluator/access_ops_spec.rb

@@ -400,6 +400,25 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
       expect {evaluate(expr)}.to raise_error(/Resource not found: File\['x'\]/)
     end
 
+    # NotUndef Type
+    #
+    it 'produces a NotUndef instance' do
+      type_expr = fqr('NotUndef')
+      expect(evaluate(type_expr)).to eql(Puppet::Pops::Types::TypeFactory.not_undef())
+    end
+
+    it 'produces a NotUndef instance with contained type' do
+      type_expr = fqr('NotUndef')[fqr('Integer')]
+      tf = Puppet::Pops::Types::TypeFactory
+      expect(evaluate(type_expr)).to eql(tf.not_undef(tf.integer))
+    end
+
+    it 'produces a NotUndef instance with String type when given a literal String' do
+      type_expr = fqr('NotUndef')[literal('hey')]
+      tf = Puppet::Pops::Types::TypeFactory
+      expect(evaluate(type_expr)).to eql(tf.not_undef(tf.string('hey')))
+    end
+
     # Type Type
     #
     it 'creates a Type instance when applied to a Type' do

data/spec/unit/pops/evaluator/evaluating_parser_spec.rb

@@ -71,6 +71,9 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "[1,2,3] != [1,2,3]"                              => false,
       "[1,2,3][2]"                                      => 3,
       "[1,2,3] + [4,5]"                                 => [1,2,3,4,5],
+      "[1,2,3, *[4,5]]"                                 => [1,2,3,4,5],
+      "[1,2,3, (*[4,5])]"                               => [1,2,3,4,5],
+      "[1,2,3, ((*[4,5]))]"                             => [1,2,3,4,5],
       "[1,2,3] + [[4,5]]"                               => [1,2,3,[4,5]],
       "[1,2,3] + 4"                                     => [1,2,3,4],
       "[1,2,3] << [4,5]"                                => [1,2,3,[4,5]],
@@ -219,6 +222,8 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "$x = Pattern['a.*'] a =~ $x"     => true,
       "1 =~ Integer"                    => true,
       "1 !~ Integer"                    => false,
+      "undef =~ NotUndef"               => false,
+      "undef !~ NotUndef"               => true,
       "[1,2,3] =~ Array[Integer[1,10]]" => true,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
@@ -300,7 +305,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     {
-      'Any'  => ['Data', 'Scalar', 'Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern', 'Collection',
+      'Any'  => ['NotUndef', 'Data', 'Scalar', 'Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern', 'Collection',
                     'Array', 'Hash', 'CatalogEntry', 'Resource', 'Class', 'Undef', 'File', 'NotYetKnownResourceType'],
 
       # Note, Data > Collection is false (so not included)
@@ -430,18 +435,31 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "$a = 5; $a"                 => 5,
       "$a = 5; $b = 6; $a"         => 5,
       "$a = $b = 5; $a == $b"      => true,
+      "[$a] = 1 $a"                              => 1,
+      "[$a] = [1] $a"                            => 1,
+      "[$a, $b] = [1,2] $a+$b"                   => 3,
+      "[$a, [$b, $c]] = [1,[2, 3]] $a+$b+$c"     => 6,
+      "[$a] = {a => 1} $a"                       => 1,
+      "[$a, $b] = {a=>1,b=>2} $a+$b"             => 3,
+      "[$a, [$b, $c]] = {a=>1,[b,c] =>{b=>2, c=>3}} $a+$b+$c"     => 6,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
         end
       end
 
-    {
-      "[a,b,c] = [1,2,3]"               => /attempt to assign to 'an Array Expression'/,
-      "[a,b,c] = {b=>2,c=>3,a=>1}"      => /attempt to assign to 'an Array Expression'/,
-    }.each do |source, result|
-        it "should parse and evaluate the expression '#{source}' to error with #{result}" do
-          expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(Puppet::ParseError, result)
+    [
+      "[a,b,c] = [1,2,3]",
+      "[a,b,c] = {b=>2,c=>3,a=>1}",
+      "[$a, $b] = 1",
+      "[$a, $b] = [1,2,3]",
+      "[$a, [$b,$c]] = [1,[2]]",
+      "[$a, [$b,$c]] = [1,[2,3,4]]",
+      "[$a, $b] = {a=>1}",
+      "[$a, [$b, $c]] = {a=>1, b =>{b=>2, c=>3}}",
+    ].each do |source|
+        it "should parse and evaluate the expression '#{source}' to error" do
+          expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(Puppet::ParseError)
         end
       end
   end
@@ -456,6 +474,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "unless false {5}"                => 5,
       "unless true {5}"                 => nil,
       "unless true {2} else {5}"        => 5,
+      "unless true {} else {5}"         => 5,
       "$a = if true {5} $a"                     => 5,
       "$a = if false {5} $a"                    => nil,
       "$a = if false {2} else {5} $a"           => 5,
@@ -493,12 +512,31 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "case ringo {
          *[paul, john, ringo, george] : { 'beatle' } }"      => 'beatle',
 
+      "case ringo {
+         (*[paul, john, ringo, george]) : { 'beatle' } }"    => 'beatle',
+
       "case undef {
          undef : { 'yes' } }"                                => 'yes',
 
       "case undef {
          *undef : { 'no' }
          default :{ 'yes' }}"                                => 'yes',
+
+      "case [green, 2, whatever] {
+         [/ee/, Integer[0,10], default] : { 'yes' }
+         default :{ 'no' }}"                                => 'yes',
+
+      "case [green, 2, whatever] {
+         default :{ 'no' }
+         [/ee/, Integer[0,10], default] : { 'yes' }}"        => 'yes',
+
+      "case {a=>1, b=>2, whatever=>3, extra => ignored} {
+         { a => Integer[0,5],
+           b => Integer[0,5],
+           whatever => default
+         }       : { 'yes' }
+         default : { 'no' }}"                               => 'yes',
+
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
@@ -515,8 +553,22 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "'banana' ? { /.*(ana).*/  => $1 }"                 => 'ana',
       "[2] ? { Array[String] => yes, Array => yes}"       => 'yes',
       "ringo ? *[paul, john, ringo, george] => 'beatle'"  => 'beatle',
+      "ringo ? (*[paul, john, ringo, george]) => 'beatle'"=> 'beatle',
       "undef ? undef => 'yes'"                            => 'yes',
       "undef ? {*undef => 'no', default => 'yes'}"        => 'yes',
+
+      "[green, 2, whatever] ? {
+         [/ee/, Integer[0,10], default
+         ]       => 'yes',
+         default => 'no'}"                                => 'yes',
+
+      "{a=>1, b=>2, whatever=>3, extra => ignored} ?
+         {{ a => Integer[0,5],
+           b => Integer[0,5],
+           whatever => default
+         }       => 'yes',
+         default => 'no' }"                               => 'yes',
+
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
@@ -683,6 +735,8 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "'abc'[x]"                    => "The value 'x' cannot be converted to Numeric",
       "'abc'[1.0]"                  => "A String[] cannot use Float where Integer is expected",
       "'abc'[1,2,3]"                => "String supports [] with one or two arguments. Got 3",
+      "NotUndef[0]"                 => 'NotUndef-Type[] argument must be a Type or a String. Got Fixnum',
+      "NotUndef[a,b]"               => 'NotUndef-Type[] accepts 0 to 1 arguments. Got 2',
       "Resource[0]"                 => 'First argument to Resource[] must be a resource type or a String. Got Integer',
       "Resource[a, 0]"              => 'Error creating type specialization of a Resource-Type, Cannot use Integer where a resource title String is expected',
       "File[0]"                     => 'Error creating type specialization of a File-Type, Cannot use Integer where a resource title String is expected',
@@ -884,6 +938,8 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       'sprintf( "x%iy", $a )'                 => "x10y",
       # unfolds
       'sprintf( *["x%iy", $a] )'              => "x10y",
+      '( *["x%iy", $a] ).sprintf'             => "x10y",
+      '((*["x%iy", $a])).sprintf'             => "x10y",
       '"x%iy".sprintf( $a )'                  => "x10y",
       '$b.reduce |$memo,$x| { $memo + $x }'   => 6,
       'reduce($b) |$memo,$x| { $memo + $x }'  => 6,
@@ -1084,7 +1140,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     it "a lex error should be raised for '$foo::::bar'" do
-      expect { parser.evaluate_string(scope, "$foo::::bar") }.to raise_error(Puppet::LexError, /Illegal fully qualified name at line 1:7/)
+      expect { parser.evaluate_string(scope, "$foo::::bar") }.to raise_error(Puppet::ParseErrorWithIssue, /Illegal fully qualified name at line 1:7/)
     end
 
     { '$a = $0'   => nil,
@@ -1215,14 +1271,24 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
 
     it "parses interpolated heredoc expression" do
       src = <<-CODE
-      $name = 'Fjodor'
+      $pname = 'Fjodor'
       @("END")
-      Hello $name
+      Hello $pname
       |- END
       CODE
       expect(parser.evaluate_string(scope, src)).to eq("Hello Fjodor")
     end
 
+    it "parses interpolated heredoc expression with escapes" do
+      src = <<-CODE
+      $name = 'Fjodor'
+      @("END")
+      Hello\\ \\$name
+      |- END
+      CODE
+      expect(parser.evaluate_string(scope, src)).to eq("Hello\\ \\Fjodor")
+    end
+
   end
   context "Handles Deprecations and Discontinuations" do
     it 'of import statements' do
@@ -1251,14 +1317,14 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     it 'for non r-value producing define' do
-      Puppet.expects(:err).with("Invalid use of expression. A 'define' expression does not produce a value at line 1:6")
-      Puppet.expects(:err).with("Classes, definitions, and nodes may only appear at toplevel or inside other classes at line 1:6")
+      Puppet::Util::Log.expects(:create).with(has_entries(:level => :err, :message => "Invalid use of expression. A 'define' expression does not produce a value", :line => 1, :pos => 6))
+      Puppet::Util::Log.expects(:create).with(has_entries(:level => :err, :message => 'Classes, definitions, and nodes may only appear at toplevel or inside other classes', :line => 1, :pos => 6))
       expect { parser.parse_string("$a = define foo { }", nil) }.to raise_error(/2 errors/)
     end
 
     it 'for non r-value producing class' do
-      Puppet.expects(:err).with("Invalid use of expression. A Host Class Definition does not produce a value at line 1:6")
-      Puppet.expects(:err).with("Classes, definitions, and nodes may only appear at toplevel or inside other classes at line 1:6")
+      Puppet::Util::Log.expects(:create).with(has_entries(:level => :err, :message => 'Invalid use of expression. A Host Class Definition does not produce a value', :line => 1, :pos => 6))
+      Puppet::Util::Log.expects(:create).with(has_entries(:level => :err, :message => 'Classes, definitions, and nodes may only appear at toplevel or inside other classes', :line => 1, :pos => 6))
       expect { parser.parse_string("$a = class foo { }", nil) }.to raise_error(/2 errors/)
     end
 
@@ -1272,8 +1338,8 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     it 'for multiple errors with a summary exception' do
-      Puppet.expects(:err).with("Invalid use of expression. A Node Definition does not produce a value at line 1:6")
-      Puppet.expects(:err).with("Classes, definitions, and nodes may only appear at toplevel or inside other classes at line 1:6")
+      Puppet::Util::Log.expects(:create).with(has_entries(:level => :err, :message => 'Invalid use of expression. A Node Definition does not produce a value', :line => 1, :pos => 6))
+      Puppet::Util::Log.expects(:create).with(has_entries(:level => :err, :message => 'Classes, definitions, and nodes may only appear at toplevel or inside other classes', :line => 1, :pos => 6))
       expect { parser.parse_string("$a = node x { }",nil) }.to raise_error(/2 errors/)
     end
 
@@ -1285,8 +1351,8 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
 
     it 'for a hostname with interpolation' do
       source = <<-SOURCE.gsub(/^ {6}/,'')
-      $name = 'fred'
-      node "macbook-owned-by$name" { }
+      $pname = 'fred'
+      node "macbook-owned-by$pname" { }
       SOURCE
       expect {
         parser.parse_string(source, nil)