puppet 4.7.1-x86-mingw32 → 4.8.0-x86-mingw32

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

@@ -1,5 +1,6 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'puppet_spec/compiler'
 
 require 'puppet/pops'
 require 'puppet/pops/evaluator/evaluator_impl'
@@ -73,5 +74,174 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
         expect(evaluate(literal('012.3') + literal('010'))).to eq(20.3)
       end
     end
+
+    context 'on timespans' do
+      include PuppetSpec::Compiler
+
+      it 'Timespan + Timespan = Timespan' do
+        code = 'notice(assert_type(Timespan, Timespan({days => 3}) + Timespan({hours => 12})))'
+        expect(eval_and_collect_notices(code)).to eql(['3-12:00:00.0'])
+      end
+
+      it 'Timespan - Timespan = Timespan' do
+        code = 'notice(assert_type(Timespan, Timespan({days => 3}) - Timespan({hours => 12})))'
+        expect(eval_and_collect_notices(code)).to eql(['2-12:00:00.0'])
+      end
+
+      it 'Timespan + -Timespan = Timespan' do
+        code = 'notice(assert_type(Timespan, Timespan({days => 3}) + -Timespan({hours => 12})))'
+        expect(eval_and_collect_notices(code)).to eql(['2-12:00:00.0'])
+      end
+
+      it 'Timespan - -Timespan = Timespan' do
+        code = 'notice(assert_type(Timespan, Timespan({days => 3}) - -Timespan({hours => 12})))'
+        expect(eval_and_collect_notices(code)).to eql(['3-12:00:00.0'])
+      end
+
+      it 'Timespan / Timespan = Float' do
+        code = "notice(assert_type(Float, Timespan({days => 3}) / Timespan('0-12:00:00')))"
+        expect(eval_and_collect_notices(code)).to eql(['6.0'])
+      end
+
+      it 'Timespan * Timespan is an error' do
+        code = 'notice(Timespan({days => 3}) * Timespan({hours => 12}))'
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /A Timestamp cannot be multiplied by a Timespan/)
+      end
+
+      it 'Timespan + Numeric = Timespan (numeric treated as seconds)' do
+        code = 'notice(assert_type(Timespan, Timespan({days => 3}) + 7300.0))'
+        expect(eval_and_collect_notices(code)).to eql(['3-02:01:40.0'])
+      end
+
+      it 'Timespan - Numeric = Timespan (numeric treated as seconds)' do
+        code = "notice(assert_type(Timespan, Timespan({days => 3}) - 7300.123))"
+        expect(eval_and_collect_notices(code)).to eql(['2-21:58:19.877'])
+      end
+
+      it 'Timespan * Numeric = Timespan (numeric treated as seconds)' do
+        code = "notice(strftime(assert_type(Timespan, Timespan({days => 3}) * 2), '%D'))"
+        expect(eval_and_collect_notices(code)).to eql(['6'])
+      end
+
+      it 'Numeric + Timespan = Timespan (numeric treated as seconds)' do
+        code = 'notice(assert_type(Timespan, 7300.0 + Timespan({days => 3})))'
+        expect(eval_and_collect_notices(code)).to eql(['3-02:01:40.0'])
+      end
+
+      it 'Numeric - Timespan = Timespan (numeric treated as seconds)' do
+        code = "notice(strftime(assert_type(Timespan, 300000 - Timespan({days => 3})), '%H:%M'))"
+        expect(eval_and_collect_notices(code)).to eql(['11:20'])
+      end
+
+      it 'Numeric * Timespan = Timespan (numeric treated as seconds)' do
+        code = "notice(strftime(assert_type(Timespan, 2 * Timespan({days => 3})), '%D'))"
+        expect(eval_and_collect_notices(code)).to eql(['6'])
+      end
+
+      it 'Timespan + Timestamp = Timestamp' do
+        code = "notice(assert_type(Timestamp, Timespan({days => 3}) + Timestamp('2016-08-27T16:44:49.999 UTC')))"
+        expect(eval_and_collect_notices(code)).to eql(['2016-08-30T16:44:49.999 UTC'])
+      end
+
+      it 'Timespan - Timestamp is an error' do
+        code = 'notice(Timespan({days => 3}) - Timestamp())'
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /A Timestamp cannot be subtracted from a Timespan/)
+      end
+
+      it 'Timespan * Timestamp is an error' do
+        code = 'notice(Timespan({days => 3}) * Timestamp())'
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /A Timestamp cannot be multiplied by a Timestamp/)
+      end
+
+      it 'Timespan / Timestamp is an error' do
+        code = 'notice(Timespan({days => 3}) / Timestamp())'
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /A Timespan cannot be divided by a Timestamp/)
+      end
+    end
+
+
+    context 'on timestamps' do
+      include PuppetSpec::Compiler
+
+      it 'Timestamp + Timestamp is an error' do
+        code = 'notice(Timestamp() + Timestamp())'
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /A Timestamp cannot be added to a Timestamp/)
+      end
+
+      it 'Timestamp + Timespan = Timestamp' do
+        code = "notice(assert_type(Timestamp, Timestamp('2016-10-10') + Timespan('0-12:00:00')))"
+        expect(eval_and_collect_notices(code)).to eql(['2016-10-10T12:00:00.000 UTC'])
+      end
+
+      it 'Timestamp + Numeric = Timestamp' do
+        code = "notice(assert_type(Timestamp, Timestamp('2016-10-10T12:00:00.000') + 3600.123))"
+        expect(eval_and_collect_notices(code)).to eql(['2016-10-10T13:00:00.123 UTC'])
+      end
+
+      it 'Numeric + Timestamp = Timestamp' do
+        code = "notice(assert_type(Timestamp, 3600.123 + Timestamp('2016-10-10T12:00:00.000')))"
+        expect(eval_and_collect_notices(code)).to eql(['2016-10-10T13:00:00.123 UTC'])
+      end
+
+      it 'Timestamp - Timestamp = Timespan' do
+        code = "notice(assert_type(Timespan, Timestamp('2016-10-10') - Timestamp('2015-10-10')))"
+        expect(eval_and_collect_notices(code)).to eql(['366-00:00:00.0'])
+      end
+
+      it 'Timestamp - Timespan = Timestamp' do
+        code = "notice(assert_type(Timestamp, Timestamp('2016-10-10') - Timespan('0-12:00:00')))"
+        expect(eval_and_collect_notices(code)).to eql(['2016-10-09T12:00:00.000 UTC'])
+      end
+
+      it 'Timestamp - Numeric = Timestamp' do
+        code = "notice(assert_type(Timestamp, Timestamp('2016-10-10') - 3600.123))"
+        expect(eval_and_collect_notices(code)).to eql(['2016-10-09T22:59:59.877 UTC'])
+      end
+
+      it 'Numeric - Timestamp = Timestamp' do
+        code = "notice(assert_type(Timestamp, 123 - Timestamp('2016-10-10')))"
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Operator '-' is not applicable.*when right side is a Timestamp/)
+      end
+
+      it 'Timestamp / Timestamp is an error' do
+        code = "notice(Timestamp('2016-10-10') / Timestamp())"
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Operator '\/' is not applicable to a Timestamp/)
+      end
+
+      it 'Timestamp / Timespan is an error' do
+        code = "notice(Timestamp('2016-10-10') / Timespan('0-12:00:00'))"
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Operator '\/' is not applicable to a Timestamp/)
+      end
+
+      it 'Timestamp / Numeric is an error' do
+        code = "notice(Timestamp('2016-10-10') / 3600.123)"
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Operator '\/' is not applicable to a Timestamp/)
+      end
+
+      it 'Numeric / Timestamp is an error' do
+        code = "notice(3600.123 / Timestamp('2016-10-10'))"
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Operator '\/' is not applicable.*when right side is a Timestamp/)
+      end
+
+      it 'Timestamp * Timestamp is an error' do
+        code = "notice(Timestamp('2016-10-10') * Timestamp())"
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Operator '\*' is not applicable to a Timestamp/)
+      end
+
+      it 'Timestamp * Timespan is an error' do
+        code = "notice(Timestamp('2016-10-10') * Timespan('0-12:00:00'))"
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Operator '\*' is not applicable to a Timestamp/)
+      end
+
+      it 'Timestamp * Numeric is an error' do
+        code = "notice(Timestamp('2016-10-10') * 3600.123)"
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Operator '\*' is not applicable to a Timestamp/)
+      end
+
+      it 'Numeric * Timestamp is an error' do
+        code = "notice(3600.123 * Timestamp('2016-10-10'))"
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Operator '\*' is not applicable.*when right side is a Timestamp/)
+      end
+    end
   end
 end

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

