puppet 5.5.22 → 6.0.0

data/spec/unit/parser/scope_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'puppet_spec/scope'
@@ -70,8 +71,8 @@ describe Puppet::Parser::Scope do
   end
 
   it "should be able to retrieve class scopes by object" do
-    klass = double('ast_class')
-    expect(klass).to receive(:name).and_return("myname")
+    klass = mock 'ast_class'
+    klass.expects(:name).returns("myname")
     @scope.class_set "myname", "myscope"
     expect(@scope.class_scope(klass)).to eq("myscope")
   end
@@ -92,7 +93,7 @@ describe Puppet::Parser::Scope do
 
   it "should get its environment from its compiler" do
     env = Puppet::Node::Environment.create(:testing, [])
-    compiler = double('compiler', :environment => env, :is_a? => true)
+    compiler = stub 'compiler', :environment => env, :is_a? => true
     scope = Puppet::Parser::Scope.new(compiler)
     expect(scope.environment).to equal(env)
   end
@@ -145,7 +146,7 @@ describe Puppet::Parser::Scope do
     it "should extend itself with its environment's Functions module as well as the default" do
       env = Puppet::Node::Environment.create(:myenv, [])
       root = Puppet.lookup(:root_environment)
-      compiler = double('compiler', :environment => env, :is_a? => true)
+      compiler = stub 'compiler', :environment => env, :is_a? => true
 
       scope = Puppet::Parser::Scope.new(compiler)
       expect(scope.singleton_class.ancestors).to be_include(Puppet::Parser::Functions.environment_module(env))
@@ -223,22 +224,22 @@ describe Puppet::Parser::Scope do
     end
 
     it "warns and return nil for non found unqualified variable" do
-      expect(Puppet).to receive(:warn_once)
+      Puppet.expects(:warn_once)
       expect(@scope["santa_clause"]).to be_nil
     end
 
     it "warns once for a non found variable" do
-      expect(Puppet).to receive(:send_log).with(:warning, be_a(String)).once
+      Puppet.expects(:send_log).with(:warning, is_a(String)).once
       expect([@scope["santa_claus"],@scope["santa_claus"]]).to eq([nil, nil])
     end
 
     it "warns and return nil for non found qualified variable" do
-      expect(Puppet).to receive(:warn_once)
+      Puppet.expects(:warn_once)
       expect(@scope["north_pole::santa_clause"]).to be_nil
     end
 
     it "does not warn when a numeric variable is missing - they always exist" do
-      expect(Puppet).not_to receive(:warn_once)
+      Puppet.expects(:warn_once).never
       expect(@scope["1"]).to be_nil
     end
 
@@ -260,13 +261,13 @@ describe Puppet::Parser::Scope do
         catalog = Puppet::Resource::Catalog.new
         catalog.add_resource(Puppet::Parser::Resource.new("stage", :main, :scope => Puppet::Parser::Scope.new(@compiler)))
 
-        Puppet::Parser::Resource.new("class", name, :scope => @scope, :source => double('source'), :catalog => catalog).evaluate
+        Puppet::Parser::Resource.new("class", name, :scope => @scope, :source => mock('source'), :catalog => catalog).evaluate
 
         @scope.class_scope(klass)
       end
 
       it "should be able to look up explicitly fully qualified variables from compiler's top scope" do
-        expect(Puppet).not_to receive(:deprecation_warning)
+        Puppet.expects(:deprecation_warning).never
         other_scope = @scope.compiler.topscope
 
         other_scope["othervar"] = "otherval"
@@ -275,7 +276,7 @@ describe Puppet::Parser::Scope do
       end
 
       it "should be able to look up explicitly fully qualified variables from other scopes" do
-        expect(Puppet).not_to receive(:deprecation_warning)
+        Puppet.expects(:deprecation_warning).never
         other_scope = create_class_scope("other")
 
         other_scope["var"] = "otherval"
@@ -284,7 +285,7 @@ describe Puppet::Parser::Scope do
       end
 
       it "should be able to look up deeply qualified variables" do
-        expect(Puppet).not_to receive(:deprecation_warning)
+        Puppet.expects(:deprecation_warning).never
         other_scope = create_class_scope("other::deep::klass")
 
         other_scope["var"] = "otherval"
