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

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

@@ -364,8 +364,10 @@ describe 'The Loader' do
           end
 
           it 'discover is only called once on dependent loader' do
-            ModuleLoaders::FileBased.any_instance.expects(:discover).times(4).with(:type, nil, Pcore::RUNTIME_NAME_AUTHORITY).returns([])
+            times_called = 0
+            allow_any_instance_of(ModuleLoaders::FileBased).to receive(:discover).with(:type, nil, Pcore::RUNTIME_NAME_AUTHORITY) { times_called += 1 }.and_return([])
             expect(loader.private_loader.discover(:type) { |t| t.name =~ /^.::.*\z/ }).to(contain_exactly())
+            expect(times_called).to eq(4)
           end
 
           context 'with tasks enabled' do
@@ -383,7 +385,7 @@ describe 'The Loader' do
 
             context 'with a yaml plan instantiator defined' do
               before :each do
-                Puppet.push_context(:yaml_plan_instantiator => mock(:create => mock('plan')))
+                Puppet.push_context(:yaml_plan_instantiator => double(:create => double('plan')))
               end
 
               after :each do
@@ -458,13 +460,13 @@ describe 'The Loader' do
               let(:env) { Puppet::Node::Environment.create(:none_such, [modules_dir]) }
 
               it 'an EmptyLoader is used and module loader finds types' do
-                Puppet::Pops::Loader::ModuleLoaders::EmptyLoader.any_instance.expects(:find).at_least_once.returns(nil)
+                expect_any_instance_of(Puppet::Pops::Loader::ModuleLoaders::EmptyLoader).to receive(:find).and_return(nil)
                 expect(Loaders.find_loader('a').discover(:type) { |t| t.name =~ /^.::.*\z/ }).to(
                   contain_exactly(tn(:type, 'a::atype')))
               end
 
               it 'an EmptyLoader is used and module loader finds tasks' do
-                Puppet::Pops::Loader::ModuleLoaders::EmptyLoader.any_instance.expects(:find).at_least_once.returns(nil)
+                expect_any_instance_of(Puppet::Pops::Loader::ModuleLoaders::EmptyLoader).to receive(:find).and_return(nil)
                 expect(Loaders.find_loader('a').discover(:task) { |t| t.name =~ /^.::.*\z/ }).to(
                   contain_exactly(tn(:task, 'a::atask')))
               end
@@ -495,8 +497,10 @@ describe 'The Loader' do
             end
 
             it 'discover is only called once on dependent loader' do
-              ModuleLoaders::FileBased.any_instance.expects(:discover).times(4).with(:type, nil, Pcore::RUNTIME_NAME_AUTHORITY).returns([])
+              times_called = 0
+              allow_any_instance_of(ModuleLoaders::FileBased).to receive(:discover).with(:type, nil, Pcore::RUNTIME_NAME_AUTHORITY) { times_called += 1 }.and_return([])
               expect(loader.private_loader.discover(:type) { |t| t.name =~ /^.::.*\z/ }).to(contain_exactly())
+              expect(times_called).to eq(4)
             end
           end
         end

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

@@ -167,9 +167,9 @@ describe 'loaders' do
     end
 
     it 'loader allows loading a function more than once' do
