puppet 7.27.0-x64-mingw32 → 7.29.0-x64-mingw32

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

@@ -1,124 +0,0 @@
-require 'spec_helper'
-
-describe "the generate function" do
-  include PuppetSpec::Files
-
-  let :node     do Puppet::Node.new('localhost') end
-  let :compiler do Puppet::Parser::Compiler.new(node) end
-  let :scope    do Puppet::Parser::Scope.new(compiler) end
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("generate")).to eq("function_generate")
-  end
-
-  it "accept a fully-qualified path as a command" do
-    command = File.expand_path('/command/foo')
-    expect(Dir).to receive(:chdir).with(File.dirname(command)).and_return("yay")
-    expect(scope.function_generate([command])).to eq("yay")
-  end
-
-  it "should not accept a relative path as a command" do
-    expect { scope.function_generate(["command"]) }.to raise_error(Puppet::ParseError)
-  end
-
-  it "should not accept a command containing illegal characters" do
-    expect { scope.function_generate([File.expand_path('/##/command')]) }.to raise_error(Puppet::ParseError)
-  end
-
-  it "should not accept a command containing spaces" do
-    expect { scope.function_generate([File.expand_path('/com mand')]) }.to raise_error(Puppet::ParseError)
-  end
-
-  it "should not accept a command containing '..'", :unless => RUBY_PLATFORM == 'java' do
-    command = File.expand_path("/command/../")
-    expect { scope.function_generate([command]) }.to raise_error(Puppet::ParseError)
-  end
-
-  it "should execute the generate script with the correct working directory" do
-    command = File.expand_path("/command")
-    expect(Dir).to receive(:chdir).with(File.dirname(command)).and_return("yay")
-    expect(scope.function_generate([command])).to eq('yay')
-  end
-
-  describe "on Windows", :if => Puppet::Util::Platform.windows? do
-    it "should accept the tilde in the path" do
-      command = "C:/DOCUME~1/ADMINI~1/foo.bat"
-      expect(Dir).to receive(:chdir).with(File.dirname(command)).and_return("yay")
-      expect(scope.function_generate([command])).to eq('yay')
-    end
-
-    it "should accept lower-case drive letters" do
-      command = 'd:/command/foo'
-      expect(Dir).to receive(:chdir).with(File.dirname(command)).and_return("yay")
-      expect(scope.function_generate([command])).to eq('yay')
-    end
-
-    it "should accept upper-case drive letters" do
-      command = 'D:/command/foo'
-      expect(Dir).to receive(:chdir).with(File.dirname(command)).and_return("yay")
-      expect(scope.function_generate([command])).to eq('yay')
-    end
-
-    it "should accept forward and backslashes in the path" do
-      command = 'D:\command/foo\bar'
-      expect(Dir).to receive(:chdir).with(File.dirname(command)).and_return("yay")
-      expect(scope.function_generate([command])).to eq('yay')
-    end
-
-    it "should reject colons when not part of the drive letter" do
-      expect { scope.function_generate(['C:/com:mand']) }.to raise_error(Puppet::ParseError)
-    end
-
-    it "should reject root drives" do
-      expect { scope.function_generate(['C:/']) }.to raise_error(Puppet::ParseError)
-    end
-  end
-
-  describe "on POSIX", :if => Puppet.features.posix? do
-    it "should reject backslashes" do
-      expect { scope.function_generate(['/com\\mand']) }.to raise_error(Puppet::ParseError)
-    end
-
-    it "should accept plus and dash" do
-      command = "/var/folders/9z/9zXImgchH8CZJh6SgiqS2U+++TM/-Tmp-/foo"
-      expect(Dir).to receive(:chdir).with(File.dirname(command)).and_return("yay")
-      expect(scope.function_generate([command])).to eq('yay')
-    end
-  end
-
-  describe "function_generate", :unless => RUBY_PLATFORM == 'java' do
-    let :command do
-      script_containing('function_generate',
-        :windows => '@echo off' + "\n" + 'echo a-%1 b-%2',
-        :posix   => '#!/bin/sh' + "\n" + 'echo a-$1 b-$2')
-    end
-
-    after :each do
-      File.delete(command) if Puppet::FileSystem.exist?(command)
-    end
-
-    it "returns the output as a String" do
-      expect(scope.function_generate([command]).class).to eq(String)
-    end
-
-    it "should call generator with no arguments" do
-      expect(scope.function_generate([command])).to eq("a- b-\n")
-    end
-
-    it "should call generator with one argument" do
-      expect(scope.function_generate([command, 'one'])).to eq("a-one b-\n")
-    end
-
-    it "should call generator with wo arguments" do
-      expect(scope.function_generate([command, 'one', 'two'])).to eq("a-one b-two\n")
-    end
-
-    it "should fail if generator is not absolute" do
-      expect { scope.function_generate(['boo']) }.to raise_error(Puppet::ParseError)
-    end
-
-    it "should fail if generator fails" do
-      expect { scope.function_generate(['/boo']) }.to raise_error(Puppet::ParseError)
-    end
-  end
-end

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