@@ -300,12 +301,12 @@ describe Puppet::Parser::Scope do
 
       it "should warn and return nil for qualified variables whose classes have not been evaluated" do
         newclass("other::deep::klass")
-        expect(Puppet).to receive(:warn_once)
+        Puppet.expects(:warn_once)
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
 
       it "should warn and return nil for qualified variables whose classes do not exist" do
-        expect(Puppet).to receive(:warn_once)
+        Puppet.expects(:warn_once)
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
 
@@ -314,7 +315,7 @@ describe Puppet::Parser::Scope do
       end
 
       it "should return nil when asked for a non-string qualified variable from a class that has not been evaluated" do
-        allow(@scope).to receive(:warning)
+        @scope.stubs(:warning)
         newclass("other::deep::klass")
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
@@ -536,10 +537,10 @@ describe Puppet::Parser::Scope do
 
   describe "when setting ephemeral vars from matches" do
     before :each do
-      @match = double('match', :is_a? => true)
-      allow(@match).to receive(:[]).with(0).and_return("this is a string")
-      allow(@match).to receive(:captures).and_return([])
-      allow(@scope).to receive(:setvar)
+      @match = stub 'match', :is_a? => true
+      @match.stubs(:[]).with(0).returns("this is a string")
+      @match.stubs(:captures).returns([])
+      @scope.stubs(:setvar)
     end
 
     it "should accept only MatchData" do
@@ -550,32 +551,27 @@ describe Puppet::Parser::Scope do
 
     it "should set $0 with the full match" do
       # This is an internal impl detail test
-      expect(@scope).to receive(:new_match_scope) do |arg|
-        expect(arg[0]).to eq("this is a string")
-      end
+      @scope.expects(:new_match_scope).with { |*arg| arg[0][0] == "this is a string" }
       @scope.ephemeral_from(@match)
     end
 
     it "should set every capture as ephemeral var" do
       # This is an internal impl detail test
-      allow(@match).to receive(:[]).with(1).and_return(:capture1)
-      allow(@match).to receive(:[]).with(2).and_return(:capture2)
-      expect(@scope).to receive(:new_match_scope) do |arg|
-        expect(arg[1]).to eq(:capture1)
-        expect(arg[2]).to eq(:capture2)
-      end
+      @match.stubs(:[]).with(1).returns(:capture1)
+      @match.stubs(:[]).with(2).returns(:capture2)
+      @scope.expects(:new_match_scope).with { |*arg| arg[0][1] == :capture1 && arg[0][2] == :capture2 }
 
       @scope.ephemeral_from(@match)
     end
 
     it "should shadow previous match variables" do
       # This is an internal impl detail test
-      allow(@match).to receive(:[]).with(1).and_return(:capture1)
-      allow(@match).to receive(:[]).with(2).and_return(:capture2)
+      @match.stubs(:[]).with(1).returns(:capture1)
+      @match.stubs(:[]).with(2).returns(:capture2)
 
-      @match2 = double('match', :is_a? => true)
-      allow(@match2).to receive(:[]).with(1).and_return(:capture2_1)
-      allow(@match2).to receive(:[]).with(2).and_return(nil)
+      @match2 = stub 'match', :is_a? => true
+      @match2.stubs(:[]).with(1).returns(:capture2_1)
+      @match2.stubs(:[]).with(2).returns(nil)
       @scope.ephemeral_from(@match)
       @scope.ephemeral_from(@match2)
       expect(@scope.lookupvar('2')).to eq(nil)
@@ -590,13 +586,13 @@ describe Puppet::Parser::Scope do
 
   describe "when managing defaults" do
     it "should be able to set and lookup defaults" do
-      param = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => double("source"))
+      param = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => stub("source"))
       @scope.define_settings(:mytype, param)
       expect(@scope.lookupdefaults(:mytype)).to eq({:myparam => param})
     end
 
     it "should fail if a default is already defined and a new default is being defined" do
-      param = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => double("source"))
+      param = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => stub("source"))
       @scope.define_settings(:mytype, param)
       expect {
         @scope.define_settings(:mytype, param)
@@ -604,20 +600,20 @@ describe Puppet::Parser::Scope do
     end
 
     it "should return multiple defaults at once" do
-      param1 = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => double("source"))
+      param1 = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => stub("source"))
       @scope.define_settings(:mytype, param1)
