puppet 5.5.12-universal-darwin → 5.5.13-universal-darwin

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

@@ -422,7 +422,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

@@ -459,7 +459,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

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

@@ -24,13 +24,13 @@ describe 'the type asserter' do
   end
 
   it 'does not produce a string unless the assertion fails' do
-    TypeAsserter.expects(:report_type_mismatch).never
+    expect(TypeAsserter).not_to receive(:report_type_mismatch)
     asserter.assert_instance_of(nil, PIntegerType::DEFAULT, 1)
   end
 
   it 'does not format string unless the assertion fails' do
     fmt_string = 'The %s in the %s'
-    fmt_string.expects(:'%').never
+    expect(fmt_string).not_to receive(:'%')
     asserter.assert_instance_of([fmt_string, 'gizmo', 'gadget'], PIntegerType::DEFAULT, 1)
   end
 

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

@@ -1723,13 +1723,13 @@ describe 'The type calculator' do
       end
 
       it 'a recursive alias can be assignable from a conformant type with any depth' do
-        scope = Object.new
+        scope = double
 
         t = type_alias_t('Tree', 'Hash[String,Variant[String,Tree]]')
-        loader = Object.new
-        loader.expects(:load).with(:type, 'tree').returns t
+        loader = double
+        expect(loader).to receive(:load).with(:type, 'tree').and_return(t)
 
-        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
+        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
 
         t.resolve(scope)
         expect(calculator.assignable?(t, parser.parse('Hash[String,Variant[String,Hash[String,Variant[String,String]]]]'))).to be_truthy
@@ -1737,15 +1737,15 @@ describe 'The type calculator' do
 
 
       it 'similar recursive aliases are assignable' do
-        scope = Object.new
+        scope = double
 
         t1 = type_alias_t('Tree1', 'Hash[String,Variant[String,Tree1]]')
         t2 = type_alias_t('Tree2', 'Hash[String,Variant[String,Tree2]]')
-        loader = Object.new
-        loader.expects(:load).with(:type, 'tree1').returns t1
-        loader.expects(:load).with(:type, 'tree2').returns t2
+        loader = double
+        expect(loader).to receive(:load).with(:type, 'tree1').and_return(t1)
+        expect(loader).to receive(:load).with(:type, 'tree2').and_return(t2)
 
-        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
+        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
 
         t1.resolve(scope)
         t2.resolve(scope)
@@ -1755,11 +1755,11 @@ describe 'The type calculator' do
       it 'crossing recursive aliases are assignable' do
         t1 = type_alias_t('Tree1', 'Hash[String,Variant[String,Tree2]]')
         t2 = type_alias_t('Tree2', 'Hash[String,Variant[String,Tree1]]')
-        loader = Object.new
-        loader.expects(:load).with(:type, 'tree1').returns t1
-        loader.expects(:load).with(:type, 'tree2').returns t2
+        loader = double
+        expect(loader).to receive(:load).with(:type, 'tree1').and_return(t1)
+        expect(loader).to receive(:load).with(:type, 'tree2').and_return(t2)
 
-        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
+        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
 
         t1.resolve(loader)
         t2.resolve(loader)
@@ -1767,12 +1767,12 @@ describe 'The type calculator' do
       end
 
       it 'Type[T] is assignable to Type[AT] when AT is an alias for T' do
-        scope = Object.new
+        scope = double
 
         ta = type_alias_t('PositiveInteger', 'Integer[0,default]')
-        loader = Object.new
-        loader.expects(:load).with(:type, 'positiveinteger').returns ta
-        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
+        loader = double
+        expect(loader).to receive(:load).with(:type, 'positiveinteger').and_return(ta)
+        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
 
         t1 = type_t(range_t(0, :default))
         t2 = parser.parse('Type[PositiveInteger]', scope)
@@ -1780,12 +1780,12 @@ describe 'The type calculator' do
       end
 
       it 'Type[T] is assignable to AT when AT is an alias for Type[T]' do
-        scope = Object.new
+        scope = double
 
         ta = type_alias_t('PositiveIntegerType', 'Type[Integer[0,default]]')