@@ -1,12 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/scope'
-
-describe 'Puppet::Parser::Functions#hiera_array' do
-  include PuppetSpec::Scope
-
-  let :scope do create_test_scope_for_node('foo') end
-
-  it 'should raise an error since this function is converted to 4x API)' do
-    expect { scope.function_hiera_array(['key']) }.to raise_error(Puppet::ParseError, /can only be called using the 4.x function API/)
-  end
-end

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

@@ -1,12 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/scope'
-
-describe 'Puppet::Parser::Functions#hiera_hash' do
-  include PuppetSpec::Scope
-
-  let :scope do create_test_scope_for_node('foo') end
-
-  it 'should raise an error since this function is converted to 4x API)' do
-    expect { scope.function_hiera_hash(['key']) }.to raise_error(Puppet::ParseError, /can only be called using the 4.x function API/)
-  end
-end

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

@@ -1,12 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/scope'
-
-describe 'Puppet::Parser::Functions#hiera_include' do
-  include PuppetSpec::Scope
-
-  let :scope do create_test_scope_for_node('foo') end
-
-  it 'should raise an error since this function is converted to 4x API)' do
-    expect { scope.function_hiera_include(['key']) }.to raise_error(Puppet::ParseError, /can only be called using the 4.x function API/)
-  end
-end

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

@@ -1,12 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/scope'
-
-describe 'Puppet::Parser::Functions#hiera' do
-  include PuppetSpec::Scope
-
-  let :scope do create_test_scope_for_node('foo') end
-
-  it 'should raise an error since this function is converted to 4x API)' do
-    expect { scope.function_hiera(['key']) }.to raise_error(Puppet::ParseError, /can only be called using the 4.x function API/)
-  end
-end

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

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe "the inline_template function" do
-  let(:node) { Puppet::Node.new('localhost') }
-  let(:compiler) { Puppet::Parser::Compiler.new(node) }
-  let(:scope) { Puppet::Parser::Scope.new(compiler) }
-
-  it "should concatenate template wrapper outputs for multiple templates" do
-    expect(inline_template("template1", "template2")).to eq("template1template2")
-  end
-
-  it "should raise an error if the template raises an error" do
-    expect { inline_template("<% raise 'error' %>") }.to raise_error(Puppet::ParseError)
-  end
-
-  it "is not interfered with by a variable called 'string' (#14093)" do
-    scope['string'] = "this is a variable"
-    expect(inline_template("this is a template")).to eq("this is a template")
-  end
-
-  it "has access to a variable called 'string' (#14093)" do
-    scope['string'] = "this is a variable"
-    expect(inline_template("string was: <%= @string %>")).to eq("string was: this is a variable")
-  end
-
-  it 'is not available when --tasks is on' do
-    Puppet[:tasks] = true
-    expect {
-      inline_template("<%= lookupvar('myvar') %>")
-    }.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)
-  end
-
-  def inline_template(*templates)
-    scope.function_inline_template(templates)
-  end
-end

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