-      param2 = Puppet::Parser::Resource::Param.new(:name => :other, :value => "myvalue", :source => double("source"))
+      param2 = Puppet::Parser::Resource::Param.new(:name => :other, :value => "myvalue", :source => stub("source"))
       @scope.define_settings(:mytype, param2)
 
       expect(@scope.lookupdefaults(:mytype)).to eq({:myparam => param1, :other => param2})
     end
 
     it "should look up defaults defined in parent scopes" do
-      param1 = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => double("source"))
+      param1 = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => stub("source"))
       @scope.define_settings(:mytype, param1)
 
       child_scope = @scope.newscope
-      param2 = Puppet::Parser::Resource::Param.new(:name => :other, :value => "myvalue", :source => double("source"))
+      param2 = Puppet::Parser::Resource::Param.new(:name => :other, :value => "myvalue", :source => stub("source"))
       child_scope.define_settings(:mytype, param2)
 
       expect(child_scope.lookupdefaults(:mytype)).to eq({:myparam => param1, :other => param2})

data/spec/unit/parser/templatewrapper_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/parser/templatewrapper'
 
@@ -5,20 +6,20 @@ describe Puppet::Parser::TemplateWrapper do
   let(:known_resource_types) { Puppet::Resource::TypeCollection.new("env") }
   let(:scope) do
     compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
-    allow(compiler.environment).to receive(:known_resource_types).and_return(known_resource_types)
+    compiler.environment.stubs(:known_resource_types).returns known_resource_types
     Puppet::Parser::Scope.new compiler
   end
 
   let(:tw) { Puppet::Parser::TemplateWrapper.new(scope) }
 
   it "fails if a template cannot be found" do
-    expect(Puppet::Parser::Files).to receive(:find_template).and_return(nil)
+    Puppet::Parser::Files.expects(:find_template).returns nil
 
     expect { tw.file = "fake_template" }.to raise_error(Puppet::ParseError)
   end
 
   it "stringifies as template[<filename>] for a file based template" do
-    allow(Puppet::Parser::Files).to receive(:find_template).and_return("/tmp/fake_template")
+    Puppet::Parser::Files.stubs(:find_template).returns("/tmp/fake_template")
     tw.file = "fake_template"
     expect(tw.to_s).to eql("template[/tmp/fake_template]")
   end
@@ -46,19 +47,19 @@ describe Puppet::Parser::TemplateWrapper do
   end
 
   it "provides the defined classes with #classes" do
-    catalog = double('catalog', :classes => ["class1", "class2"])
-    expect(scope).to receive(:catalog).and_return(catalog)
+    catalog = mock 'catalog', :classes => ["class1", "class2"]
+    scope.expects(:catalog).returns( catalog )
     expect(tw.classes).to eq(["class1", "class2"])
   end
 
   it "provides all the tags with #all_tags" do
-    catalog = double('catalog', :tags => ["tag1", "tag2"])
-    expect(scope).to receive(:catalog).and_return(catalog)
+    catalog = mock 'catalog', :tags => ["tag1", "tag2"]
+    scope.expects(:catalog).returns( catalog )
     expect(tw.all_tags).to eq(["tag1","tag2"])
   end
 
   it "provides the tags defined in the current scope with #tags" do
-    expect(scope).to receive(:tags).and_return(["tag1", "tag2"])
+    scope.expects(:tags).returns( ["tag1", "tag2"] )
     expect(tw.tags).to eq(["tag1","tag2"])
   end
 
@@ -90,10 +91,10 @@ describe Puppet::Parser::TemplateWrapper do
 
   def given_a_template_file(name, contents)
     full_name = "/full/path/to/#{name}"
-    allow(Puppet::Parser::Files).to receive(:find_template).
+    Puppet::Parser::Files.stubs(:find_template).
       with(name, anything()).
-      and_return(full_name)
-    allow(Puppet::FileSystem).to receive(:read_preserve_line_endings).with(full_name).and_return(contents)
+      returns(full_name)
+    Puppet::FileSystem.stubs(:read_preserve_line_endings).with(full_name).returns(contents)
 
     full_name
   end

data/spec/unit/parser/type_loader_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/parser/type_loader'
@@ -36,14 +37,15 @@ describe Puppet::Parser::TypeLoader do
     end
 
     it "should attempt to import each generated name" do