-        loader = Object.new
-        loader.expects(:load).with(:type, 'positiveintegertype').returns ta
-        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
+        loader = double
+        expect(loader).to receive(:load).with(:type, 'positiveintegertype').and_return(ta)
+        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
 
         t1 = type_t(range_t(0, :default))
         t2 = parser.parse('PositiveIntegerType', scope)
@@ -1793,12 +1793,12 @@ describe 'The type calculator' do
       end
 
       it 'Type[Type[T]] is assignable to Type[Type[AT]] when AT is an alias for T' do
-        scope = Object.new
+        scope = double
 
         ta = type_alias_t('PositiveInteger', 'Integer[0,default]')
-        loader = Object.new
-        loader.expects(:load).with(:type, 'positiveinteger').returns ta
-        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
+        loader = double
+        expect(loader).to receive(:load).with(:type, 'positiveinteger').and_return(ta)
+        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
 
         t1 = type_t(type_t(range_t(0, :default)))
         t2 = parser.parse('Type[Type[PositiveInteger]]', scope)
@@ -1806,12 +1806,12 @@ describe 'The type calculator' do
       end
 
       it 'Type[Type[T]] is assignable to Type[AT] when AT is an alias for Type[T]' do
-        scope = Object.new
+        scope = double
 
         ta = type_alias_t('PositiveIntegerType', 'Type[Integer[0,default]]')
-        loader = Object.new
-        loader.expects(:load).with(:type, 'positiveintegertype').returns ta
-        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
+        loader = double
+        expect(loader).to receive(:load).with(:type, 'positiveintegertype').and_return(ta)
+        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
 
         t1 = type_t(type_t(range_t(0, :default)))
         t2 = parser.parse('Type[PositiveIntegerType]', scope)
@@ -2122,10 +2122,10 @@ describe 'The type calculator' do
 
       it 'should consider x an instance of the aliased type that uses self recursion' do
         t = type_alias_t('Tree', 'Hash[String,Variant[String,Tree]]')
-        loader = Object.new
-        loader.expects(:load).with(:type, 'tree').returns t
+        loader = double
+        expect(loader).to receive(:load).with(:type, 'tree').and_return(t)
 
-        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
+        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
 
         t.resolve(loader)
         expect(calculator.instance?(t, {'a'=>{'aa'=>{'aaa'=>'aaaa'}}, 'b'=>'bb'})).to be_truthy
@@ -2134,11 +2134,11 @@ describe 'The type calculator' do
       it 'should consider x an instance of the aliased type that uses contains an alias that causes self recursion' do
         t1 = type_alias_t('Tree', 'Hash[String,Variant[String,OtherTree]]')
         t2 = type_alias_t('OtherTree', 'Hash[String,Tree]')
-        loader = Object.new
-        loader.expects(:load).with(:type, 'tree').returns t1
-        loader.expects(:load).with(:type, 'othertree').returns t2
+        loader = double
+        expect(loader).to receive(:load).with(:type, 'tree').and_return(t1)
+        expect(loader).to receive(:load).with(:type, 'othertree').and_return(t2)
 
-        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
+        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
 
         t1.resolve(loader)
         expect(calculator.instance?(t1, {'a'=>{'aa'=>{'aaa'=>'aaaa'}}, 'b'=>'bb'})).to be_truthy

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

@@ -172,39 +172,39 @@ describe TypeParser do
 
   context 'with scope context and loader' do
     let!(:scope) { {} }
-    let(:loader) { Object.new }
+    let(:loader) { double() }
 
     before :each do
-      Adapters::LoaderAdapter.expects(:loader_for_model_object).returns loader
+      expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).and_return(loader)
     end
 
     it 'interprets anything that is not found by the loader to be a type reference' do
-      loader.expects(:load).with(:type, 'nonesuch').returns nil
+      expect(loader).to receive(:load).with(:type, 'nonesuch').and_return(nil)
       expect(parser.parse('Nonesuch', scope)).to be_the_type(types.type_reference('Nonesuch'))
     end
 
     it 'interprets anything that is found by the loader to be what the loader found' do