@@ -1,14 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-require 'stringio'
-require 'puppet_spec/scope'
-
-describe "lookup function" do
-  include PuppetSpec::Scope
-
-  let :scope do create_test_scope_for_node('foo') end
-
-  it 'should raise an error since this function is converted to 4x API)' do
-    expect { scope.function_lookup(['key']) }.to raise_error(Puppet::ParseError, /can only be called using the 4.x function API/)
-  end
-end

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

@@ -1,70 +0,0 @@
-require 'spec_helper'
-require 'matchers/resource'
-require 'puppet_spec/compiler'
-
-describe "the realize function" do
-  include Matchers::Resource
-  include PuppetSpec::Compiler
-
-  it "realizes a single, referenced resource" do
-    catalog = compile_to_catalog(<<-EOM)
-      @notify { testing: }
-      realize(Notify[testing])
-    EOM
-
-    expect(catalog).to have_resource("Notify[testing]")
-  end
-
-  it "realizes multiple resources" do
-    catalog = compile_to_catalog(<<-EOM)
-      @notify { testing: }
-      @notify { other: }
-      realize(Notify[testing], Notify[other])
-    EOM
-
-    expect(catalog).to have_resource("Notify[testing]")
-    expect(catalog).to have_resource("Notify[other]")
-  end
-
-  it "realizes resources provided in arrays" do
-    catalog = compile_to_catalog(<<-EOM)
-      @notify { testing: }
-      @notify { other: }
-      realize([Notify[testing], [Notify[other]]])
-    EOM
-
-    expect(catalog).to have_resource("Notify[testing]")
-    expect(catalog).to have_resource("Notify[other]")
-  end
-
-  it "fails when the resource does not exist" do
-    expect do
-      compile_to_catalog(<<-EOM)
-        realize(Notify[missing])
-      EOM
-    end.to raise_error(Puppet::Error, /Failed to realize/)
-  end
-
-  it "fails when no parameters given" do
-    expect do
-      compile_to_catalog(<<-EOM)
-        realize()
-      EOM
-    end.to raise_error(Puppet::Error, /Wrong number of arguments/)
-  end
-
-  it "silently does nothing when an empty array of resources is given" do
-    compile_to_catalog(<<-EOM)
-      realize([])
-    EOM
-  end
-
-  it 'is not available when --tasks is on' do
-    Puppet[:tasks] = true
-    expect do
-      compile_to_catalog(<<-MANIFEST)
-        realize([])
-      MANIFEST
-    end.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)
-  end
-end

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

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe "the regsubst function" do
-  before :each do
-    node     = Puppet::Node.new('localhost')
-    compiler = Puppet::Parser::Compiler.new(node)
-    @scope   = Puppet::Parser::Scope.new(compiler)
-  end
-
-  it 'should raise an ParseError' do
-    expect do
-      @scope.function_regsubst(
-      [ 'the monkey breaks banana trees',
-        'b[an]*a',
-        'coconut'
-      ])
-    end.to raise_error(Puppet::ParseError, /can only be called using the 4.x function API/)
-  end
-end

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

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-describe "the scanf function" do
-  let(:node) { Puppet::Node.new('localhost') }
-  let(:compiler) { Puppet::Parser::Compiler.new(node) }
-  let(:scope) { Puppet::Parser::Scope.new(compiler) }
-
-  it 'scans a value and returns an array' do
-    expect(scope.function_scanf(['42', '%i'])[0] == 42)
-  end
-
-  it 'returns empty array if nothing was scanned' do
-    expect(scope.function_scanf(['no', '%i']) == [])
-  end
-
-  it 'produces result up to first unsuccessful scan' do
-    expect(scope.function_scanf(['42 no', '%i'])[0] == 42)
-  end
-
-  it 'errors when not given enough arguments' do
-    expect do
-      scope.function_scanf(['42'])
-    end.to raise_error(/.*scanf\(\): Wrong number of arguments given/m)
-  end
-end

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