-      expect(loader).to receive(:import_from_modules).with("foo/bar").and_return([])
-      expect(loader).to receive(:import_from_modules).with("foo").and_return([])
+      loader.expects(:import_from_modules).with("foo/bar").returns([])
+      loader.expects(:import_from_modules).with("foo").returns([])
       loader.try_load_fqname(:hostclass, "foo::bar")
     end
 
     it "should attempt to load each possible name going from most to least specific" do
+      path_order = sequence('path')
       ['foo/bar/baz', 'foo/bar', 'foo'].each do |path|
-        expect(Puppet::Parser::Files).to receive(:find_manifests_in_modules).with(path, anything).and_return([nil, []]).ordered
+        Puppet::Parser::Files.expects(:find_manifests_in_modules).with(path, anything).returns([nil, []]).in_sequence(path_order)
       end
 
       loader.try_load_fqname(:hostclass, 'foo::bar::baz')
@@ -51,37 +53,37 @@ describe Puppet::Parser::TypeLoader do
   end
 
   describe "when importing" do
-    let(:stub_parser) { double('Parser', :file= => nil, :parse => empty_hostclass) }
+    let(:stub_parser) { stub 'Parser', :file= => nil, :parse => empty_hostclass }
 
     before(:each) do
-      allow(Puppet::Parser::ParserFactory).to receive(:parser).and_return(stub_parser)
+      Puppet::Parser::ParserFactory.stubs(:parser).with(anything).returns(stub_parser)
     end
 
     it "should find all manifests matching the file or pattern" do
-      expect(Puppet::Parser::Files).to receive(:find_manifests_in_modules).with("myfile", anything).and_return(["modname", %w{one}])
+      Puppet::Parser::Files.expects(:find_manifests_in_modules).with("myfile", anything).returns ["modname", %w{one}]
       loader.import("myfile", "/path")
     end
 
     it "should pass the environment when looking for files" do
-      expect(Puppet::Parser::Files).to receive(:find_manifests_in_modules).with(anything, loader.environment).and_return(["modname", %w{one}])
+      Puppet::Parser::Files.expects(:find_manifests_in_modules).with(anything, loader.environment).returns ["modname", %w{one}]
       loader.import("myfile", "/path")
     end
 
     it "should fail if no files are found" do
-      expect(Puppet::Parser::Files).to receive(:find_manifests_in_modules).and_return([nil, []])
+      Puppet::Parser::Files.expects(:find_manifests_in_modules).returns [nil, []]
       expect { loader.import("myfile", "/path") }.to raise_error(/No file\(s\) found for import/)
     end
 
     it "should parse each found file" do
-      expect(Puppet::Parser::Files).to receive(:find_manifests_in_modules).and_return(["modname", [make_absolute("/one")]])
-      expect(loader).to receive(:parse_file).with(make_absolute("/one")).and_return(Puppet::Parser::AST::Hostclass.new(''))
+      Puppet::Parser::Files.expects(:find_manifests_in_modules).returns ["modname", [make_absolute("/one")]]
+      loader.expects(:parse_file).with(make_absolute("/one")).returns(Puppet::Parser::AST::Hostclass.new(''))
       loader.import("myfile", "/path")
     end
 
     it "should not attempt to import files that have already been imported" do
       loader = Puppet::Parser::TypeLoader.new(:myenv)
 
-      expect(Puppet::Parser::Files).to receive(:find_manifests_in_modules).twice.and_return(["modname", %w{/one}])
+      Puppet::Parser::Files.expects(:find_manifests_in_modules).twice.returns ["modname", %w{/one}]
       expect(loader.import("myfile", "/path")).not_to be_empty
 
       expect(loader.import("myfile", "/path")).to be_empty
@@ -173,20 +175,20 @@ describe Puppet::Parser::TypeLoader do
 
   describe "when parsing a file" do
     it "requests a new parser instance for each file" do
-      parser = double('Parser', :file= => nil, :parse => empty_hostclass)
+      parser = stub 'Parser', :file= => nil, :parse => empty_hostclass
 
