puppet 5.3.4 → 6.29.0

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,21 +478,26 @@ 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(
-            /The string '#{coerced_val}' was automatically coerced to the numerical value #{coerced_val}/
-            )
+          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/)
+          }
         end
       end
 
@@ -1103,14 +1144,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
@@ -1146,7 +1187,6 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       source = '"value is ${{a=>1,b=>2}} yo"'
       # This test requires testing against two options because a hash to string
       # produces a result that is unordered
-      hashstr = {'a' => 1, 'b' => 2}.to_s
       alt_results = ["value is {a => 1, b => 2} yo", "value is {b => 2, a => 1} yo" ]
       populate
       parse_result = parser.evaluate_string(scope, source, __FILE__)
@@ -1350,6 +1390,24 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       expect(parser.evaluate_string(scope, src)).to eq('dGhlIHF1aWNrIHJlZCBmb3g=')
     end
 
+    it "parses pp syntax checked specification" do
+      src = <<-CODE
+      @(END:pp)
+        $x = 42
+        |- END
+      CODE
+      expect(parser.evaluate_string(scope, src)).to eq('$x = 42')
+    end
+
+    it "parses epp syntax checked specification" do
+      src = <<-CODE
+      @(END:epp)
+        <% $x = 42 %><%= $x %>
+        |- END
+      CODE
+      expect(parser.evaluate_string(scope, src)).to eq('<% $x = 42 %><%= $x %>')
+    end
+
     it "parses json syntax checked specification with error and reports it" do
       src = <<-CODE
       @(END:json)
@@ -1368,6 +1426,24 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       expect { parser.evaluate_string(scope, src)}.to raise_error(/Cannot parse invalid Base64 string/)
     end
 
+    it "parses pp syntax checked specification with error and reports it" do
+      src = <<-CODE
+      @(END:pp)
+        $x ==== 42
+        |- END
+      CODE
+      expect{parser.evaluate_string(scope, src)}.to raise_error(/Invalid produced text having syntax: 'pp'/)
+    end
+
+    it "parses epp syntax checked specification with error and reports it" do
+      src = <<-CODE
+      @(END:epp)
+        <% $x ==== 42 %>
+        |- END
+      CODE
+      expect{parser.evaluate_string(scope, src)}.to raise_error(/Invalid produced text having syntax: 'epp'/)
+    end
+
     it "parses interpolated heredoc expression" do
       src = <<-CODE
       $pname = 'Fjodor'
@@ -1416,14 +1492,14 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     it 'for non r-value producing define' do
-      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(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))
       expect { parser.parse_string("$a = define foo { }", nil) }.to raise_error(/2 errors/)
     end
 
     it 'for non r-value producing class' do
-      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(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))
       expect { parser.parse_string("$a = class foo { }", nil) }.to raise_error(/2 errors/)
     end
 
@@ -1437,8 +1513,8 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     it 'for multiple errors with a summary exception' do
-      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(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))
       expect { parser.parse_string("$a = node x { }",nil) }.to raise_error(/2 errors/)
     end
 
@@ -1493,9 +1569,50 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
   end
 
-  matcher :have_relationship do |expected|
-    calc = Puppet::Pops::Types::TypeCalculator.new
+  context 'with --tasks' do
+    before(:each) do
+      Puppet[:tasks] = true
+    end
 
+    context 'when evaluating apply' do
+      let(:applicator) { double('apply_executor') }
+
+      it 'invokes an apply_executor' do
+        expect(applicator).to receive(:apply).with(
+          ['arg1', 'arg2'],
+          instance_of(Puppet::Pops::Model::BlockExpression),
+          scope).and_return(: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
+        expect(applicator).to receive(:apply).with(
+          [['arg1']],
+          instance_of(Puppet::Pops::Model::ResourceExpression),
+          scope).and_return(:result)
+        src = "apply(['arg1']) { notify { 'hello': } }"
+        Puppet.override(apply_executor: applicator) do
+          expect(parser.evaluate_string(scope, src)).to eq(:result)
+        end
+      end
+
+      it 'returns a BlockExpression with an empty apply block' do
+        expect(applicator).to receive(:apply).with(
+          [['arg1']],
+          instance_of(Puppet::Pops::Model::BlockExpression),
+          scope).and_return(:result)
+        src = "apply(['arg1']) { }"
+        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}
       compiler.relationships.any? do | relation |