@@ -746,8 +746,9 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "Array[Integer,1,2,3]"        => 'Array-Type[] accepts 1 to 3 arguments. Got 4',
       "Array[Integer,String]"       => "A Type's size constraint arguments must be a single Integer type, or 1-2 integers (or default). Got a String-Type",
       "Hash[Integer,String, 1,2,3]" => 'Hash-Type[] accepts 2 to 4 arguments. Got 5',
-      "'abc'[x]"                    => "The value 'x' cannot be converted to Numeric",
-      "'abc'[1.0]"                  => "A String[] cannot use Float where Integer is expected",
+      "'abc'[x]"                    => "A substring operation does not accept a String as a character index. Expected an Integer",
+      "'abc'[1.0]"                  => "A substring operation does not accept a Float as a character index. Expected an Integer",
+      "'abc'[1, x]"                 => "A substring operation does not accept a String as a character index. Expected an Integer",
       "'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',
@@ -1040,6 +1041,12 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       expect{parser.evaluate_string(scope, "assert_no_undef({1 => undef})")}.to_not raise_error()
     end
 
+    it 'a lambda return value is checked using the return type' do
+      expect(parser.evaluate_string(scope, "[1,2].map |Integer $x| >> Integer { $x }")).to eql([1,2])
+      expect { parser.evaluate_string(scope, "[1,2].map |Integer $x| >> String { $x }") }.to raise_error(
+        /value returned from lambda has wrong type, expects a String value, got Integer/)
+    end
+
     context 'using the 3x function api' do
       it 'can call a 3x function' do
         Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0] }
