puppet 6.0.10 → 6.1.0

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'
 

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

@@ -1385,6 +1385,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)
@@ -1403,6 +1421,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'
@@ -1451,14 +1487,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
 
@@ -1472,8 +1508,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
 
@@ -1534,10 +1570,10 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     context 'when evaluating apply' do
-      let(:applicator) { double('apply_executor') }
+      let(:applicator) { mock('apply_executor') }
 
       it 'invokes an apply_executor' do
-        expect(applicator).to receive(:apply).with(['arg1', 'arg2'], nil, scope).and_return(:result)
+        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)
@@ -1545,10 +1581,10 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       end
 
       it 'passes the declared ast' do
-        expect(applicator).to receive(:apply).with(
+        applicator.expects(:apply).with(
           [['arg1']],
           instance_of(Puppet::Pops::Model::ResourceExpression),
-          scope).and_return(:result)
+          scope).returns(:result)
         src = "apply(['arg1']) { notify { 'hello': } }"
         Puppet.override(apply_executor: applicator) do
           expect(parser.evaluate_string(scope, src)).to eq(:result)
@@ -1579,4 +1615,5 @@ 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,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/pops'

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

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

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

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

data/spec/unit/pops/evaluator/variables_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/factory_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
 require File.join(File.dirname(__FILE__), '/factory_rspec_helper')
@@ -44,9 +45,9 @@ describe Puppet::Pops::Model::Factory do
     end
 
     it "Multiple expressions should produce a block expression" do
-      braces = double('braces')
-      allow(braces).to receive(:offset).and_return(0)
-      allow(braces).to receive(:length).and_return(0)
+      braces = mock 'braces'
+      braces.stubs(:offset).returns(0)
+      braces.stubs(:length).returns(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)

data/spec/unit/pops/issues_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
 
@@ -30,7 +31,7 @@ describe "Puppet::Pops::IssueReporter" do
   let(:acceptor) { Puppet::Pops::Validation::Acceptor.new }
 
   def fake_positioned(number)
-    double("positioned_#{number}", :line => number, :pos => number)
+    stub("positioned_#{number}", :line => number, :pos => number)
   end
 
   def diagnostic(severity,  number, args)
@@ -62,19 +63,19 @@ describe "Puppet::Pops::IssueReporter" do
     end
 
     it "emits warnings if told to emit them" do
-      expect(Puppet::Log).to receive(:create).twice.with(hash_including(:level => :warning, :message => match(/warning1|deprecation1/)))
+      Puppet::Log.expects(:create).twice.with(has_entries(:level => :warning, :message => regexp_matches(/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
-      expect(Puppet::Log).not_to receive(:create)
+      Puppet::Log.expects(:create).never
       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
-      expect(Puppet::Log).to receive(:create).once.with(hash_including(:level => :warning, :message => match(/deprecation1/)))
+      Puppet::Log.expects(:create).once.with(has_entries(:level => :warning, :message => regexp_matches(/deprecation1/)))
       Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
     end
 
@@ -82,27 +83,27 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( warning(2) )
       acceptor.accept( warning(3) )
       Puppet[:max_warnings] = 1
-      expect(Puppet::Log).to receive(:create).twice.with(hash_including(:level => :warning, :message => match(/warning1|deprecation1/)))
+      Puppet::Log.expects(:create).twice.with(has_entries(:level => :warning, :message => regexp_matches(/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
-      expect(Puppet::Log).to receive(:create).once.with(hash_including(:level => :warning, :message => match(/warning1/)))
+      Puppet::Log.expects(:create).once.with(has_entries(:level => :warning, :message => regexp_matches(/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'
-      expect(Puppet::Log).to receive(:create).once.with(hash_including(:level => :warning, :message => match(/warning1/)))
+      Puppet::Log.expects(:create).once.with(has_entries(:level => :warning, :message => regexp_matches(/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::Log.expects(:create).twice.with(has_entries(:level => :warning, :message => regexp_matches(/warning1|deprecation1/)))
+      Puppet::Log.expects(:create).once.with(has_entries(:level => :warning, :message => regexp_matches(/warning2/), :arguments => {:n => 'a'}))
       Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
     end
   end
@@ -110,7 +111,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) )
-      expect(Puppet::Log).not_to receive(:create)
+      Puppet::Log.expects(:create).never
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_errors => false, :message => 'special'})
       end.to raise_error(Puppet::ParseError, 'special')
@@ -118,7 +119,7 @@ describe "Puppet::Pops::IssueReporter" do
 
     it "prefixes :message if a single error is raised" do
       acceptor.accept( error(1) )
-      expect(Puppet::Log).not_to receive(:create)
+      Puppet::Log.expects(:create).never
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :message => 'special'})
       end.to raise_error(Puppet::ParseError, /special error1/)
@@ -126,7 +127,7 @@ describe "Puppet::Pops::IssueReporter" do
 
     it "logs nothing and raises immediately if there is only one error" do
       acceptor.accept( error(1) )
-      expect(Puppet::Log).not_to receive(:create)
+      Puppet::Log.expects(:create).never
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /error1/)
@@ -136,7 +137,7 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( error(1) )
       acceptor.accept( error(2) )
       Puppet[:max_errors] = 0
-      expect(Puppet::Log).not_to receive(:create)
+      Puppet::Log.expects(:create).never
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /error1/)
@@ -145,7 +146,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) )
-      expect(Puppet::Log).to receive(:create).exactly(3).times.with(hash_including(:level => :err, :message => match(/error1|error2|special/)))
+      Puppet::Log.expects(:create).times(3).with(has_entries(:level => :err, :message => regexp_matches(/error1|error2|special/)))
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :message => 'special'})
       end.to raise_error(Puppet::ParseError, /Giving up/)
@@ -156,7 +157,7 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( error(2) )
       acceptor.accept( error(3) )
       Puppet[:max_errors] = 2
-      expect(Puppet::Log).to receive(:create).twice.with(hash_including(:level => :err, :message => match(/error1|error2/)))
+      Puppet::Log.expects(:create).times(2).with(has_entries(:level => :err, :message => regexp_matches(/error1|error2/)))
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /3 errors.*Giving up/)
@@ -167,7 +168,7 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( error(2) )
       acceptor.accept( error(3) )
       Puppet[:max_errors] = 4
-      expect(Puppet::Log).to receive(:create).exactly(3).times.with(hash_including(:level => :err, :message => match(/error[123]/)))
+      Puppet::Log.expects(:create).times(3).with(has_entries(:level => :err, :message => regexp_matches(/error[123]/)))
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /3 errors.*Giving up/)
@@ -177,7 +178,7 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( error(1) )
       acceptor.accept( error(2) )
       Puppet[:disable_warnings] = 'deprecations'
-      expect(Puppet::Log).to receive(:create).twice.with(hash_including(:level => :err, :message => match(/error1|error2/)))
+      Puppet::Log.expects(:create).times(2).with(has_entries(:level => :err, :message => regexp_matches(/error1|error2/)))
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /Giving up/)
@@ -200,8 +201,8 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( error(3) )
       acceptor.accept( deprecation(1) )
       Puppet[:max_errors] = 2
-      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]/)))
+      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 do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
       end.to raise_error(Puppet::ParseError, /3 errors.*2 warnings.*Giving up/)