puppet 6.4.0-x64-mingw32 → 6.4.1-x64-mingw32

data/spec/unit/parser/templatewrapper_spec.rb

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

data/spec/unit/parser/type_loader_spec.rb

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

data/spec/unit/pops/adaptable_spec.rb

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

data/spec/unit/pops/benchmark_spec.rb

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1487,14 +1487,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
 
@@ -1508,8 +1508,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
 
@@ -1570,10 +1570,10 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     context 'when evaluating apply' do
-      let(:applicator) { mock('apply_executor') }
+      let(:applicator) { double('apply_executor') }
 
       it 'invokes an apply_executor' do
-        applicator.expects(:apply).with(['arg1', 'arg2'], nil, scope).returns(:result)
+        expect(applicator).to receive(:apply).with(['arg1', 'arg2'], nil, scope).and_return(:result)
         src = "apply('arg1', 'arg2') { }"
         Puppet.override(apply_executor: applicator) do
           expect(parser.evaluate_string(scope, src)).to eq(:result)
@@ -1581,10 +1581,10 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       end
 
       it 'passes the declared ast' do
-        applicator.expects(:apply).with(
+        expect(applicator).to receive(:apply).with(
           [['arg1']],
           instance_of(Puppet::Pops::Model::ResourceExpression),
-          scope).returns(:result)
+          scope).and_return(:result)
         src = "apply(['arg1']) { notify { 'hello': } }"
         Puppet.override(apply_executor: applicator) do
           expect(parser.evaluate_string(scope, src)).to eq(:result)
@@ -1615,5 +1615,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'

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_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)

data/spec/unit/pops/issues_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
 
@@ -31,7 +30,7 @@ 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, args)
@@ -63,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
 
@@ -83,27 +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') )
-      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'}))
+      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
@@ -111,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')
@@ -119,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/)
@@ -127,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/)
@@ -137,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/)
@@ -146,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/)
@@ -157,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/)
@@ -168,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/)
@@ -178,7 +177,7 @@ 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/)
@@ -201,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/)