puppet 8.4.0-x64-mingw32 → 8.5.1-x64-mingw32

data/spec/unit/pops/loaders/module_loaders_spec.rb

@@ -1,268 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/files'
-require 'puppet/pops'
-require 'puppet/loaders'
-require 'puppet_spec/compiler'
-
-describe 'FileBased module loader' do
-  include PuppetSpec::Files
-
-  let(:static_loader) { Puppet::Pops::Loader::StaticLoader.new() }
-  let(:loaders) { Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, [])) }
-
-  it 'can load a 4x function API ruby function in global name space' do
-    module_dir = dir_containing('testmodule', {
-      'lib' => {
-        'puppet' => {
-          'functions' => {
-            'foo4x.rb' => <<-CODE
-               Puppet::Functions.create_function(:foo4x) do
-                 def foo4x()
-                   'yay'
-                 end
-               end
-            CODE
-          }
-            }
-          }
-        })
-
-    module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, loaders, 'testmodule', module_dir)
-    function = module_loader.load_typed(typed_name(:function, 'foo4x')).value
-
-    expect(function.class.name).to eq('foo4x')
-    expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
-  end
-
-  it 'can load a 4x function API ruby function in qualified name space' do
-    module_dir = dir_containing('testmodule', {
-      'lib' => {
-        'puppet' => {
-          'functions' => {
-            'testmodule' => {
-              'foo4x.rb' => <<-CODE
-                 Puppet::Functions.create_function('testmodule::foo4x') do
-                   def foo4x()
-                     'yay'
-                   end
-                 end
-              CODE
-              }
-            }
-          }
-      }})
-
-    module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, loaders, 'testmodule', module_dir)
-    function = module_loader.load_typed(typed_name(:function, 'testmodule::foo4x')).value
-    expect(function.class.name).to eq('testmodule::foo4x')
-    expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
-  end
-
-  it 'system loader has itself as private loader' do
-    module_loader = loaders.puppet_system_loader
-    expect(module_loader.private_loader).to be(module_loader)
-  end
-
-  it 'makes parent loader win over entries in child' do
-    module_dir = dir_containing('testmodule', {
-      'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {
-        'foo.rb' => <<-CODE
-           Puppet::Functions.create_function('testmodule::foo') do
-             def foo()
-               'yay'
-             end
-           end
-        CODE
-      }}}}})
-    module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, loaders, 'testmodule', module_dir)
-
-    module_dir2 = dir_containing('testmodule2', {
-      'lib' => { 'puppet' => { 'functions' => { 'testmodule2' => {
-        'foo.rb' => <<-CODE
-           raise "should not get here"
-        CODE
-      }}}}})
-    module_loader2 = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(module_loader, loaders, 'testmodule2', module_dir2, 'test2')
-
-    function = module_loader2.load_typed(typed_name(:function, 'testmodule::foo')).value
-
-    expect(function.class.name).to eq('testmodule::foo')
-    expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
-  end
-
-  context 'loading tasks' do
-    before(:each) do
-      Puppet[:tasks] = true
-      Puppet.push_context(:loaders => loaders)
-    end
-    after(:each) { Puppet.pop_context }
-
-    it 'can load tasks with multiple files' do
-      module_dir = dir_containing('testmodule', 'tasks' => {'foo.py' => '', 'foo.json' => '{}'})
-
-      module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, loaders, 'testmodule', module_dir)
-
-      task = module_loader.load_typed(typed_name(:task, 'testmodule::foo')).value
-      expect(task.name).to eq('testmodule::foo')
-      expect(task.files.length).to eq(1)
-      expect(task.files[0]['name']).to eq('foo.py')
-    end
-
-    it 'can load tasks with multiple implementations' do
-      metadata = { 'implementations' => [{'name' => 'foo.py'}, {'name' => 'foo.ps1'}] }
-      module_dir = dir_containing('testmodule', 'tasks' => {'foo.py' => '', 'foo.ps1' => '', 'foo.json' => metadata.to_json})
-
-      module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, loaders, 'testmodule', module_dir)
-
-      task = module_loader.load_typed(typed_name(:task, 'testmodule::foo')).value
-      expect(task.name).to eq('testmodule::foo')
-      expect(task.files.map {|impl| impl['name']}).to eq(['foo.py', 'foo.ps1'])
-    end
-
-    it 'can load multiple tasks with multiple files' do
-      module_dir = dir_containing('testmodule', 'tasks' => {'foo.py' => '', 'foo.json' => '{}', 'foobar.py' => '', 'foobar.json' => '{}'})
-
-      module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, loaders, 'testmodule', module_dir)
-
-      foo_task = module_loader.load_typed(typed_name(:task, 'testmodule::foo')).value
-      foobar_task = module_loader.load_typed(typed_name(:task, 'testmodule::foobar')).value
-
-      expect(foo_task.name).to eq('testmodule::foo')
-      expect(foo_task.files.length).to eq(1)
-      expect(foo_task.files[0]['name']).to eq('foo.py')
-      expect(foobar_task.name).to eq('testmodule::foobar')
-      expect(foobar_task.files.length).to eq(1)
-      expect(foobar_task.files[0]['name']).to eq('foobar.py')
-    end
-
-    it "won't load tasks with invalid names" do
-      module_dir = dir_containing('testmodule', 'tasks' => {'a-b.py' => '', 'foo.tar.gz' => ''})
-
-      module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, loaders, 'testmodule', module_dir)
-
-      tasks = module_loader.discover(:task)
-      expect(tasks).to be_empty
-
-      expect(module_loader.load_typed(typed_name(:task, 'testmodule::foo'))).to be_nil
-    end
-
-    it "lists tasks without executables, if they specify implementations" do
-      module_dir = dir_containing('testmodule', 'tasks' => {'foo.py' => '',
-                                                            'bar.rb' => '',
-                                                            'baz.json' => {'implementations' => ['name' => 'foo.py']}.to_json,
-                                                            'qux.json' => '{}'})
-
-      module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, loaders, 'testmodule', module_dir)
-
-      tasks = module_loader.discover(:task)
-      expect(tasks.length).to eq(3)
-      expect(tasks.map(&:name).sort).to eq(['testmodule::bar', 'testmodule::baz', 'testmodule::foo'])
-
-      expect(module_loader.load_typed(typed_name(:task, 'testmodule::foo'))).not_to be_nil
-      expect(module_loader.load_typed(typed_name(:task, 'testmodule::bar'))).not_to be_nil
-      expect(module_loader.load_typed(typed_name(:task, 'testmodule::baz'))).not_to be_nil
-      expect { module_loader.load_typed(typed_name(:task, 'testmodule::qux')) }.to raise_error(/No source besides task metadata was found/)
-    end
-
-    it 'raises and error when `parameters` is not a hash' do
-      metadata = { 'parameters' => 'foo' }
-      module_dir = dir_containing('testmodule', 'tasks' => {'foo.py' => '', 'foo.json' => metadata.to_json})
-
-      module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, loaders, 'testmodule', module_dir)
-      expect{module_loader.load_typed(typed_name(:task, 'testmodule::foo'))}
-        .to raise_error(Puppet::ParseError, /Failed to load metadata for task testmodule::foo: 'parameters' must be a hash/)
-    end
-
-    it 'raises and error when `implementations` `requirements` key is not an array' do
-      metadata = { 'implementations' => { 'name' => 'foo.py', 'requirements' => 'foo'} }
-      module_dir = dir_containing('testmodule', 'tasks' => {'foo.py' => '', 'foo.json' => metadata.to_json})
-
-      module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, loaders, 'testmodule', module_dir)
-      expect{module_loader.load_typed(typed_name(:task, 'testmodule::foo'))}
-        .to raise_error(Puppet::Module::Task::InvalidMetadata,
-        /Task metadata for task testmodule::foo does not specify implementations as an array/)
-    end
-
-    it 'raises and error when top-level `files` is not an array' do
-      metadata = { 'files' => 'foo' }
-      module_dir = dir_containing('testmodule', 'tasks' => {'foo.py' => '', 'foo.json' => metadata.to_json})
-
-      module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, loaders, 'testmodule', module_dir)
-      expect{module_loader.load_typed(typed_name(:task, 'testmodule::foo'))}
-        .to raise_error(Puppet::Module::Task::InvalidMetadata, /The 'files' task metadata expects an array, got foo/)
-    end
-
-    it 'raises and error when `files` nested in `interpreters` is not an array' do
-      metadata = { 'implementations' => [{'name' => 'foo.py', 'files' => 'foo'}] }
-      module_dir = dir_containing('testmodule', 'tasks' => {'foo.py' => '', 'foo.json' => metadata.to_json})
-
-      module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, loaders, 'testmodule', module_dir)
-      expect{module_loader.load_typed(typed_name(:task, 'testmodule::foo'))}
-        .to raise_error(Puppet::Module::Task::InvalidMetadata, /The 'files' task metadata expects an array, got foo/)
-    end
-  end
-
-  def typed_name(type, name)
-    Puppet::Pops::Loader::TypedName.new(type, name)
-  end
-
-  context 'module function and class using a module type alias' do
-    include PuppetSpec::Compiler
-
-    let(:modules) do
-      {
-        'mod' => {
-          'functions' => {
-            'afunc.pp' => <<-PUPPET.unindent
-              function mod::afunc(Mod::Analias $v) {
-                notice($v)
-              }
-          PUPPET
-          },
-          'types' => {
-            'analias.pp' => <<-PUPPET.unindent
-               type Mod::Analias = Enum[a,b]
-               PUPPET
-          },
-          'manifests' => {
-            'init.pp' => <<-PUPPET.unindent
-              class mod(Mod::Analias $v) {
-                notify { $v: }
-              }
-              PUPPET
-          }
-        }
-      }
-    end
-
-    let(:testing_env) do
-      {
-        'testing' => {
-          'modules' => modules
-        }
-      }
-    end
-
-    let(:environments_dir) { Puppet[:environmentpath] }
-
-    let(:testing_env_dir) do
-      dir_contained_in(environments_dir, testing_env)
-      env_dir = File.join(environments_dir, 'testing')
-      PuppetSpec::Files.record_tmp(env_dir)
-      env_dir
-    end
-
-    let(:env) { Puppet::Node::Environment.create(:testing, [File.join(testing_env_dir, 'modules')]) }
-    let(:node) { Puppet::Node.new('test', :environment => env) }
-
-    # The call to mod:afunc will load the function, and as a consequence, make an attempt to load
-    # the parameter type Mod::Analias. That load in turn, will trigger the Runtime3TypeLoader which
-    # will load the manifests in Mod. The init.pp manifest also references the Mod::Analias parameter
-    # which results in a recursive call to the same loader. This test asserts that this recursive
-    # call is handled OK.
-    # See PUP-7391 for more info.
-    it 'should handle a recursive load' do
-      expect(eval_and_collect_notices("mod::afunc('b')", node)).to eql(['b'])
-    end
-  end
-end