-      loader.expects(:load).with(:type, 'file').returns types.resource('File')
+      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
       expect(parser.parse('File', scope)).to be_the_type(types.resource('File'))
     end
 
     it "parses a resource type with title" do
-      loader.expects(:load).with(:type, 'file').returns types.resource('File')
+      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
       expect(parser.parse("File['/tmp/foo']", scope)).to be_the_type(types.resource('file', '/tmp/foo'))
     end
 
     it "parses a resource type using 'Resource[type]' form" do
-      loader.expects(:load).with(:type, 'file').returns types.resource('File')
+      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
       expect(parser.parse("Resource[File]", scope)).to be_the_type(types.resource('file'))
     end
 
     it "parses a resource type with title using 'Resource[type, title]'" do
-      loader.expects(:load).with(:type, 'file').returns nil
+      expect(loader).to receive(:load).with(:type, 'file').and_return(nil)
       expect(parser.parse("Resource[File, '/tmp/foo']", scope)).to be_the_type(types.resource('file', '/tmp/foo'))
     end
 
     it "parses a resource type with title using 'Resource[Type[title]]'" do
-      loader.expects(:load).with(:type, 'nonesuch').returns nil
+      expect(loader).to receive(:load).with(:type, 'nonesuch').and_return(nil)
       expect(parser.parse("Resource[Nonesuch['fife']]", scope)).to be_the_type(types.resource('nonesuch', 'fife'))
     end
   end
@@ -213,27 +213,27 @@ describe TypeParser do
     let(:loader) { Puppet::Pops::Loader::BaseLoader.new(nil, "type_parser_unit_test_loader") }
 
     it 'interprets anything that is not found by the loader to be a type reference' do
-      loader.expects(:load).with(:type, 'nonesuch').returns nil
+      expect(loader).to receive(:load).with(:type, 'nonesuch').and_return(nil)
       expect(parser.parse('Nonesuch', loader)).to be_the_type(types.type_reference('Nonesuch'))
     end
 
     it 'interprets anything that is found by the loader to be what the loader found' do
-      loader.expects(:load).with(:type, 'file').returns types.resource('File')
+      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
       expect(parser.parse('File', loader)).to be_the_type(types.resource('file'))
     end
 
     it "parses a resource type with title" do
-      loader.expects(:load).with(:type, 'file').returns types.resource('File')
+      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
       expect(parser.parse("File['/tmp/foo']", loader)).to be_the_type(types.resource('file', '/tmp/foo'))
     end
 
     it "parses a resource type using 'Resource[type]' form" do
-      loader.expects(:load).with(:type, 'file').returns types.resource('File')
+      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
       expect(parser.parse("Resource[File]", loader)).to be_the_type(types.resource('file'))
     end
 
     it "parses a resource type with title using 'Resource[type, title]'" do
-      loader.expects(:load).with(:type, 'file').returns types.resource('File')
+      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
       expect(parser.parse("Resource[File, '/tmp/foo']", loader)).to be_the_type(types.resource('file', '/tmp/foo'))
     end
   end

data/spec/unit/pops/validator/validator_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
 require 'puppet_spec/pops'
@@ -912,7 +911,7 @@ describe "validating 4x" do
       result = '$hg_oais::archivematica::requirements::automation_tools::USER' =~ Puppet::Pops::Patterns::VAR_NAME
       t2 = Time.now.nsec
       expect(result).to be(nil)
-      expect(t2-t).to be < 1000000 # one ms as a check for very slow operation, is in fact at ~< 10 microsecond 
+      expect(t2-t).to be < 1000000 # one ms as a check for very slow operation, is in fact at ~< 10 microsecond
     end
   end
 

data/spec/unit/pops/visitor_spec.rb

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

data/spec/unit/property/boolean_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'puppet/property/boolean'
 
 describe Puppet::Property::Boolean do
-  let (:resource) { mock('resource') }
+  let (:resource) { double('resource') }
   subject { described_class.new(:resource => resource) }
 
   [ true, :true, 'true', :yes, 'yes', 'TrUe', 'yEs' ].each do |arg|

data/spec/unit/property/ensure_spec.rb

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