-      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns ''
-      File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
-      File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return('')
+      allow(File).to receive(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
+      allow(File).to receive(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
 
       env = environment_for(File.join(dependent_modules_with_metadata, 'modules'))
       loaders = Puppet::Pops::Loaders.new(env)
@@ -228,9 +228,9 @@ describe 'loaders' do
     end
 
     it 'all dependent modules are visible' do
-      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'}, { 'name' => 'test-usee2'} ]).to_pson
-      File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
-      File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'}, { 'name' => 'test-usee2'} ]).to_pson)
+      allow(File).to receive(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
+      allow(File).to receive(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
       loaders = Puppet::Pops::Loaders.new(env)
 
       moduleb_loader = loaders.private_loader_for_module('user')
@@ -257,10 +257,11 @@ describe 'loaders' do
         {:from => from, :called => 'a puppet function declared in init.pp', :expects => "I'm the function usee::usee_puppet_init()"},
         {:from => from, :called => 'a ruby function', :expects => "I'm the function usee::usee_ruby()"} ].each_with_index do |desc, called_idx|
         case_number = from_idx * 3 + called_idx + 1
+
         it "can call #{desc[:called]} from #{desc[:from]} when dependency is present in metadata.json" do
-          File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
-          File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
-          File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+          allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson)
+          allow(File).to receive(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
+          allow(File).to receive(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
           Puppet[:code] = "$case_number = #{case_number}\ninclude ::user"
           catalog = compiler.compile
           resource = catalog.resource('Notify', "case_#{case_number}")
@@ -269,18 +270,20 @@ describe 'loaders' do
         end
 
         it "can call #{desc[:called]} from #{desc[:from]} when no metadata is present" do
-          Puppet::Module.any_instance.expects('has_metadata?').at_least_once.returns(false)
+          times_has_metadata_called = 0
+          allow_any_instance_of(Puppet::Module).to receive('has_metadata?') { times_has_metadata_called += 1 }.and_return(false)
           Puppet[:code] = "$case_number = #{case_number}\ninclude ::user"
           catalog = compiler.compile
           resource = catalog.resource('Notify', "case_#{case_number}")
           expect(resource).not_to be_nil
           expect(resource['message']).to eq(desc[:expects])
+          expect(times_has_metadata_called).to be >= 1
         end
 
         it "can not call #{desc[:called]} from #{desc[:from]} if dependency is missing in existing metadata.json" do
-          File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => []).to_pson
-          File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
-          File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+          allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => []).to_pson)
+          allow(File).to receive(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
+          allow(File).to receive(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
           Puppet[:code] = "$case_number = #{case_number}\ninclude ::user"
           catalog = compiler.compile
           resource = catalog.resource('Notify', "case_#{case_number}")
@@ -291,9 +294,9 @@ describe 'loaders' do
     end
 
     it "a type can reference an autoloaded type alias from another module when dependency is present in metadata.json" do
-      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
-      File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
-      File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson)
+      allow(File).to receive(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
+      allow(File).to receive(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
         assert_type(Usee::Zero, 0)
         notice(ok)
@@ -301,7 +304,7 @@ describe 'loaders' do
     end
 
     it "a type can reference an autoloaded type alias from another module when no metadata is present" do
-      Puppet::Module.any_instance.expects('has_metadata?').at_least_once.returns(false)
+      expect_any_instance_of(Puppet::Module).to receive('has_metadata?').at_least(:once).and_return(false)
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
         assert_type(Usee::Zero, 0)
         notice(ok)
@@ -309,9 +312,9 @@ describe 'loaders' do
     end
 
     it "a type can reference a type alias from another module when other module has it declared in init.pp" do
-      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
-      File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
-      File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson)
+      allow(File).to receive(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
+      allow(File).to receive(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
         include 'usee'
         assert_type(Usee::One, 1)
@@ -320,9 +323,9 @@ describe 'loaders' do
     end
 
     it "an autoloaded type can reference an autoloaded type alias from another module when dependency is present in metadata.json" do
-      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
-      File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
-      File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson)
+      allow(File).to receive(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
+      allow(File).to receive(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
         assert_type(User::WithUseeZero, [0])
         notice(ok)
@@ -330,9 +333,9 @@ describe 'loaders' do
     end
 
     it "an autoloaded type can reference an autoloaded type alias from another module when other module has it declared in init.pp" do
-      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
-      File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
-      File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson)
+      allow(File).to receive(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
+      allow(File).to receive(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
         include 'usee'
         assert_type(User::WithUseeOne, [1])
@@ -376,7 +379,7 @@ describe 'loaders' do
         catalog = compiler.compile
         expect(catalog.resource('Notify[first]')).to be_a(Puppet::Resource)
 
-        Puppet::Pops::Loader::RubyFunctionInstantiator.expects(:create).never
+        expect(Puppet::Pops::Loader::RubyFunctionInstantiator).not_to receive(:create)
         compiler = Puppet::Parser::Compiler.new(node)
         compiler.topscope['value_from_scope'] = 'second'
         catalog = compiler.compile
@@ -527,7 +530,7 @@ end
       Puppet::Parser::Functions::newfunction(:callee, :type => :rvalue, :arity => 1) do |args|
         function_callee_ws(['passed in scope'])
       end
-      Puppet.expects(:warning).with(any_parameters).never
+      expect(Puppet).not_to receive(:warning)
       scope['passed_in_scope'] = 'value'
       function = loader.load_typed(typed_name(:function, 'callee')).value
       expect(function.call(scope, 'passed in scope')).to eql("usee::callee_ws() got 'value'")

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

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

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet'
 
@@ -39,11 +38,11 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
   let(:lookup_invocation) { Lookup::Invocation.new(scope, {}, {}, nil) }
 
   before(:each) do
-    Lookup::Invocation.any_instance.stubs(:lookup_adapter).returns(adapter)
+    allow_any_instance_of(Lookup::Invocation).to receive(:lookup_adapter).and_return(adapter)
   end
 
   def expect_lookup(*keys)
-    keys.each { |key| adapter.expects(:track).with(key) }
+    keys.each { |key| expect(adapter).to receive(:track).with(key) }
   end
 
   context 'when interpolating nested data' do

data/spec/unit/pops/merge_strategy_spec.rb

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

data/spec/unit/pops/migration_spec.rb

@@ -34,20 +34,18 @@ describe 'Puppet::Pops::MigrationMigrationChecker' do
   describe "when there is no MigrationChecker in the PuppetContext" do
     it "a null implementation of the MigrationChecker gets created (once per impl that needs one)" do
       migration_checker = Puppet::Pops::Migration::MigrationChecker.new()
-      Puppet::Pops::Migration::MigrationChecker.expects(:new).at_least_once.returns(migration_checker)
+      expect(Puppet::Pops::Migration::MigrationChecker).to receive(:new).at_least(:once).and_return(migration_checker)
       expect(Puppet::Pops::Parser::EvaluatingParser.new.evaluate_string(scope, "1", __FILE__)).to eq(1)
-      Puppet::Pops::Migration::MigrationChecker.unstub(:new)
     end
   end
 
   describe "when there is a MigrationChecker in the Puppet Context" do
     it "does not create any MigrationChecker instances when parsing and evaluating" do
-      migration_checker = mock()
-      Puppet::Pops::Migration::MigrationChecker.expects(:new).never
+      migration_checker = double()
+      expect(Puppet::Pops::Migration::MigrationChecker).not_to receive(:new)
       Puppet.override({:migration_checker => migration_checker}, "test-context") do
         Puppet::Pops::Parser::EvaluatingParser.new.evaluate_string(scope, "true", __FILE__)
       end
-      Puppet::Pops::Migration::MigrationChecker.unstub(:new)
     end
   end
 end

data/spec/unit/pops/model/model_spec.rb

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

data/spec/unit/pops/model/pn_transformer_spec.rb

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

data/spec/unit/pops/parser/locator_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 require 'puppet/pops'
 
 describe Puppet::Pops::Parser::Locator do
-
   it "multi byte characters in a comment does not interfere with AST node text extraction" do
     parser = Puppet::Pops::Parser::Parser.new()
     model = parser.parse_string("# \u{0400}comment\nabcdef#XXXXXXXXXX").model
@@ -22,20 +21,18 @@ describe Puppet::Pops::Parser::Locator do
   end
 
   it 'Locator caches last offset / line' do
-    #Puppet::Pops::Parser::Locator::AbstractLocator.expects(:ary_bsearch_i).once
     parser = Puppet::Pops::Parser::Parser.new()
     model = parser.parse_string("$a\n = 1\n + 1\n").model
-    model.body.locator.expects(:ary_bsearch_i).with(anything, 2).once.returns(:special_value)
+    expect(model.body.locator).to receive(:ary_bsearch_i).with(anything, 2).once.and_return(:special_value)
     expect(model.body.locator.line_for_offset(2)).to eq(:special_value)
     expect(model.body.locator.line_for_offset(2)).to eq(:special_value)
   end
 
   it 'Locator invalidates last offset / line cache if asked for different offset' do
-    #Puppet::Pops::Parser::Locator::AbstractLocator.expects(:ary_bsearch_i).once
     parser = Puppet::Pops::Parser::Parser.new()
     model = parser.parse_string("$a\n = 1\n + 1\n").model
-    model.body.locator.expects(:ary_bsearch_i).with(anything, 2).twice.returns(:first_value, :third_value)
-    model.body.locator.expects(:ary_bsearch_i).with(anything, 3).once.returns(:second_value)
+    expect(model.body.locator).to receive(:ary_bsearch_i).with(anything, 2).twice.and_return(:first_value, :third_value)
+    expect(model.body.locator).to receive(:ary_bsearch_i).with(anything, 3).once.and_return(:second_value)
     expect(model.body.locator.line_for_offset(2)).to eq(:first_value)
     expect(model.body.locator.line_for_offset(3)).to eq(:second_value) # invalidates cache as side effect
     expect(model.body.locator.line_for_offset(2)).to eq(:third_value)

data/spec/unit/pops/parser/parse_application_spec.rb

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

data/spec/unit/pops/parser/parse_basic_expressions_spec.rb

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

data/spec/unit/pops/parser/parse_calls_spec.rb

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

data/spec/unit/pops/parser/parse_capabilities_spec.rb

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

data/spec/unit/pops/parser/parse_conditionals_spec.rb

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

data/spec/unit/pops/parser/parse_containers_spec.rb

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

data/spec/unit/pops/parser/parse_plan_spec.rb

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

data/spec/unit/pops/parser/parse_resource_spec.rb

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

data/spec/unit/pops/parser/parse_site_spec.rb

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

data/spec/unit/pops/parser/pn_parser_spec.rb

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

data/spec/unit/pops/pn_spec.rb

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

data/spec/unit/pops/resource/resource_type_impl_spec.rb

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

data/spec/unit/pops/serialization/serialization_spec.rb

@@ -424,7 +424,7 @@ module Serialization
     it 'succeeds when deserializer is aware of the referenced type' do
       obj = type.create(32)
       write(obj)
-      loaders.find_loader(nil).expects(:load).with(:type, 'mytype').returns(type)
+      expect(loaders.find_loader(nil)).to receive(:load).with(:type, 'mytype').and_return(type)
       expect(read).to eql(obj)
     end
   end

data/spec/unit/pops/serialization/to_from_hr_spec.rb

@@ -482,7 +482,7 @@ module Serialization
     it 'succeeds when deserializer is aware of the referenced type' do
       obj = type.create(32)
       write(obj)
-      loaders.find_loader(nil).expects(:load).with(:type, 'mytype').returns(type)
+      expect(loaders.find_loader(nil)).to receive(:load).with(:type, 'mytype').and_return(type)
       expect(read).to eql(obj)
     end
   end

data/spec/unit/pops/types/recursion_guard_spec.rb

@@ -61,32 +61,32 @@ describe 'the RecursionGuard' do
   end
 
   it "should not call 'hash' on an added instance" do
-    x = mock
-    x.expects(:hash).never
+    x = double()
+    expect(x).not_to receive(:hash)
     expect(guard.add_that(x)).to eq(RecursionGuard::NO_SELF_RECURSION)
   end
 
   it "should not call '==' on an added instance" do
-    x = mock
-    x.expects(:==).never
+    x = double()
+    expect(x).not_to receive(:==)
     expect(guard.add_that(x)).to eq(RecursionGuard::NO_SELF_RECURSION)
   end
 
   it "should not call 'eq?' on an added instance" do
-    x = mock
-    x.expects(:eq?).never
+    x = double()
+    expect(x).not_to receive(:eq?)
     expect(guard.add_that(x)).to eq(RecursionGuard::NO_SELF_RECURSION)
   end
 
   it "should not call 'eql?' on an added instance" do
-    x = mock
-    x.expects(:eql?).never
+    x = double()
+    expect(x).not_to receive(:eql?)
     expect(guard.add_that(x)).to eq(RecursionGuard::NO_SELF_RECURSION)
   end
 
   it "should not call 'equal?' on an added instance" do
-    x = mock
-    x.expects(:equal?).never
+    x = double()
+    expect(x).not_to receive(:equal?)
     expect(guard.add_that(x)).to eq(RecursionGuard::NO_SELF_RECURSION)
   end
 end

data/spec/unit/pops/types/ruby_generator_spec.rb

@@ -448,7 +448,7 @@ describe 'Puppet Ruby Generator' do
 
       after(:all) do
         # Don't want generated module to leak outside this test
-        PuppetSpec.send(:remove_const, :RubyGenerator)
+        PuppetSpec.send(:remove_const, :RubyGenerator) if PuppetSpec.const_defined?(:RubyGenerator)
       end
 
       it 'the #_pcore_type class method returns a resolved Type' do
@@ -765,7 +765,7 @@ describe 'Puppet Ruby Generator' do
 
       after(:all) do
         # Don't want generated module to leak outside this test
-        PuppetSpec.send(:remove_const, :RubyGenerator)
+        PuppetSpec.send(:remove_const, :RubyGenerator) if PuppetSpec.const_defined?(:RubyGenerator)
       end
 
       it 'the #_pcore_type class method returns a resolved Type' do