@@ -1,66 +0,0 @@
-require 'spec_helper'
-
-describe "the shellquote function" do
-  let :node     do Puppet::Node.new('localhost') end
-  let :compiler do Puppet::Parser::Compiler.new(node) end
-  let :scope    do Puppet::Parser::Scope.new(compiler) end
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("shellquote")).to eq("function_shellquote")
-  end
-
-  it "should handle no arguments" do
-    expect(scope.function_shellquote([])).to eq("")
-  end
-
-  it "should handle several simple arguments" do
-    expect(scope.function_shellquote(
-      ['foo', 'bar@example.com', 'localhost:/dev/null', 'xyzzy+-4711,23']
-    )).to eq('foo bar@example.com localhost:/dev/null xyzzy+-4711,23')
-  end
-
-  it "should handle array arguments" do
-    expect(scope.function_shellquote(
-      ['foo', ['bar@example.com', 'localhost:/dev/null'],
-      'xyzzy+-4711,23']
-    )).to eq('foo bar@example.com localhost:/dev/null xyzzy+-4711,23')
-  end
-
-  it "should quote unsafe characters" do
-    expect(scope.function_shellquote(['/etc/passwd ', '(ls)', '*', '[?]', "'&'"])).
-      to eq('"/etc/passwd " "(ls)" "*" "[?]" "\'&\'"')
-  end
-
-  it "should deal with double quotes" do
-    expect(scope.function_shellquote(['"foo"bar"'])).to eq('\'"foo"bar"\'')
-  end
-
-  it "should cope with dollar signs" do
-    expect(scope.function_shellquote(['$PATH', 'foo$bar', '"x$"'])).
-      to eq("'$PATH' 'foo$bar' '\"x$\"'")
-  end
-
-  it "should deal with apostrophes (single quotes)" do
-    expect(scope.function_shellquote(["'foo'bar'", "`$'EDITOR'`"])).
-      to eq('"\'foo\'bar\'" "\\`\\$\'EDITOR\'\\`"')
-  end
-
-  it "should cope with grave accents (backquotes)" do
-    expect(scope.function_shellquote(['`echo *`', '`ls "$MAILPATH"`'])).
-      to eq("'`echo *`' '`ls \"$MAILPATH\"`'")
-  end
-
-  it "should deal with both single and double quotes" do
-    expect(scope.function_shellquote(['\'foo"bar"xyzzy\'', '"foo\'bar\'xyzzy"'])).
-      to eq('"\'foo\\"bar\\"xyzzy\'" "\\"foo\'bar\'xyzzy\\""')
-  end
-
-  it "should handle multiple quotes *and* dollars and backquotes" do
-    expect(scope.function_shellquote(['\'foo"$x`bar`"xyzzy\''])).
-      to eq('"\'foo\\"\\$x\\`bar\\`\\"xyzzy\'"')
-  end
-
-  it "should handle linefeeds" do
-    expect(scope.function_shellquote(["foo \n bar"])).to eq("\"foo \n bar\"")
-  end
-end

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

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-describe "the split function" do
-  before :each do
-    node     = Puppet::Node.new('localhost')
-    compiler = Puppet::Parser::Compiler.new(node)
-    @scope   = Puppet::Parser::Scope.new(compiler)
-  end
-
-  it 'should raise a ParseError' do
-    expect { @scope.function_split([ '130;236;254;10', ';']) }.to raise_error(Puppet::ParseError, /can only be called using the 4.x function API/)
-  end
-end

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