data/spec/unit/property/keyvalue_spec.rb

@@ -1,9 +1,7 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/property/keyvalue'
 
-
 describe 'Puppet::Property::KeyValue' do 
   let(:klass) { Puppet::Property::KeyValue }
 
@@ -15,7 +13,7 @@ describe 'Puppet::Property::KeyValue' do
     before do
       # Wow that's a messy interface to the resource.
       klass.initvars
-      @resource = stub 'resource', :[]= => nil, :property => nil
+      @resource = double('resource', :[]= => nil, :property => nil)
       @property = klass.new(:resource => @resource)
       klass.log_only_changed_or_new_keys = false
     end
@@ -65,20 +63,20 @@ describe 'Puppet::Property::KeyValue' do
 
     describe "when calling inclusive?" do
       it "should use the membership method to look up on the @resource" do
-        @property.expects(:membership).returns(:key_value_membership)
-        @resource.expects(:[]).with(:key_value_membership)
+        expect(@property).to receive(:membership).and_return(:key_value_membership)
+        expect(@resource).to receive(:[]).with(:key_value_membership)
         @property.inclusive?
       end
 
       it "should return true when @resource[membership] == inclusive" do
-        @property.stubs(:membership).returns(:key_value_membership)
-        @resource.stubs(:[]).with(:key_value_membership).returns(:inclusive)
+        allow(@property).to receive(:membership).and_return(:key_value_membership)
+        allow(@resource).to receive(:[]).with(:key_value_membership).and_return(:inclusive)
         expect(@property.inclusive?).to eq(true)
       end
 
       it "should return false when @resource[membership] != inclusive" do
-        @property.stubs(:membership).returns(:key_value_membership)
-        @resource.stubs(:[]).with(:key_value_membership).returns(:minimum)
+        allow(@property).to receive(:membership).and_return(:key_value_membership)
+        allow(@resource).to receive(:[]).with(:key_value_membership).and_return(:minimum)
         expect(@property.inclusive?).to eq(false)
       end
     end
@@ -89,12 +87,12 @@ describe 'Puppet::Property::KeyValue' do
       end
 
       it "should set every key to nil if inclusive?" do
-        @property.stubs(:inclusive?).returns(true)
+        allow(@property).to receive(:inclusive?).and_return(true)
         expect(@property.process_current_hash({:foo => "bar", :do => "re"})).to eq({ :foo => nil, :do => nil })
       end
 
       it "should return the hash if !inclusive?" do
-        @property.stubs(:inclusive?).returns(false)
+        allow(@property).to receive(:inclusive?).and_return(false)
         expect(@property.process_current_hash({:foo => "bar", :do => "re"})).to eq({:foo => "bar", :do => "re"})
       end
     end
@@ -106,22 +104,22 @@ describe 'Puppet::Property::KeyValue' do
 
       it "should call process_current_hash" do
         @property.should = ["foo=baz", "bar=boo"]
-        @property.stubs(:retrieve).returns({:do => "re", :mi => "fa" })
-        @property.expects(:process_current_hash).returns({})
+        allow(@property).to receive(:retrieve).and_return({:do => "re", :mi => "fa" })
+        expect(@property).to receive(:process_current_hash).and_return({})
         @property.should
       end
 
       it "should return the hashed values of @should and the nilled values of retrieve if inclusive" do
         @property.should = ["foo=baz", "bar=boo"]
-        @property.expects(:retrieve).returns({:do => "re", :mi => "fa" })
-        @property.expects(:inclusive?).returns(true)
+        expect(@property).to receive(:retrieve).and_return({:do => "re", :mi => "fa" })
+        expect(@property).to receive(:inclusive?).and_return(true)
         expect(@property.should).to eq({ :foo => "baz", :bar => "boo", :do => nil, :mi => nil })
       end
 
       it "should return the hashed @should + the unique values of retrieve if !inclusive" do
         @property.should = ["foo=baz", "bar=boo"]
