puppet 6.0.7-universal-darwin → 6.0.8-universal-darwin

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

@@ -1726,10 +1726,10 @@ describe 'The type calculator' do
         scope = {}
 
         t = type_alias_t('Tree', 'Hash[String,Variant[String,Tree]]')
-        loader = mock
-        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
@@ -1741,11 +1741,11 @@ describe 'The type calculator' do
 
         t1 = type_alias_t('Tree1', 'Hash[String,Variant[String,Tree1]]')
         t2 = type_alias_t('Tree2', 'Hash[String,Variant[String,Tree2]]')
-        loader = mock
-        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 = mock
-        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)
@@ -1770,9 +1770,9 @@ describe 'The type calculator' do
         scope = {}
 
         ta = type_alias_t('PositiveInteger', 'Integer[0,default]')
-        loader = mock
-        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)
@@ -1783,9 +1783,9 @@ describe 'The type calculator' do
         scope = {}
 
         ta = type_alias_t('PositiveIntegerType', 'Type[Integer[0,default]]')
-        loader = mock
-        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)
@@ -1796,9 +1796,9 @@ describe 'The type calculator' do
         scope = {}
 
         ta = type_alias_t('PositiveInteger', 'Integer[0,default]')
-        loader = mock
-        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)
@@ -1809,9 +1809,9 @@ describe 'The type calculator' do
         scope = {}
 
         ta = type_alias_t('PositiveIntegerType', 'Type[Integer[0,default]]')
-        loader = mock
-        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 = mock
-        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 = mock
-        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) { mock }
+    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'
@@ -1012,7 +1011,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

data/spec/unit/property/list_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/property/list'
@@ -15,7 +14,7 @@ describe list_class do
     before do
       # Wow that's a messy interface to the resource.
       list_class.initvars
-      @resource = stub 'resource', :[]= => nil, :property => nil
+      @resource = double('resource', :[]= => nil, :property => nil)
       @property = list_class.new(:resource => @resource)
     end
 
@@ -55,20 +54,20 @@ describe list_class do
 
     describe "when calling inclusive?" do
       it "should use the membership method to look up on the @resource" do
-        @property.expects(:membership).returns(:membership)
-        @resource.expects(:[]).with(:membership)
+        expect(@property).to receive(:membership).and_return(:membership)
+        expect(@resource).to receive(:[]).with(:membership)
         @property.inclusive?
       end
 
       it "should return true when @resource[membership] == inclusive" do
-        @property.stubs(:membership).returns(:membership)
-        @resource.stubs(:[]).with(:membership).returns(:inclusive)
+        allow(@property).to receive(:membership).and_return(:membership)
+        allow(@resource).to receive(:[]).with(:membership).and_return(:inclusive)
         expect(@property.inclusive?).to eq(true)
       end
 
       it "should return false when @resource[membership] != inclusive" do
-        @property.stubs(:membership).returns(:membership)
-        @resource.stubs(:[]).with(:membership).returns(:minimum)
+        allow(@property).to receive(:membership).and_return(:membership)
+        allow(@resource).to receive(:[]).with(:membership).and_return(:minimum)
         expect(@property.inclusive?).to eq(false)
       end
     end
@@ -80,14 +79,14 @@ describe list_class do
 
       it "should return the sorted values of @should as a string if inclusive" do
         @property.should = ["foo", "bar"]
-        @property.expects(:inclusive?).returns(true)
+        expect(@property).to receive(:inclusive?).and_return(true)
         expect(@property.should).to eq("bar,foo")
       end
 
       it "should return the uniq sorted values of @should + retrieve as a string if !inclusive" do
         @property.should = ["foo", "bar"]
-        @property.expects(:inclusive?).returns(false)
-        @property.expects(:retrieve).returns(["foo","baz"])
+        expect(@property).to receive(:inclusive?).and_return(false)
+        expect(@property).to receive(:retrieve).and_return(["foo","baz"])
         expect(@property.should).to eq("bar,baz,foo")
       end
     end
@@ -95,25 +94,25 @@ describe list_class do
     describe "when calling retrieve" do
       let(:provider) { @provider }
       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(:group)
-        @property.expects(:name).returns(:group)
+        expect(@provider).to receive(:send).with(:group)
+        expect(@property).to receive(:name).and_return(:group)
         @property.retrieve
       end
 
       it "should return an array with the provider returned info" do
-        @provider.stubs(:send).with(:group).returns("foo,bar,baz")
-        @property.stubs(:name).returns(:group)
+        allow(@provider).to receive(:send).with(:group).and_return("foo,bar,baz")
+        allow(@property).to receive(:name).and_return(:group)
         @property.retrieve == ["foo", "bar", "baz"]
       end
 
       it "should return :absent when the provider returns :absent" do
-        @provider.stubs(:send).with(:group).returns(:absent)
-        @property.stubs(:name).returns(:group)
+        allow(@provider).to receive(:send).with(:group).and_return(:absent)
+        allow(@property).to receive(:name).and_return(:group)
         @property.retrieve == :absent
       end
 
@@ -137,35 +136,35 @@ describe list_class do
 
       it "should call prepare_is_for_comparison with value passed in and should" do
         @property.should = "foo"
-        @property.expects(:prepare_is_for_comparison).with("bar")
-        @property.expects(:should)
+        expect(@property).to receive(:prepare_is_for_comparison).with("bar")
+        expect(@property).to receive(:should)
         @property.safe_insync?("bar")
       end
 
       it "should return true if 'is' value is array of comma delimited should values" do
         @property.should = "bar,foo"
-        @property.expects(:inclusive?).returns(true)
+        expect(@property).to receive(:inclusive?).and_return(true)
         expect(@property).to be_safe_insync(["bar","foo"])
       end
 
       it "should return true if 'is' value is :absent and should value is empty string" do
         @property.should = ""
-        @property.expects(:inclusive?).returns(true)
+        expect(@property).to receive(:inclusive?).and_return(true)
         expect(@property).to be_safe_insync([])
       end
 
       it "should return false if prepared value != should value" do
         @property.should = "bar,baz,foo"
-        @property.expects(:inclusive?).returns(true)
+        expect(@property).to receive(:inclusive?).and_return(true)
         expect(@property).to_not be_safe_insync(["bar","foo"])
       end
     end
 
     describe "when calling dearrayify" do
       it "should sort and join the array with 'delimiter'" do
-        array = mock "array"
-        array.expects(:sort).returns(array)
-        array.expects(:join).with(@property.delimiter)
+        array = double("array")
+        expect(array).to receive(:sort).and_return(array)
+        expect(array).to receive(:join).with(@property.delimiter)
         @property.dearrayify(array)
       end
     end