@@ -1,68 +0,0 @@
-require 'spec_helper'
-
-describe "the sprintf function" do
-  before :each do
-    node     = Puppet::Node.new('localhost')
-    compiler = Puppet::Parser::Compiler.new(node)
-    @scope   = Puppet::Parser::Scope.new(compiler)
-  end
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("sprintf")).to eq("function_sprintf")
-  end
-
-  it "should raise an ArgumentError if there is less than 1 argument" do
-    expect { @scope.function_sprintf([]) }.to( raise_error(ArgumentError))
-  end
-
-  it "should format integers" do
-    result = @scope.function_sprintf(["%+05d", "23"])
-    expect(result).to(eql("+0023"))
-  end
-
-  it "should format floats" do
-    result = @scope.function_sprintf(["%+.2f", "2.7182818284590451"])
-    expect(result).to(eql("+2.72"))
-  end
-
-  it "should format large floats" do
-    result = @scope.function_sprintf(["%+.2e", "27182818284590451"])
-    str =
-      "+2.72e+16"
-    expect(result).to(eql(str))
-  end
-
-  it "should perform more complex formatting" do
-    result = @scope.function_sprintf(
-      [ "<%.8s:%#5o %#8X (%-8s)>",
-        "overlongstring", "23", "48879", "foo" ])
-    expect(result).to(eql("<overlong:  027   0XBEEF (foo     )>"))
-  end
-
-  it 'does not attempt to mutate its arguments' do
-    args = ['%d', 1].freeze
-    expect { @scope.function_sprintf(args) }.to_not raise_error
-  end
-
-  it 'support named arguments in a hash with string keys' do
-    result = @scope.function_sprintf(["%<foo>d : %<bar>f", {'foo' => 1, 'bar' => 2}])
-    expect(result).to eq("1 : 2.000000")
-  end
-
-  it 'raises a key error if a key is not present' do
-    expect do
-      @scope.function_sprintf(["%<foo>d : %<zanzibar>f", {'foo' => 1, 'bar' => 2}])
-    end.to raise_error(KeyError, /key<zanzibar> not found/)
-  end
-
-  it 'a hash with string keys that is output formats as strings' do
-    result = @scope.function_sprintf(["%s", {'foo' => 1, 'bar' => 2}])
-    expect(result).to eq("{\"foo\"=>1, \"bar\"=>2}")
-  end
-
-  it 'named arguments hash with non string keys are tolerated' do
-    result = @scope.function_sprintf(["%<foo>d : %<bar>f", {'foo' => 1, 'bar' => 2, 1 => 2, [1] => 2, false => true, {} => {}}])
-    expect(result).to eq("1 : 2.000000")
-  end
-
-end

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

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-describe "the 'tag' function" do
-  before :each do
-    node     = Puppet::Node.new('localhost')
-    compiler = Puppet::Parser::Compiler.new(node)
-    @scope   = Puppet::Parser::Scope.new(compiler)
-  end
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function(:tag)).to eq("function_tag")
-  end
-
-  it "should tag the resource with any provided tags" do
-    resource = Puppet::Parser::Resource.new(:file, "/file", :scope => @scope)
-    expect(@scope).to receive(:resource).and_return(resource)
-
-    @scope.function_tag ["one", "two"]
-
-    expect(resource).to be_tagged("one")
-    expect(resource).to be_tagged("two")
-  end
-
-  it 'is not available when --tasks is on' do
-    Puppet[:tasks] = true
-    expect do
-      @scope.function_tag(['one', 'two'])
-    end.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)
-  end
-end

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

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe "the 'tagged' function" do
-  before :each do
-    node     = Puppet::Node.new('localhost')
-    compiler = Puppet::Parser::Compiler.new(node)
-    @scope   = Puppet::Parser::Scope.new(compiler)
-  end
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function(:tagged)).to eq("function_tagged")
-  end
-
-  it 'is not available when --tasks is on' do
-    Puppet[:tasks] = true
-    expect do
-      @scope.function_tagged(['one', 'two'])
-    end.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)
-  end
-
-  it 'should be case-insensitive' do
-    resource = Puppet::Parser::Resource.new(:file, "/file", :scope => @scope)
-    allow(@scope).to receive(:resource).and_return(resource)
-    @scope.function_tag ["one"]
-
-    expect(@scope.function_tagged(['One'])).to eq(true)
-  end
-
-  it 'should check if all specified tags are included' do
-    resource = Puppet::Parser::Resource.new(:file, "/file", :scope => @scope)
-    allow(@scope).to receive(:resource).and_return(resource)
-    @scope.function_tag ["one"]
-
-    expect(@scope.function_tagged(['one', 'two'])).to eq(false)
-  end
-end

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