@@ -1274,7 +1281,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       expect(parser.evaluate_string(scope, src)).to eq("Tex\tt\\n")
     end
 
-    it "parses syntax checked specification" do
+    it "parses json syntax checked specification" do
       src = <<-CODE
       @(END:json)
       ["foo", "bar"]
@@ -1283,7 +1290,16 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       expect(parser.evaluate_string(scope, src)).to eq('["foo", "bar"]')
     end
 
-    it "parses syntax checked specification with error and reports it" do
+    it "parses base64 syntax checked specification" do
+      src = <<-CODE
+      @(END:base64)
+        dGhlIHF1aWNrIHJlZCBmb3g=
+        |- END
+      CODE
+      expect(parser.evaluate_string(scope, src)).to eq('dGhlIHF1aWNrIHJlZCBmb3g=')
+    end
+
+    it "parses json syntax checked specification with error and reports it" do
       src = <<-CODE
       @(END:json)
       ['foo', "bar"]
@@ -1292,6 +1308,15 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       expect { parser.evaluate_string(scope, src)}.to raise_error(/Cannot parse invalid JSON string/)
     end
 
+    it "parses base syntax checked specification with error and reports it" do
+      src = <<-CODE
+      @(END:base64)
+        dGhlIHF1aWNrIHJlZCBmb3g
+        |- END
+      CODE
+      expect { parser.evaluate_string(scope, src)}.to raise_error(/Cannot parse invalid Base64 string/)
+    end
+
     it "parses interpolated heredoc expression" do
       src = <<-CODE
       $pname = 'Fjodor'

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

@@ -5,21 +5,129 @@ require 'puppet/pops'
 require 'puppet/pops/types/type_factory'
 
 describe 'when converting to 3.x' do
+  let(:converter) { Puppet::Pops::Evaluator::Runtime3Converter.instance }
+
   it "converts a resource type starting with Class without confusing it with exact match on 'class'" do
     t = Puppet::Pops::Types::TypeFactory.resource('classroom', 'kermit')
-    converted = Puppet::Pops::Evaluator::Runtime3Converter.instance.catalog_type_to_split_type_title(t)
+    converted = converter.catalog_type_to_split_type_title(t)
     expect(converted).to eql(['classroom', 'kermit'])
   end
 
   it "converts a resource type of exactly 'Class'" do
     t = Puppet::Pops::Types::TypeFactory.resource('class', 'kermit')
-    converted = Puppet::Pops::Evaluator::Runtime3Converter.instance.catalog_type_to_split_type_title(t)
+    converted = converter.catalog_type_to_split_type_title(t)
     expect(converted).to eql(['class', 'kermit'])
   end
 
   it "errors on attempts to convert an 'Iterator'" do
     expect {
-      Puppet::Pops::Evaluator::Runtime3Converter.convert(Puppet::Pops::Types::Iterable.on((1..3)), {}, nil)
+      converter.convert(Puppet::Pops::Types::Iterable.on((1..3)), {}, nil)
     }.to raise_error(Puppet::Error, /Use of an Iterator is not supported here/)
   end