@@ -1517,5 +1634,4 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       parser.evaluate_string(scope, code, __FILE__)
     end
   end
-
 end

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

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

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/pops'
@@ -30,24 +29,38 @@ describe 'when converting to 3.x' do
     expect(converter.convert(v, {}, nil)).to equal(v)
   end
 
-  it 'converts the symbol :undef to the undef value' do
-    v = SemanticPuppet::Version.parse('1.0.0')
+  it 'converts top level symbol :undef to the given undef value' do
     expect(converter.convert(:undef, {}, 'undef value')).to eql('undef value')
   end
 
-  it 'converts the nil to the undef value' do
-    v = SemanticPuppet::Version.parse('1.0.0')
+  it 'converts top level nil value to the given undef value' do
     expect(converter.convert(nil, {}, 'undef value')).to eql('undef value')
   end
 
-  it 'does not convert a symbol nested in an array' do
-    v = SemanticPuppet::Version.parse('1.0.0')
-    expect(converter.convert({'foo' => :undef}, {}, 'undef value')).to eql({'foo' => :undef})
+  it 'converts nested :undef in a hash to nil' do
+    expect(converter.convert({'foo' => :undef}, {}, 'undef value')).to eql({'foo' => nil})
   end
 
-  it 'converts nil to :undef when nested in an array' do
-    v = SemanticPuppet::Version.parse('1.0.0')
-    expect(converter.convert({'foo' => nil}, {}, 'undef value')).to eql({'foo' => :undef})
+  it 'converts nested :undef in an array to nil' do
+    expect(converter.convert(['boo', :undef], {}, 'undef value')).to eql(['boo', nil])
+  end
+
+  it 'converts deeply nested :undef in to nil' do
+    expect(converter.convert({'foo' => [[:undef]], 'bar' => { 'x' => :undef }}, {}, 'undef value')).to eql({'foo' => [[nil]], 'bar' => { 'x' => nil}})
+  end
+
+  it 'does not converts nil to given undef value when nested in an array' do
+    expect(converter.convert({'foo' => nil}, {}, 'undef value')).to eql({'foo' => nil})
+  end
+
+  it 'does not convert top level symbols' do
+    expect(converter.convert(:default, {}, 'undef value')).to eql(:default)
+    expect(converter.convert(:whatever, {}, 'undef value')).to eql(:whatever)
+  end
+
+  it 'does not convert nested symbols' do
+    expect(converter.convert([:default], {}, 'undef value')).to eql([:default])
+    expect(converter.convert([:whatever], {}, 'undef value')).to eql([:whatever])
   end
 
   it 'does not convert a Regex instance to string' do

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

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

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

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

data/spec/unit/pops/factory_rspec_helper.rb

@@ -59,7 +59,7 @@ module FactoryRspecHelper
   end
 
   def unindent x