-      expect(Puppet::Parser::ParserFactory).to receive(:parser).twice.and_return(parser)
+      Puppet::Parser::ParserFactory.expects(:parser).twice.returns(parser)
 
       loader.parse_file("/my/file")
       loader.parse_file("/my/other_file")
     end
 
     it "assigns the parser its file and then parses" do
-      parser = double('parser')
+      parser = mock 'parser'
 
-      expect(Puppet::Parser::ParserFactory).to receive(:parser).and_return(parser)
-      expect(parser).to receive(:file=).with("/my/file")
-      expect(parser).to receive(:parse).and_return(empty_hostclass)
+      Puppet::Parser::ParserFactory.expects(:parser).returns(parser)
+      parser.expects(:file=).with("/my/file")
+      parser.expects(:parse).returns(empty_hostclass)
 
       loader.parse_file("/my/file")
     end

data/spec/unit/pops/adaptable_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
 

data/spec/unit/pops/benchmark_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
 require 'puppet_spec/pops'

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/pops'

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 
@@ -127,6 +128,16 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       end
     end
 
+    context 'on binary values' do
+      include PuppetSpec::Compiler
+      require 'base64'
+      encoded = Base64.encode64('Hello world').chomp
+      it 'Binary + Binary' do
+        code = 'notice(assert_type(Binary, Binary([72,101,108,108,111,32]) + Binary([119,111,114,108,100])))'
+        expect(eval_and_collect_notices(code)).to eql([encoded])
+      end
+    end
+
     context 'on timespans' do
       include PuppetSpec::Compiler
 

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/pops'

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/pops'

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/pops'

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
 require 'puppet/pops/evaluator/evaluator_impl'

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

@@ -202,6 +202,42 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "true  == true " => true,
       "false == false" => true,
       "true == false"  => false,
+
+      "Timestamp(1) < Timestamp(2)"  => true,
+      "Timespan(1) < Timespan(2)"    => true,
+      "Timestamp(1) > Timestamp(2)"  => false,
+      "Timespan(1) > Timespan(2)"    => false,
+      "Timestamp(1) == Timestamp(1)" => true,
+      "Timespan(1) == Timespan(1)"   => true,
+
+      "1 < Timestamp(2)"  => true,
+      "1 < Timespan(2)"   => true,
+      "1 > Timestamp(2)"  => false,
+      "1 > Timespan(2)"   => false,
+      "1 == Timestamp(1)" => true,
+      "1 == Timespan(1)"  => true,
+
+      "1.0 < Timestamp(2)"  => true,
+      "1.0 < Timespan(2)"   => true,
+      "1.0 > Timestamp(2)"  => false,
+      "1.0 > Timespan(2)"   => false,
+      "1.0 == Timestamp(1)" => true,
+      "1.0 == Timespan(1)"  => true,
+
+      "Timestamp(1) < 2"  => true,
+      "Timespan(1) < 2"   => true,
+      "Timestamp(1) > 2"  => false,
+      "Timespan(1) > 2"   => false,
+      "Timestamp(1) == 1" => true,
+      "Timespan(1) == 1"  => true,
+
+      "Timestamp(1) < 2.0"  => true,
+      "Timespan(1) < 2.0"   => true,
+      "Timestamp(1) > 2.0"  => false,
+      "Timespan(1) > 2.0"   => false,
+      "Timestamp(1) == 1.0" => true,
+      "Timespan(1) == 1.0"  => true,
+
     }.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)
@@ -442,26 +478,21 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       }.each do |source, coerced_val|
           it "should warn about numeric coercion in '#{source}' when strict = warning" do
             Puppet[:strict] = :warning