-end
+
+  it 'does not convert a SemVer instance to string' do
+    v = Semantic::Version.parse('1.0.0')
+    expect(converter.convert(v, {}, nil)).to equal(v)
+  end
+
+  it 'converts the symbol :undef to the undef value' do
+    v = Semantic::Version.parse('1.0.0')
+    expect(converter.convert(:undef, {}, 'undef value')).to eql('undef value')
+  end
+
+  it 'converts the nil to the undef value' do
+    v = Semantic::Version.parse('1.0.0')
+    expect(converter.convert(nil, {}, 'undef value')).to eql('undef value')
+  end
+
+  it 'does not convert a symbol nested in an array' do
+    v = Semantic::Version.parse('1.0.0')
+    expect(converter.convert({'foo' => :undef}, {}, 'undef value')).to eql({'foo' => :undef})
+  end
+
+  it 'converts nil to :undef when nested in an array' do
+    v = Semantic::Version.parse('1.0.0')
+    expect(converter.convert({'foo' => nil}, {}, 'undef value')).to eql({'foo' => :undef})
+  end
+
+  it 'does not convert a Regex instance to string' do
+    v = /^[A-Z]$/
+    expect(converter.convert(v, {}, nil)).to equal(v)
+  end
+
+  it 'does not convert a Version instance to string' do
+    v = Semantic::Version.parse('1.0.0')
+    expect(converter.convert(v, {}, nil)).to equal(v)
+  end
+
+  it 'does not convert a VersionRange instance to string' do
+    v = Semantic::VersionRange.parse('>=1.0.0')
+    expect(converter.convert(v, {}, nil)).to equal(v)
+  end
+
+  it 'does not convert a Timespan instance to string' do
+    v = Puppet::Pops::Time::Timespan.new(1234)
+    expect(converter.convert(v, {}, nil)).to equal(v)
+  end
+
+  it 'does not convert a Timestamp instance to string' do
+    v = Puppet::Pops::Time::Timestamp.now
+    expect(converter.convert(v, {}, nil)).to equal(v)
+  end
+
+  it 'does not convert a Sensitive instance to string' do
+    v = Puppet::Pops::Types::PSensitiveType::Sensitive.new("don't reveal this")
+    expect(converter.convert(v, {}, nil)).to equal(v)
+  end
+
+  it 'does not convert a Binary instance to string' do
+    v = Puppet::Pops::Types::PBinaryType::Binary.from_base64('w5ZzdGVuIG1lZCByw7ZzdGVuCg==')
+    expect(converter.convert(v, {}, nil)).to equal(v)
+  end
+
+  context 'the Runtime3FunctionArgumentConverter' do
+    let(:converter) { Puppet::Pops::Evaluator::Runtime3FunctionArgumentConverter.instance }
+
+    it 'converts a Regex instance to string' do
+      c = converter.convert(/^[A-Z]$/, {}, nil)
+      expect(c).to be_a(String)
+      expect(c).to eql('/^[A-Z]$/')
+    end
+
+    it 'converts a Version instance to string' do
+      c = converter.convert(Semantic::Version.parse('1.0.0'), {}, nil)
+      expect(c).to be_a(String)
+      expect(c).to eql('1.0.0')
+    end
+
+    it 'converts a VersionRange instance to string' do
+      c = converter.convert(Semantic::VersionRange.parse('>=1.0.0'), {}, nil)
+      expect(c).to be_a(String)
+      expect(c).to eql('>=1.0.0')
+    end
+
+    it 'converts a Timespan instance to string' do
+      c = converter.convert(Puppet::Pops::Time::Timespan.new(1234), {}, nil)
+      expect(c).to be_a(String)
+      expect(c).to eql('0-00:00:00.1234')
+    end
+
+    it 'converts a Timestamp instance to string' do
+      c = converter.convert(Puppet::Pops::Time::Timestamp.parse('2016-09-15T12:24:47.193 UTC'), {}, nil)
+      expect(c).to be_a(String)
+      expect(c).to eql('2016-09-15T12:24:47.193 UTC')
+    end
+
+    it 'converts a Binary instance to string' do
+      b64 = 'w5ZzdGVuIG1lZCByw7ZzdGVuCg=='
+      c = converter.convert(Puppet::Pops::Types::PBinaryType::Binary.from_base64(b64), {}, nil)
+      expect(c).to be_a(String)
+      expect(c).to eql(b64)
+    end
+
+    it 'does not convert a Sensitive instance to string' do
+      v = Puppet::Pops::Types::PSensitiveType::Sensitive.new("don't reveal this")
+      expect(converter.convert(v, {}, nil)).to equal(v)
+    end
+  end
+end

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