-    (x.gsub /^#{x[/\A\s*/]}/, '').chomp
+    x.gsub(/^#{x[/\A\s*/]}/, '').chomp
   end
   factory ||= Puppet::Pops::Model::Factory
 end

data/spec/unit/pops/factory_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
 require File.join(File.dirname(__FILE__), '/factory_rspec_helper')
@@ -45,9 +44,9 @@ describe Puppet::Pops::Model::Factory do
     end
 
     it "Multiple expressions should produce a block expression" do
-      braces = mock 'braces'
-      braces.stubs(:offset).returns(0)
-      braces.stubs(:length).returns(0)
+      braces = double('braces')
+      allow(braces).to receive(:offset).and_return(0)
+      allow(braces).to receive(:length).and_return(0)
 
       model = block_or_expression([literal(1) + literal(2), literal(2) + literal(3)], braces, braces).model
       expect(model.is_a?(Puppet::Pops::Model::BlockExpression)).to eq(true)
@@ -191,7 +190,7 @@ describe Puppet::Pops::Model::Factory do
     it "should handle 'just a string'" do
       model = string('blah blah').model
       expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      model.segments.size == 1
+      expect(model.segments.size).to eq(1)
       expect(model.segments[0].class).to eq(Puppet::Pops::Model::LiteralString)
       expect(model.segments[0].value).to eq("blah blah")
     end
@@ -199,7 +198,7 @@ describe Puppet::Pops::Model::Factory do
     it "should handle one expression in the middle" do
       model = string('blah blah', TEXT(literal(1)+literal(2)), 'blah blah').model
       expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      model.segments.size == 3
+      expect(model.segments.size).to eq(3)
       expect(model.segments[0].class).to eq(Puppet::Pops::Model::LiteralString)
       expect(model.segments[0].value).to eq("blah blah")
       expect(model.segments[1].class).to eq(Puppet::Pops::Model::TextExpression)
@@ -211,7 +210,7 @@ describe Puppet::Pops::Model::Factory do
     it "should handle one expression at the end" do
       model = string('blah blah', TEXT(literal(1)+literal(2))).model
       expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      model.segments.size == 2
+      expect(model.segments.size).to eq(2)
       expect(model.segments[0].class).to eq(Puppet::Pops::Model::LiteralString)
       expect(model.segments[0].value).to eq("blah blah")
       expect(model.segments[1].class).to eq(Puppet::Pops::Model::TextExpression)
@@ -221,7 +220,7 @@ describe Puppet::Pops::Model::Factory do
     it "should handle only one expression" do
       model = string(TEXT(literal(1)+literal(2))).model
       expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      model.segments.size == 1
+      expect(model.segments.size).to eq(1)
       expect(model.segments[0].class).to eq(Puppet::Pops::Model::TextExpression)
       expect(model.segments[0].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
     end
@@ -229,7 +228,7 @@ describe Puppet::Pops::Model::Factory do
     it "should handle several expressions" do
       model = string(TEXT(literal(1)+literal(2)), TEXT(literal(1)+literal(2))).model
       expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      model.segments.size == 2
+      expect(model.segments.size).to eq(2)
       expect(model.segments[0].class).to eq(Puppet::Pops::Model::TextExpression)
       expect(model.segments[0].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
       expect(model.segments[1].class).to eq(Puppet::Pops::Model::TextExpression)

data/spec/unit/pops/issues_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
 
@@ -31,27 +30,28 @@ describe "Puppet::Pops::IssueReporter" do
   let(:acceptor) { Puppet::Pops::Validation::Acceptor.new }
 
   def fake_positioned(number)
-    stub("positioned_#{number}", :line => number, :pos => number)
+    double("positioned_#{number}", :line => number, :pos => number)
   end
 
-  def diagnostic(severity,  number)
+  def diagnostic(severity,  number, args)
     Puppet::Pops::Validation::Diagnostic.new(
       severity,
       Puppet::Pops::Issues::Issue.new(number) { "#{severity}#{number}" },
       "#{severity}file",
-      fake_positioned(number))
+      fake_positioned(number),
+      args)
   end
 
-  def warning(number)
-    diagnostic(:warning, number)
+  def warning(number, args = {})
+    diagnostic(:warning, number, args)
   end
 
-  def deprecation(number)
-    diagnostic(:deprecation, number)
+  def deprecation(number, args = {})
+    diagnostic(:deprecation, number, args)
   end
 
-  def error(number)
-    diagnostic(:error, number)
+  def error(number, args = {})
+    diagnostic(:error, number, args)
   end
 
   context "given warnings" do
@@ -62,19 +62,19 @@ describe "Puppet::Pops::IssueReporter" do
     end
 
     it "emits warnings if told to emit them" do
-      Puppet::Log.expects(:create).twice.with(has_entries(:level => :warning, :message => regexp_matches(/warning1|deprecation1/)))
+      expect(Puppet::Log).to receive(:create).twice.with(hash_including(:level => :warning, :message => match(/warning1|deprecation1/)))
       Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
     end
 
     it "does not emit warnings if not told to emit them" do
-      Puppet::Log.expects(:create).never
+      expect(Puppet::Log).not_to receive(:create)
       Puppet::Pops::IssueReporter.assert_and_report(acceptor, {})
     end
 
     it "emits no warnings if :max_warnings is 0" do
       acceptor.accept( warning(2) )
       Puppet[:max_warnings] = 0
-      Puppet::Log.expects(:create).once.with(has_entries(:level => :warning, :message => regexp_matches(/deprecation1/)))
+      expect(Puppet::Log).to receive(:create).once.with(hash_including(:level => :warning, :message => match(/deprecation1/)))
       Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
     end
 
@@ -82,20 +82,27 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( warning(2) )
       acceptor.accept( warning(3) )
       Puppet[:max_warnings] = 1
-      Puppet::Log.expects(:create).twice.with(has_entries(:level => :warning, :message => regexp_matches(/warning1|deprecation1/)))
+      expect(Puppet::Log).to receive(:create).twice.with(hash_including(:level => :warning, :message => match(/warning1|deprecation1/)))
       Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
     end
 
     it "does not emit more deprecations warnings than the max deprecation warnings" do
       acceptor.accept( deprecation(2) )
       Puppet[:max_deprecations] = 0
-      Puppet::Log.expects(:create).once.with(has_entries(:level => :warning, :message => regexp_matches(/warning1/)))
+      expect(Puppet::Log).to receive(:create).once.with(hash_including(:level => :warning, :message => match(/warning1/)))
       Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
     end
 
     it "does not emit deprecation warnings, but does emit regular warnings if disable_warnings includes deprecations" do
       Puppet[:disable_warnings] = 'deprecations'
-      Puppet::Log.expects(:create).once.with(has_entries(:level => :warning, :message => regexp_matches(/warning1/)))
+      expect(Puppet::Log).to receive(:create).once.with(hash_including(:level => :warning, :message => match(/warning1/)))
+      Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
+    end
+
+    it "includes diagnostic arguments in logged entry" do
+      acceptor.accept( warning(2, :n => 'a') )
+      expect(Puppet::Log).to receive(:create).twice.with(hash_including(:level => :warning, :message => match(/warning1|deprecation1/)))
+      expect(Puppet::Log).to receive(:create).once.with(hash_including(:level => :warning, :message => match(/warning2/), :arguments => {:n => 'a'}))
       Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
     end
   end
@@ -103,7 +110,7 @@ describe "Puppet::Pops::IssueReporter" do
   context "given errors" do
     it "logs nothing, but raises the given :message if :emit_errors is repressing error logging" do
       acceptor.accept( error(1) )
-      Puppet::Log.expects(:create).never
+      expect(Puppet::Log).not_to receive(:create)
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_errors => false, :message => 'special'})
       end.to raise_error(Puppet::ParseError, 'special')
@@ -111,7 +118,7 @@ describe "Puppet::Pops::IssueReporter" do
 
     it "prefixes :message if a single error is raised" do
       acceptor.accept( error(1) )
-      Puppet::Log.expects(:create).never
+      expect(Puppet::Log).not_to receive(:create)
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :message => 'special'})
       end.to raise_error(Puppet::ParseError, /special error1/)