data/spec/unit/pops/loaders/static_loader_spec.rb

@@ -1,85 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-require 'puppet/loaders'
-
-describe 'the static loader' do
-  let(:loader) do
-    loader = Puppet::Pops::Loader::StaticLoader.new()
-    loader.runtime_3_init
-    loader
-  end
-
-  it 'has no parent' do
-    expect(loader.parent).to be(nil)
-  end
-
-  it 'identifies itself in string form' do
-    expect(loader.to_s).to be_eql('(StaticLoader)')
-  end
-
-  it 'support the Loader API' do
-    # it may produce things later, this is just to test that calls work as they should - now all lookups are nil.
-    a_typed_name = typed_name(:function, 'foo')
-    expect(loader[a_typed_name]).to be(nil)
-    expect(loader.load_typed(a_typed_name)).to be(nil)
-    expect(loader.find(a_typed_name)).to be(nil)
-  end
-
-  context 'provides access to resource types built into puppet' do
-    %w{
-      Component
-      Exec
-      File
-      Filebucket
-      Group
-      Notify
-      Package
-      Resources
-      Schedule
-      Service
-      Stage
-      Tidy
-      User
-      Whit
-    }.each do |name |
-      it "such that #{name} is available" do
-        expect(loader.load(:type, name.downcase)).to be_the_type(resource_type(name))
-      end
-    end
-  end
-
-  context 'provides access to app-management specific resource types built into puppet' do
-    it "such that Node is available" do
-      expect(loader.load(:type, 'node')).to be_the_type(resource_type('Node'))
-    end
-  end
-
-  context 'without init_runtime3 initialization' do
-    let(:loader) { Puppet::Pops::Loader::StaticLoader.new() }
-
-    it 'does not provide access to resource types built into puppet' do
-      expect(loader.load(:type, 'file')).to be_nil
-    end
-  end
-
-  def typed_name(type, name)
-    Puppet::Pops::Loader::TypedName.new(type, name)
-  end
-
-  def resource_type(name)
-    Puppet::Pops::Types::TypeFactory.resource(name)
-  end
-
-  matcher :be_the_type do |type|
-    calc = Puppet::Pops::Types::TypeCalculator.new
-
-    match do |actual|
-      calc.assignable?(actual, type) && calc.assignable?(type, actual)
-    end
-
-    failure_message do |actual|
-      "expected #{type.to_s}, but was #{actual.to_s}"
-    end
-  end
-
-end