@@ -10,6 +10,18 @@ describe 'dependency loader' do
   let(:loaders) { Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, [])) }
 
   describe 'FileBased module loader' do
+    it 'prints a pretty name for itself when inspected' do
+      module_dir = dir_containing('testmodule', {
+      'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {
+        'foo.rb' => 'Puppet::Functions.create_function("foo") { def foo; end; }'
+      }}}}})
+
+      loader = loader_for('testmodule', module_dir)
+
+      expect(loader.inspect).to eq("(DependencyLoader 'test-dep' [(ModuleLoader::FileBased 'testmodule' 'testmodule')])")
+      expect(loader.to_s).to eq("(DependencyLoader 'test-dep' [(ModuleLoader::FileBased 'testmodule' 'testmodule')])")
+    end
+
     it 'load something in global name space raises an error' do
       module_dir = dir_containing('testmodule', {
       'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {

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

@@ -20,32 +20,6 @@ describe 'the static loader' do
     expect(loader.find(a_typed_name)).to be(nil)
   end
 
-  context 'provides access to logging functions' do
-    let(:loader) { loader = Puppet::Pops::Loader::StaticLoader.new() }
-    # Ensure all logging functions produce output
-    before(:each) { Puppet::Util::Log.level = :debug }
-
-    Puppet::Util::Log.levels.each do |level|
-      it "defines the function #{level.to_s}" do
-        expect(loader.load(:function, level).class.name).to eql(level.to_s)
-      end
-
-      it 'and #{level.to_s} can be called' do
-        expect(loader.load(:function, level).call({}, 'yay').to_s).to eql('yay')
-      end
-
-      it "uses the evaluator to format output" do
-        expect(loader.load(:function, level).call({}, ['yay', 'surprise']).to_s).to eql('[yay, surprise]')
-      end
-
-      it 'outputs name of source (scope) by passing it to the Log utility' do
-        the_scope = {}
-        Puppet::Util::Log.any_instance.expects(:source=).with(the_scope)
-        loader.load(:function, level).call(the_scope, 'x')
-      end
-    end
-  end
-
   context 'provides access to resource types built into puppet' do
     let(:loader) { loader = Puppet::Pops::Loader::StaticLoader.new() }
 

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

@@ -0,0 +1,149 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+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('e', '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('e', 'm').environment_name)"
+      expect(eval_and_collect_notices(code)[0]).to eql('e')
+    end
+
+    it 'returns its module_name' do
+      code = "notice(Puppet::LookupContext.new('e', '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('e', 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('e', '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 'can store and retrieve a hash using the cache' do
+      code = <<-PUPPET.unindent
+        $ctx = Puppet::LookupContext.new('e', '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('e', '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('e', '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('e', '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('e', '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('e', '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('e', '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('e', 'm')
+        $ctx.not_found
+      PUPPET
+      expect { eval_and_collect_notices(code) }.to throw_symbol(:no_such_key)
+    end
+
+    context 'when used in an Invocation' do
+      let(:invocation) { Invocation.new({}) }
+      let(:invocation_with_explain) { Invocation.new({}, {}, {}, true) }
+
+      it 'will not call explain unless explanations are active' do
+        Invocation.expects(:current).returns(invocation)
+        code = <<-PUPPET.unindent
+          $ctx = Puppet::LookupContext.new('e', 'm')
+          $ctx.explain || { notice('stop calling'); 'bad' }
+        PUPPET
+        expect(eval_and_collect_notices(code)).to be_empty
+      end
+
+      it 'will call explain when explanations are active' do
+        Invocation.expects(:current).returns(invocation_with_explain)
+        invocation_with_explain.with(:global, 'test') do
+          code = <<-PUPPET.unindent
+            $ctx = Puppet::LookupContext.new('e', 'm')
+            $ctx.explain || { notice('called'); 'good' }
+          PUPPET
+          expect(eval_and_collect_notices(code)).to eql(['called'])
+        end
+        expect(invocation_with_explain.explainer.to_s).to eql(<<-TEXT.unindent)
+          Data Binding "test"
+            good
+        TEXT
+      end
+    end
+  end
+end
+end
+end
+