@@ -119,7 +126,7 @@ describe "Puppet::Pops::IssueReporter" do
 
     it "logs nothing and raises immediately if there is only one error" do
       acceptor.accept( error(1) )
-      Puppet::Log.expects(:create).never
+      expect(Puppet::Log).not_to receive(:create)
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /error1/)
@@ -129,7 +136,7 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( error(1) )
       acceptor.accept( error(2) )
       Puppet[:max_errors] = 0
-      Puppet::Log.expects(:create).never
+      expect(Puppet::Log).not_to receive(:create)
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /error1/)
@@ -138,7 +145,7 @@ describe "Puppet::Pops::IssueReporter" do
     it "logs the :message if there is more than one allowed error" do
       acceptor.accept( error(1) )
       acceptor.accept( error(2) )
-      Puppet::Log.expects(:create).times(3).with(has_entries(:level => :err, :message => regexp_matches(/error1|error2|special/)))
+      expect(Puppet::Log).to receive(:create).exactly(3).times.with(hash_including(:level => :err, :message => match(/error1|error2|special/)))
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :message => 'special'})
       end.to raise_error(Puppet::ParseError, /Giving up/)
@@ -149,7 +156,7 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( error(2) )
       acceptor.accept( error(3) )
       Puppet[:max_errors] = 2