data/spec/unit/pops/lookup/context_spec.rb

@@ -1,333 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/files'
-require 'puppet_spec/compiler'
-
-module Puppet::Pops
-module Lookup
-describe 'Puppet::Pops::Lookup::Context' do
-
-  context 'an instance' do
-    include PuppetSpec::Compiler
-    it 'can be created' do
-      code = "notice(type(Puppet::LookupContext.new('m')))"
-      expect(eval_and_collect_notices(code)[0]).to match(/Object\[\{name => 'Puppet::LookupContext'/)
-    end
-
-    it 'returns its environment_name' do
-      code = "notice(Puppet::LookupContext.new('m').environment_name)"
-      expect(eval_and_collect_notices(code)[0]).to eql('production')
-    end
-
-    it 'returns its module_name' do
-      code = "notice(Puppet::LookupContext.new('m').module_name)"
-      expect(eval_and_collect_notices(code)[0]).to eql('m')
-    end
-
-    it 'can use an undef module_name' do
-      code = "notice(type(Puppet::LookupContext.new(undef).module_name))"
-      expect(eval_and_collect_notices(code)[0]).to eql('Undef')
-    end
-
-    it 'can store and retrieve a value using the cache' do
-      code = <<-PUPPET.unindent
-        $ctx = Puppet::LookupContext.new('m')
-        $ctx.cache('ze_key', 'ze_value')
-        notice($ctx.cached_value('ze_key'))
-      PUPPET
-      expect(eval_and_collect_notices(code)[0]).to eql('ze_value')
-    end
-
-    it 'the cache method returns the value that is cached' do
-      code = <<-PUPPET.unindent
-        $ctx = Puppet::LookupContext.new('m')
-        notice($ctx.cache('ze_key', 'ze_value'))
-      PUPPET
-      expect(eval_and_collect_notices(code)[0]).to eql('ze_value')
-    end
-
-    it 'can store and retrieve a hash using the cache' do
-      code = <<-PUPPET.unindent
-        $ctx = Puppet::LookupContext.new('m')
-        $ctx.cache_all({ 'v1' => 'first', 'v2' => 'second' })
-        $ctx.cached_entries |$key, $value| { notice($key); notice($value) }
-      PUPPET
-      expect(eval_and_collect_notices(code)).to eql(%w(v1 first v2 second))
-    end
-
-    it 'can use the cache to merge hashes' do
-      code = <<-PUPPET.unindent
-        $ctx = Puppet::LookupContext.new('m')
-        $ctx.cache_all({ 'v1' => 'first', 'v2' => 'second' })
-        $ctx.cache_all({ 'v3' => 'third', 'v4' => 'fourth' })
-        $ctx.cached_entries |$key, $value| { notice($key); notice($value) }
-      PUPPET
-      expect(eval_and_collect_notices(code)).to eql(%w(v1 first v2 second v3 third v4 fourth))
-    end
-
-    it 'can use the cache to merge hashes and individual entries' do
-      code = <<-PUPPET.unindent
-        $ctx = Puppet::LookupContext.new('m')
-        $ctx.cache_all({ 'v1' => 'first', 'v2' => 'second' })
-        $ctx.cache('v3', 'third')
-        $ctx.cached_entries |$key, $value| { notice($key); notice($value) }
-      PUPPET
-      expect(eval_and_collect_notices(code)).to eql(%w(v1 first v2 second v3 third))
-    end
-
-    it 'can iterate the cache using one argument block' do
-      code = <<-PUPPET.unindent
-        $ctx = Puppet::LookupContext.new('m')
-        $ctx.cache_all({ 'v1' => 'first', 'v2' => 'second' })
-        $ctx.cached_entries |$entry| { notice($entry[0]); notice($entry[1]) }
-      PUPPET
-      expect(eval_and_collect_notices(code)).to eql(%w(v1 first v2 second))
-    end
-
-    it 'can replace individual cached entries' do
-      code = <<-PUPPET.unindent
-        $ctx = Puppet::LookupContext.new('m')
-        $ctx.cache_all({ 'v1' => 'first', 'v2' => 'second' })
-        $ctx.cache('v2', 'changed')
-        $ctx.cached_entries |$key, $value| { notice($key); notice($value) }
-      PUPPET
-      expect(eval_and_collect_notices(code)).to eql(%w(v1 first v2 changed))
-    end
-
-    it 'can replace multiple cached entries' do
-      code = <<-PUPPET.unindent
-        $ctx = Puppet::LookupContext.new('m')
-        $ctx.cache_all({ 'v1' => 'first', 'v2' => 'second', 'v3' => 'third' })
-        $ctx.cache_all({ 'v1' => 'one', 'v3' => 'three' })
-        $ctx.cached_entries |$key, $value| { notice($key); notice($value) }
-      PUPPET
-      expect(eval_and_collect_notices(code)).to eql(%w(v1 one v2 second v3 three))
-    end
-
-    it 'cached_entries returns an Iterable when called without a block' do
-      code = <<-PUPPET.unindent
-        $ctx = Puppet::LookupContext.new('m')
-        $ctx.cache_all({ 'v1' => 'first', 'v2' => 'second' })
-        $iter = $ctx.cached_entries
-        notice(type($iter, generalized))
-        $iter.each |$entry| { notice($entry[0]); notice($entry[1]) }
-      PUPPET
-      expect(eval_and_collect_notices(code)).to eql(['Iterator[Tuple[String, String, 2, 2]]', 'v1', 'first', 'v2', 'second'])
-    end
-
-    it 'will throw :no_such_key when not_found is called' do
-      code = <<-PUPPET.unindent
-        $ctx = Puppet::LookupContext.new('m')
-        $ctx.not_found
-      PUPPET
-      expect { eval_and_collect_notices(code) }.to throw_symbol(:no_such_key)
-    end
-
-    context 'with cached_file_data' do
-      include PuppetSpec::Files
-
-      let(:code_dir) { Puppet[:environmentpath] }
-      let(:env_name) { 'testing' }
-      let(:env_dir) { File.join(code_dir, env_name) }
-      let(:env) { Puppet::Node::Environment.create(env_name.to_sym, [File.join(populated_env_dir, 'modules')]) }
-      let(:node) { Puppet::Node.new('test', :environment => env) }
-      let(:data_yaml) { 'data.yaml' }
-      let(:data_path) { File.join(populated_env_dir, 'data', data_yaml) }
-      let(:populated_env_dir) do
-        dir_contained_in(code_dir,
-          {
-            env_name => {
-              'data' => {
-                data_yaml => <<-YAML.unindent
-                  a: value a
-                  YAML
-              }
-            }
-          }
-        )
-        PuppetSpec::Files.record_tmp(File.join(env_dir))
-        env_dir
-      end
-
-      it 'can use cached_file_data without a block' do
-        code = <<-PUPPET.unindent
-          $ctx = Puppet::LookupContext.new(nil)
-          $yaml_data = $ctx.cached_file_data('#{data_path}')
-          notice($yaml_data)
-        PUPPET
-        expect(eval_and_collect_notices(code, node)).to eql(["a: value a\n"])
-      end
-
-      it 'can use cached_file_data with a block' do
-        code = <<-PUPPET.unindent
-          $ctx = Puppet::LookupContext.new(nil)
-          $yaml_data = $ctx.cached_file_data('#{data_path}') |$content| {
-            { 'parsed' => $content }
-          }
-          notice($yaml_data)
-        PUPPET
-        expect(eval_and_collect_notices(code, node)).to eql(["{parsed => a: value a\n}"])
-      end
-
-      context 'and multiple compilations' do
-
-        before(:each) { Puppet.settings[:environment_timeout] = 'unlimited' }
-
-        it 'will reuse cached_file_data and not call block again' do
-
-          code1 = <<-PUPPET.unindent
-            $ctx = Puppet::LookupContext.new(nil)
-            $yaml_data = $ctx.cached_file_data('#{data_path}') |$content| {
-              { 'parsed' => $content }
-            }
-            notice($yaml_data)
-            PUPPET
-
-          code2 = <<-PUPPET.unindent
-            $ctx = Puppet::LookupContext.new(nil)
-            $yaml_data = $ctx.cached_file_data('#{data_path}') |$content| {
-              { 'parsed' => 'should not be called' }
-            }
-            notice($yaml_data)
-            PUPPET
-
-          logs = []
-          Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
-            Puppet[:code] = code1
-            Puppet::Parser::Compiler.compile(node)
-            Puppet[:code] = code2
-            Puppet::Parser::Compiler.compile(node)
-          end
-          logs = logs.select { |log| log.level == :notice }.map { |log| log.message }
-          expect(logs.uniq.size).to eql(1)
-        end
-
-        it 'will invalidate cache if file changes size' do
-          code = <<-PUPPET.unindent
-            $ctx = Puppet::LookupContext.new(nil)
-            $yaml_data = $ctx.cached_file_data('#{data_path}') |$content| {
-              { 'parsed' => $content }
-            }
-            notice($yaml_data)
-            PUPPET
-
-          logs = []
-          Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
-            Puppet[:code] = code
-            Puppet::Parser::Compiler.compile(node)
-
-            # Change content size!
-            File.write(data_path, "a: value is now A\n")
-            Puppet::Parser::Compiler.compile(node)
-          end
-          logs = logs.select { |log| log.level == :notice }.map { |log| log.message }
-          expect(logs).to eql(["{parsed => a: value a\n}", "{parsed => a: value is now A\n}"])
-        end
-
-        it 'will invalidate cache if file changes mtime' do
-          old_mtime = Puppet::FileSystem.stat(data_path).mtime
-
-          code = <<-PUPPET.unindent
-            $ctx = Puppet::LookupContext.new(nil)
-            $yaml_data = $ctx.cached_file_data('#{data_path}') |$content| {
-              { 'parsed' => $content }
-            }
-            notice($yaml_data)
-          PUPPET
-
-          logs = []
-          Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
-            Puppet[:code] = code
-            Puppet::Parser::Compiler.compile(node)
-
-            # Write content with the same size
-            File.write(data_path, "a: value b\n")
-
-            # Ensure mtime is at least 1 second ahead
-            FileUtils.touch(data_path, mtime: old_mtime + 1)
-
-            Puppet::Parser::Compiler.compile(node)
-          end
-          logs = logs.select { |log| log.level == :notice }.map { |log| log.message }
-          expect(logs).to eql(["{parsed => a: value a\n}", "{parsed => a: value b\n}"])
-        end
-
-        it 'will invalidate cache if file changes inode' do
-          code = <<-PUPPET.unindent
-              $ctx = Puppet::LookupContext.new(nil)
-              $yaml_data = $ctx.cached_file_data('#{data_path}') |$content| {
-                { 'parsed' => $content }
-              }
-              notice($yaml_data)
-          PUPPET
-
-          logs = []
-          Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
-            Puppet[:code] = code
-            Puppet::Parser::Compiler.compile(node)
-
-            # Change inode!
-            File.delete(data_path);
-            # Write content with the same size
-            File.write(data_path, "a: value b\n")
-            Puppet::Parser::Compiler.compile(node)
-          end
-          logs = logs.select { |log| log.level == :notice }.map { |log| log.message }
-          expect(logs).to eql(["{parsed => a: value a\n}", "{parsed => a: value b\n}"])
-        end
-      end
-    end
-
-    context 'when used in an Invocation' do
-      let(:node) { Puppet::Node.new('test') }
-      let(:compiler) { Puppet::Parser::Compiler.new(node) }
-      let(:invocation) { Invocation.new(compiler.topscope) }
-      let(:invocation_with_explain) { Invocation.new(compiler.topscope, {}, {}, true) }
-
-      def compile_and_get_notices(code, scope_vars = {})
-        Puppet[:code] = code
-        scope = compiler.topscope
-        scope_vars.each_pair { |k,v| scope.setvar(k, v) }
-        node.environment.check_for_reparse
-        logs = []
-        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
-          compiler.compile
-        end
-        logs = logs.select { |log| log.level == :notice }.map { |log| log.message }
-        logs
-      end
-
-      it 'will not call explain unless explanations are active' do
-        invocation.lookup('dummy', nil) do
-          code = <<-PUPPET.unindent
-            $ctx = Puppet::LookupContext.new('m')
-            $ctx.explain || { notice('stop calling'); 'bad' }
-          PUPPET
-          expect(compile_and_get_notices(code)).to be_empty
-        end
-      end
-
-      it 'will call explain when explanations are active' do
-        invocation_with_explain.lookup('dummy', nil) do
-          code = <<-PUPPET.unindent
-            $ctx = Puppet::LookupContext.new('m')
-            $ctx.explain || { notice('called'); 'good' }
-          PUPPET
-          expect(compile_and_get_notices(code)).to eql(['called'])
-        end
-        expect(invocation_with_explain.explainer.explain).to eql("good\n")
-      end
-
-      it 'will call interpolate to resolve interpolation' do
-        invocation.lookup('dummy', nil) do
-          code = <<-PUPPET.unindent
-            $ctx = Puppet::LookupContext.new('m')
-            notice($ctx.interpolate('-- %{testing} --'))
-          PUPPET
-          expect(compile_and_get_notices(code, { 'testing' => 'called' })).to eql(['-- called --'])
-        end
-      end
-    end
-  end
-end
-end
-end