-            expect(Puppet::Pops::Evaluator::Runtime3Support::EvaluationError).not_to receive(:new)
             collect_notices(source)
             expect(warnings).to include(/The string '#{coerced_val}' was automatically coerced to the numerical value #{coerced_val}/)
           end
 
           it "should not warn about numeric coercion in '#{source}' if strict = off" do
             Puppet[:strict] = :off
-            expect(Puppet::Pops::Evaluator::Runtime3Support::EvaluationError).not_to receive(:new)
             collect_notices(source)
             expect(warnings).to_not include(/The string '#{coerced_val}' was automatically coerced to the numerical value #{coerced_val}/)
           end
 
         it "should error when finding numeric coercion in '#{source}' if strict = error" do
           Puppet[:strict] = :error
-          expect {
-            parser.evaluate_string(scope, source, __FILE__)
-          }.to raise_error {|error|
-            expect(error.message).to match(/The string '#{coerced_val}' was automatically coerced to the numerical value #{coerced_val}/)
-            expect(error.backtrace.first).to match(/runtime3_support\.rb.+optionally_fail/)
-          }
+          expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(
+            /The string '#{coerced_val}' was automatically coerced to the numerical value #{coerced_val}/
+            )
         end
       end
 
@@ -1108,14 +1139,14 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
 
       it 'does not map :undef to empty string in arrays' do
         Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0][0] }
-        expect(parser.evaluate_string(scope, "$a = {} $b = [$a[nope]] bazinga($b)", __FILE__)).to eq(:undef)
-        expect(parser.evaluate_string(scope, "bazinga([undef])", __FILE__)).to eq(:undef)
+        expect(parser.evaluate_string(scope, "$a = {} $b = [$a[nope]] bazinga($b)", __FILE__)).to eq(nil)
+        expect(parser.evaluate_string(scope, "bazinga([undef])", __FILE__)).to eq(nil)
       end
 
       it 'does not map :undef to empty string in hashes' do
         Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0]['a'] }
-        expect(parser.evaluate_string(scope, "$a = {} $b = {a => $a[nope]} bazinga($b)", __FILE__)).to eq(:undef)
-        expect(parser.evaluate_string(scope, "bazinga({a => undef})", __FILE__)).to eq(:undef)
+        expect(parser.evaluate_string(scope, "$a = {} $b = {a => $a[nope]} bazinga($b)", __FILE__)).to eq(nil)
+        expect(parser.evaluate_string(scope, "bazinga({a => undef})", __FILE__)).to eq(nil)
       end
     end
   end
@@ -1420,14 +1451,14 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     it 'for non r-value producing define' do
-      expect(Puppet::Util::Log).to receive(:create).with(hash_including(:level => :err, :message => "Invalid use of expression. A 'define' expression does not produce a value", :line => 1, :pos => 6))
-      expect(Puppet::Util::Log).to receive(:create).with(hash_including(:level => :err, :message => 'Classes, definitions, and nodes may only appear at toplevel or inside other classes', :line => 1, :pos => 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
-      expect(Puppet::Util::Log).to receive(:create).with(hash_including(:level => :err, :message => 'Invalid use of expression. A Host Class Definition does not produce a value', :line => 1, :pos => 6))
-      expect(Puppet::Util::Log).to receive(:create).with(hash_including(:level => :err, :message => 'Classes, definitions, and nodes may only appear at toplevel or inside other classes', :line => 1, :pos => 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
 
@@ -1441,8 +1472,8 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     it 'for multiple errors with a summary exception' do
-      expect(Puppet::Util::Log).to receive(:create).with(hash_including(:level => :err, :message => 'Invalid use of expression. A Node Definition does not produce a value', :line => 1, :pos => 6))
-      expect(Puppet::Util::Log).to receive(:create).with(hash_including(:level => :err, :message => 'Classes, definitions, and nodes may only appear at toplevel or inside other classes', :line => 1, :pos => 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
 
@@ -1497,6 +1528,35 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
   end
 
+  context 'with --tasks' do
+    before(:each) do
+      Puppet[:tasks] = true
+    end
+
+    context 'when evaluating apply' do
+      let(:applicator) { mock('apply_executor') }
+
+      it 'invokes an apply_executor' do
+        applicator.expects(:apply).with(['arg1', 'arg2'], nil, scope).returns(:result)
+        src = "apply('arg1', 'arg2') { }"
+        Puppet.override(apply_executor: applicator) do
+          expect(parser.evaluate_string(scope, src)).to eq(:result)
+        end
+      end
+
+      it 'passes the declared ast' do
+        applicator.expects(:apply).with(
+          [['arg1']],
+          instance_of(Puppet::Pops::Model::ResourceExpression),
+          scope).returns(:result)
+        src = "apply(['arg1']) { notify { 'hello': } }"
+        Puppet.override(apply_executor: applicator) do
+          expect(parser.evaluate_string(scope, src)).to eq(:result)
+        end
+      end
+    end
+  end
+
   matcher :have_relationship do |expected|
     match do |compiler|
       op_name = {'->' => :relationship, '~>' => :subscription}