-        @property.expects(:retrieve).returns({:foo => "diff", :do => "re", :mi => "fa"})
-        @property.expects(:inclusive?).returns(false)
+        expect(@property).to receive(:retrieve).and_return({:foo => "diff", :do => "re", :mi => "fa"})
+        expect(@property).to receive(:inclusive?).and_return(false)
         expect(@property.should).to eq({ :foo => "baz", :bar => "boo", :do => "re", :mi => "fa" })
       end
 
@@ -132,14 +130,14 @@ describe 'Puppet::Property::KeyValue' do
           :key3 => "new_value3",
           :key4 => "value4"
         }
-        @property.stubs(:retrieve).returns(
+        allow(@property).to receive(:retrieve).and_return(
           {
             :key1 => "value1",
             :key2 => "value2",
             :key3 => "value3"
           }
         )
-        @property.stubs(:inclusive?).returns(false)
+        allow(@property).to receive(:inclusive?).and_return(false)
 
         @property.should
         expect(@property.instance_variable_get(:@changed_or_new_keys)).to eql([:key1, :key3, :key4])
@@ -148,25 +146,25 @@ describe 'Puppet::Property::KeyValue' do
 
     describe "when calling retrieve" do
       before do
-        @provider = mock("provider")
-        @property.stubs(:provider).returns(@provider)
+        @provider = double("provider")
+        allow(@property).to receive(:provider).and_return(@provider)
       end
 
       it "should send 'name' to the provider" do
-        @provider.expects(:send).with(:keys)
-        @property.expects(:name).returns(:keys)
+        expect(@provider).to receive(:send).with(:keys)
+        expect(@property).to receive(:name).and_return(:keys)
         @property.retrieve
       end
 
       it "should return a hash with the provider returned info" do
-        @provider.stubs(:send).with(:keys).returns({"do" => "re", "mi" => "fa" })
-        @property.stubs(:name).returns(:keys)
+        allow(@provider).to receive(:send).with(:keys).and_return({"do" => "re", "mi" => "fa" })
+        allow(@property).to receive(:name).and_return(:keys)
         @property.retrieve == {"do" => "re", "mi" => "fa" }
       end
 
       it "should return :absent when the provider returns :absent" do
-        @provider.stubs(:send).with(:keys).returns(:absent)
-        @property.stubs(:name).returns(:keys)
+        allow(@provider).to receive(:send).with(:keys).and_return(:absent)
+        allow(@property).to receive(:name).and_return(:keys)
         @property.retrieve == :absent
       end
     end
@@ -185,9 +183,9 @@ describe 'Puppet::Property::KeyValue' do
 
     describe "when calling safe_insync?" do
       before do
-        @provider = mock("provider")
-        @property.stubs(:provider).returns(@provider)
-        @property.stubs(:name).returns(:prop_name)
+        @provider = double("provider")
+        allow(@property).to receive(:provider).and_return(@provider)
+        allow(@property).to receive(:name).and_return(:prop_name)
       end
 
       it "should return true unless @should is defined and not nil" do
@@ -199,16 +197,16 @@ describe 'Puppet::Property::KeyValue' do
       end
 
       it "should return true if hashified should value == (retrieved) value passed in" do
-        @provider.stubs(:prop_name).returns({ :foo => "baz", :bar => "boo" })
+        allow(@provider).to receive(:prop_name).and_return({ :foo => "baz", :bar => "boo" })
         @property.should = ["foo=baz", "bar=boo"]
-        @property.expects(:inclusive?).returns(true)
+        expect(@property).to receive(:inclusive?).and_return(true)
         expect(@property.safe_insync?({ :foo => "baz", :bar => "boo" })).to eq(true)
       end
 
       it "should return false if prepared value != should value" do
-        @provider.stubs(:prop_name).returns({ "foo" => "bee", "bar" => "boo" })
+        allow(@provider).to receive(:prop_name).and_return({ "foo" => "bee", "bar" => "boo" })
         @property.should = ["foo=baz", "bar=boo"]
-        @property.expects(:inclusive?).returns(true)
+        expect(@property).to receive(:inclusive?).and_return(true)
         expect(@property.safe_insync?({ "foo" => "bee", "bar" => "boo" })).to eq(false)
       end
     end