@@ -1,93 +0,0 @@
-require 'spec_helper'
-
-describe "the template function" do
-  let :node     do Puppet::Node.new('localhost') end
-  let :compiler do Puppet::Parser::Compiler.new(node) end
-  let :scope    do Puppet::Parser::Scope.new(compiler) end
-
-  it "concatenates outputs for multiple templates" do
-    tw1 = double("template_wrapper1")
-    tw2 = double("template_wrapper2")
-    allow(Puppet::Parser::TemplateWrapper).to receive(:new).and_return(tw1,tw2)
-    allow(tw1).to receive(:file=).with("1")
-    allow(tw2).to receive(:file=).with("2")
-    allow(tw1).to receive(:result).and_return("result1")
-    allow(tw2).to receive(:result).and_return("result2")
-
-    expect(scope.function_template(["1","2"])).to eq("result1result2")
-  end
-
-  it "raises an error if the template raises an error" do
-    tw = double('template_wrapper')
-    allow(tw).to receive(:file=).with("1")
-    allow(Puppet::Parser::TemplateWrapper).to receive(:new).and_return(tw)
-    allow(tw).to receive(:result).and_raise
-
-    expect {
-      scope.function_template(["1"])
-    }.to raise_error(Puppet::ParseError, /Failed to parse template/)
-  end
-
-  context "when accessing scope variables via method calls (deprecated)" do
-    it "raises an error when accessing an undefined variable" do
-      expect {
-        eval_template("template <%= deprecated %>")
-      }.to raise_error(Puppet::ParseError, /undefined local variable or method `deprecated'/)
-    end
-
-    it "looks up the value from the scope" do
-      scope["deprecated"] = "deprecated value"
-      expect { eval_template("template <%= deprecated %>")}.to raise_error(/undefined local variable or method `deprecated'/)
-    end
-
-    it "still has access to Kernel methods" do
-      expect { eval_template("<%= binding %>") }.to_not raise_error
-    end
-  end
-
-  context "when accessing scope variables as instance variables" do
-    it "has access to values" do
-      scope['scope_var'] = "value"
-      expect(eval_template("<%= @scope_var %>")).to eq("value")
-    end
-
-    it "get nil accessing a variable that does not exist" do
-      expect(eval_template("<%= @not_defined.nil? %>")).to eq("true")
-    end
-
-    it "get nil accessing a variable that is undef" do
-      scope['undef_var'] = :undef
-      expect(eval_template("<%= @undef_var.nil? %>")).to eq("true")
-    end
-  end
-
-  it "is not interfered with by having a variable named 'string' (#14093)" do
-    scope['string'] = "this output should not be seen"
-    expect(eval_template("some text that is static")).to eq("some text that is static")
-  end
-
-  it "has access to a variable named 'string' (#14093)" do
-    scope['string'] = "the string value"
-    expect(eval_template("string was: <%= @string %>")).to eq("string was: the string value")
-  end
-
-  it "does not have direct access to Scope#lookupvar" do
-    expect {
-      eval_template("<%= lookupvar('myvar') %>")
-    }.to raise_error(Puppet::ParseError, /undefined method `lookupvar'/)
-  end
-
-  it 'is not available when --tasks is on' do
-    Puppet[:tasks] = true
-    expect {
-      eval_template("<%= lookupvar('myvar') %>")
-    }.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)
-
-  end
-
-  def eval_template(content)
-    allow(Puppet::FileSystem).to receive(:read_preserve_line_endings).with("template").and_return(content)
-    allow(Puppet::Parser::Files).to receive(:find_template).and_return("template")
-    scope.function_template(['template'])
-  end
-end