-      Puppet::Log.expects(:create).times(2).with(has_entries(:level => :err, :message => regexp_matches(/error1|error2/)))
+      expect(Puppet::Log).to receive(:create).twice.with(hash_including(:level => :err, :message => match(/error1|error2/)))
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /3 errors.*Giving up/)
@@ -160,7 +167,7 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( error(2) )
       acceptor.accept( error(3) )
       Puppet[:max_errors] = 4
-      Puppet::Log.expects(:create).times(3).with(has_entries(:level => :err, :message => regexp_matches(/error[123]/)))
+      expect(Puppet::Log).to receive(:create).exactly(3).times.with(hash_including(:level => :err, :message => match(/error[123]/)))
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /3 errors.*Giving up/)
@@ -170,11 +177,18 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( error(1) )
       acceptor.accept( error(2) )
       Puppet[:disable_warnings] = 'deprecations'
-      Puppet::Log.expects(:create).times(2).with(has_entries(:level => :err, :message => regexp_matches(/error1|error2/)))
+      expect(Puppet::Log).to receive(:create).twice.with(hash_including(:level => :err, :message => match(/error1|error2/)))
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /Giving up/)
     end
+
+    it "includes diagnostic arguments in raised error" do
+      acceptor.accept( error(1, :n => 'a') )
+      expect do
+        Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
+      end.to raise_error(Puppet::ParseErrorWithIssue, /error1/) { |ex| expect(ex.arguments).to eq(:n => 'a')}
+    end
   end
 
   context "given both" do
@@ -186,8 +200,8 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( error(3) )
       acceptor.accept( deprecation(1) )
       Puppet[:max_errors] = 2
-      Puppet::Log.expects(:create).twice.with(has_entries(:level => :warning, :message => regexp_matches(/warning1|deprecation1/)))
-      Puppet::Log.expects(:create).twice.with(has_entries(:level => :err, :message => regexp_matches(/error[123]/)))
+      expect(Puppet::Log).to receive(:create).twice.with(hash_including(:level => :warning, :message => match(/warning1|deprecation1/)))
+      expect(Puppet::Log).to receive(:create).twice.with(hash_including(:level => :err, :message => match(/error[123]/)))
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
       end.to raise_error(Puppet::ParseError, /3 errors.*2 warnings.*Giving up/)

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

@@ -84,7 +84,7 @@ Puppet::Functions.create_function('testmodule::foo') {
 
       context 'when loading files from disk' do
         it 'should always read files as UTF-8' do
-          if Puppet.features.microsoft_windows? && Encoding.default_external == Encoding::UTF_8
+          if Puppet::Util::Platform.windows? && Encoding.default_external == Encoding::UTF_8
             raise 'This test must be run in a codepage other than 65001 to validate behavior'
           end
 
@@ -102,7 +102,7 @@ Puppet::Functions.create_function('testmodule::foo') {
         it 'currently ignores the UTF-8 BOM (Byte Order Mark) when loading module files' do
           bom = "\uFEFF"
 
-          if Puppet.features.microsoft_windows? && Encoding.default_external == Encoding::UTF_8
+          if Puppet::Util::Platform.windows? && Encoding.default_external == Encoding::UTF_8
             raise 'This test must be run in a codepage other than 65001 to validate behavior'
           end