puppet 5.5.12-x64-mingw32 → 5.5.13-x64-mingw32

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

data/spec/unit/property/ordered_list_spec.rb

@@ -1,22 +1,18 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/property/ordered_list'
 
-ordered_list_class = Puppet::Property::OrderedList
-
-describe ordered_list_class do
-
+describe Puppet::Property::OrderedList do
   it "should be a subclass of List" do
-    expect(ordered_list_class.superclass).to eq(Puppet::Property::List)
+    expect(described_class.superclass).to eq(Puppet::Property::List)
   end
 
   describe "as an instance" do
     before do
       # Wow that's a messy interface to the resource.
-      ordered_list_class.initvars
-      @resource = stub 'resource', :[]= => nil, :property => nil
-      @property = ordered_list_class.new(:resource => @resource)
+      described_class.initvars
+      @resource = double('resource', :[]= => nil, :property => nil)
+      @property = described_class.new(:resource => @resource)
     end
 
     describe "when adding should to current" do
@@ -40,22 +36,22 @@ describe ordered_list_class do
 
       it "should return the values of @should (without sorting) 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("foo,bar")
       end
 
       it "should return the uniq values of @should + retrieve as a string if !inclusive with the @ values leading" 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("foo,bar,baz")
       end
     end
 
     describe "when calling dearrayify" do
       it "should join the array with the delimiter" do
-        array = mock "array"
-        array.expects(:join).with(@property.delimiter)
+        array = double("array")
+        expect(array).to receive(:join).with(@property.delimiter)
         @property.dearrayify(array)
       end
     end

data/spec/unit/property_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/property'
 
@@ -52,73 +51,73 @@ describe Puppet::Property do
 
   describe "when returning the default event name" do
     it "should use the current 'should' value to pick the event name" do
-      property.expects(:should).returns "myvalue"
-      subclass.expects(:value_option).with('myvalue', :event).returns :event_name
+      expect(property).to receive(:should).and_return("myvalue")
+      expect(subclass).to receive(:value_option).with('myvalue', :event).and_return(:event_name)
 
       property.event_name
     end
 
     it "should return any event defined with the specified value" do
-      property.expects(:should).returns :myval
-      subclass.expects(:value_option).with(:myval, :event).returns :event_name
+      expect(property).to receive(:should).and_return(:myval)
+      expect(subclass).to receive(:value_option).with(:myval, :event).and_return(:event_name)
 
       expect(property.event_name).to eq(:event_name)
     end
 
     describe "and the property is 'ensure'" do
       before :each do
-        property.stubs(:name).returns :ensure
-        resource.expects(:type).returns :mytype
+        allow(property).to receive(:name).and_return(:ensure)
+        expect(resource).to receive(:type).and_return(:mytype)
       end
 
       it "should use <type>_created if the 'should' value is 'present'" do
-        property.expects(:should).returns :present
+        expect(property).to receive(:should).and_return(:present)
         expect(property.event_name).to eq(:mytype_created)
       end
 
       it "should use <type>_removed if the 'should' value is 'absent'" do
-        property.expects(:should).returns :absent
+        expect(property).to receive(:should).and_return(:absent)
         expect(property.event_name).to eq(:mytype_removed)
       end
 
       it "should use <type>_changed if the 'should' value is not 'absent' or 'present'" do
-        property.expects(:should).returns :foo
+        expect(property).to receive(:should).and_return(:foo)
         expect(property.event_name).to eq(:mytype_changed)
       end
 
       it "should use <type>_changed if the 'should value is nil" do
-        property.expects(:should).returns nil
+        expect(property).to receive(:should).and_return(nil)
         expect(property.event_name).to eq(:mytype_changed)
       end
     end
 
     it "should use <property>_changed if the property is not 'ensure'" do
-      property.stubs(:name).returns :myparam
-      property.expects(:should).returns :foo
+      allow(property).to receive(:name).and_return(:myparam)
+      expect(property).to receive(:should).and_return(:foo)
       expect(property.event_name).to eq(:myparam_changed)
     end
 
     it "should use <property>_changed if no 'should' value is set" do
-      property.stubs(:name).returns :myparam
-      property.expects(:should).returns nil
+      allow(property).to receive(:name).and_return(:myparam)
+      expect(property).to receive(:should).and_return(nil)
       expect(property.event_name).to eq(:myparam_changed)
     end
   end
 
   describe "when creating an event" do
     before :each do
-      property.stubs(:should).returns "myval"
+      allow(property).to receive(:should).and_return("myval")
     end
 
     it "should use an event from the resource as the base event" do
       event = Puppet::Transaction::Event.new
-      resource.expects(:event).returns event
+      expect(resource).to receive(:event).and_return(event)
 
       expect(property.event).to equal(event)
     end
 
     it "should have the default event name" do
-      property.expects(:event_name).returns :my_event
+      expect(property).to receive(:event_name).and_return(:my_event)
       expect(property.event.name).to eq(:my_event)
     end
 
@@ -127,23 +126,23 @@ describe Puppet::Property do
     end
 
     it "should have the 'should' value set" do
-      property.stubs(:should).returns "foo"
+      allow(property).to receive(:should).and_return("foo")
       expect(property.event.desired_value).to eq("foo")
     end
 
     it "should provide its path as the source description" do
-      property.stubs(:path).returns "/my/param"
+      allow(property).to receive(:path).and_return("/my/param")
       expect(property.event.source_description).to eq("/my/param")
     end
 
     it "should have the 'invalidate_refreshes' value set if set on a value" do
-      property.stubs(:event_name).returns :my_event
-      property.stubs(:should).returns "foo"
-      foo = mock()
-      foo.expects(:invalidate_refreshes).returns(true)
-      collection = mock()
-      collection.expects(:match?).with("foo").returns(foo)
-      property.class.stubs(:value_collection).returns(collection)
+      allow(property).to receive(:event_name).and_return(:my_event)
+      allow(property).to receive(:should).and_return("foo")
+      foo = double()
+      expect(foo).to receive(:invalidate_refreshes).and_return(true)
+      collection = double()
+      expect(collection).to receive(:match?).with("foo").and_return(foo)
+      allow(property.class).to receive(:value_collection).and_return(collection)
       expect(property.event.invalidate_refreshes).to be_truthy
     end
 
@@ -167,15 +166,15 @@ describe Puppet::Property do
     end
 
     it "should validate each value separately" do
-      property.expects(:validate).with("one")
-      property.expects(:validate).with("two")
+      expect(property).to receive(:validate).with("one")
+      expect(property).to receive(:validate).with("two")
 
       property.value = %w{one two}
     end
 
     it "should munge each value separately and use any result as the actual value" do
-      property.expects(:munge).with("one").returns :one
-      property.expects(:munge).with("two").returns :two
+      expect(property).to receive(:munge).with("one").and_return(:one)
+      expect(property).to receive(:munge).with("two").and_return(:two)
 
       # Do this so we get the whole array back.
       subclass.array_matching = :all
@@ -272,7 +271,7 @@ describe Puppet::Property do
     it "should validate that all required features are present" do
       subclass.newvalue(:foo, :required_features => [:a, :b])
 
-      resource.provider.expects(:satisfies?).with([:a, :b]).returns true
+      expect(resource.provider).to receive(:satisfies?).with([:a, :b]).and_return(true)
 
       property.should = :foo
     end
@@ -280,7 +279,7 @@ describe Puppet::Property do
     it "should fail if required features are missing" do
       subclass.newvalue(:foo, :required_features => [:a, :b])
 
-      resource.provider.expects(:satisfies?).with([:a, :b]).returns false
+      expect(resource.provider).to receive(:satisfies?).with([:a, :b]).and_return(false)
 
       expect { property.should = :foo }.to raise_error(Puppet::Error)
     end
@@ -288,7 +287,7 @@ describe Puppet::Property do
     it "should internally raise an ArgumentError if required features are missing" do
       subclass.newvalue(:foo, :required_features => [:a, :b])
 
-      resource.provider.expects(:satisfies?).with([:a, :b]).returns false
+      expect(resource.provider).to receive(:satisfies?).with([:a, :b]).and_return(false)
 
       expect { property.validate_features_per_value :foo }.to raise_error(ArgumentError)
     end
@@ -296,7 +295,7 @@ describe Puppet::Property do
     it "should validate that all required features are present for regexes" do
       subclass.newvalue(/./, :required_features => [:a, :b])
 
-      resource.provider.expects(:satisfies?).with([:a, :b]).returns true
+      expect(resource.provider).to receive(:satisfies?).with([:a, :b]).and_return(true)
 
       property.should = "foo"
     end
@@ -304,7 +303,7 @@ describe Puppet::Property do
     it "should support specifying an individual required feature" do
       subclass.newvalue(/./, :required_features => :a)
 
-      resource.provider.expects(:satisfies?).returns true
+      expect(resource.provider).to receive(:satisfies?).and_return(true)
 
       property.should = "foo"
     end
@@ -341,7 +340,7 @@ describe Puppet::Property do
     it "should set the value" do
       subclass.newvalue(:foo)
       property.should = :foo
-      property.expects(:set).with(:foo)
+      expect(property).to receive(:set).with(:foo)
       property.sync
     end
   end
@@ -370,13 +369,13 @@ describe Puppet::Property do
     describe "that was defined without a block" do
       it "should call the settor on the provider" do
         subclass.newvalue(:bar)
-        resource.provider.expects(:foo=).with :bar
+        expect(resource.provider).to receive(:foo=).with(:bar)
         property.set(:bar)
       end
 
        it "should generate setter named from :method argument and propagate call to the provider" do
         subclass.newvalue(:bar, :method => 'set_vv')
-        resource.provider.expects(:foo=).with :bar
+        expect(resource.provider).to receive(:foo=).with(:bar)
         property.set_vv(:bar)
       end
     end
@@ -384,13 +383,13 @@ describe Puppet::Property do
     describe "that was defined with a block" do
       it "should call the method created for the value if the value is not a regex" do
         subclass.newvalue(:bar) {}
-        property.expects(:set_bar)
+        expect(property).to receive(:set_bar)
         property.set(:bar)
       end
 
       it "should call the provided block if the value is a regex" do
-        subclass.newvalue(/./) { self.test }
-        property.expects(:test)
+        subclass.newvalue(/./) { test }
+        expect(property).to receive(:test)
         property.set("foo")
       end
     end
@@ -547,7 +546,7 @@ describe Puppet::Property do
 
   describe "#insync_values?" do
     it "should log an exception when insync? throws one" do
-      property.expects(:insync?).raises ArgumentError
+      expect(property).to receive(:insync?).and_raise(ArgumentError)
       expect(property.insync_values?("foo","bar")).to be nil
     end
   end

data/spec/unit/provider/aix_object_spec.rb

@@ -156,7 +156,7 @@ describe 'Puppet::Provider::AixObject' do
       provider.instance_variable_set(:@object_info, { :foo => 'foo', :baz => 'baz' })
 
       (provider.class.mappings[:aix_attribute].keys + [:attributes]).each do |property|
-        provider.expects(:get).with(property).returns('value')
+        expect(provider).to receive(:get).with(property).and_return('value')
 
         expect(provider.send(property)).to eql('value')
       end
@@ -167,7 +167,7 @@ describe 'Puppet::Provider::AixObject' do
 
       value = '15'
       provider.class.mappings[:aix_attribute].keys.each do |property|
-        provider.expects(:set).with(property, value)
+        expect(provider).to receive(:set).with(property, value)
 
         provider.send("#{property}=".to_sym, value)
       end
@@ -295,8 +295,8 @@ bin:2
 
     it 'lists all of the objects' do
       lscmd = 'lsgroups'
-      provider.class.stubs(:command).with(:list).returns(lscmd)
-      provider.class.stubs(:execute).with([lscmd, '-c', '-a', 'id', 'ALL']).returns(output)
+      allow(provider.class).to receive(:command).with(:list).and_return(lscmd)
+      allow(provider.class).to receive(:execute).with([lscmd, '-c', '-a', 'id', 'ALL']).and_return(output)
 
       expected_objects = [
         { :name => 'system', :id => '0' },
@@ -316,7 +316,7 @@ bin:2
     end
 
     it 'returns all of the available instances' do
-      provider.class.stubs(:list_all).returns(objects)
+      allow(provider.class).to receive(:list_all).and_return(objects)
 
       expect(provider.class.instances.map(&:name)).to eql(['group1', 'group2'])
     end
@@ -419,20 +419,20 @@ bin:2
 
   describe '#ia_module_args' do
     it 'returns no arguments if the ia_load_module parameter is not specified' do
-      provider.resource.stubs(:[]).with(:ia_load_module).returns(nil)
+      allow(provider.resource).to receive(:[]).with(:ia_load_module).and_return(nil)
       expect(provider.ia_module_args).to eql([])
     end
 
     it 'returns the ia_load_module as a CLI argument' do
-      provider.resource.stubs(:[]).with(:ia_load_module).returns('module')
+      allow(provider.resource).to receive(:[]).with(:ia_load_module).and_return('module')
       expect(provider.ia_module_args).to eql(['-R', 'module'])
     end
   end
 
   describe '#lscmd' do
     it 'returns the lscmd' do
-      provider.class.stubs(:command).with(:list).returns('list')
-      provider.stubs(:ia_module_args).returns(['ia_module_args'])
+      allow(provider.class).to receive(:command).with(:list).and_return('list')
+      allow(provider).to receive(:ia_module_args).and_return(['ia_module_args'])
 
       expect(provider.lscmd).to eql(
         ['list', '-c', 'ia_module_args', provider.resource.name]
@@ -449,8 +449,8 @@ bin:2
     end
 
     it 'returns the addcmd passing in the attributes as CLI arguments' do
-      provider.class.stubs(:command).with(:add).returns('add')
-      provider.stubs(:ia_module_args).returns(['ia_module_args'])
+      allow(provider.class).to receive(:command).with(:add).and_return('add')
+      allow(provider).to receive(:ia_module_args).and_return(['ia_module_args'])
 
       expect(provider.addcmd(attributes)).to eql(
         ['add', 'ia_module_args', 'attribute1=value1', 'attribute2=value2', provider.resource.name]
@@ -460,8 +460,8 @@ bin:2
 
   describe '#deletecmd' do
     it 'returns the lscmd' do
-      provider.class.stubs(:command).with(:delete).returns('delete')
-      provider.stubs(:ia_module_args).returns(['ia_module_args'])
+      allow(provider.class).to receive(:command).with(:delete).and_return('delete')
+      allow(provider).to receive(:ia_module_args).and_return(['ia_module_args'])
 
       expect(provider.deletecmd).to eql(
         ['delete', 'ia_module_args', provider.resource.name]
@@ -478,8 +478,8 @@ bin:2
     end
 
     it 'returns the addcmd passing in the attributes as CLI arguments' do
-      provider.class.stubs(:command).with(:modify).returns('modify')
-      provider.stubs(:ia_module_args).returns(['ia_module_args'])
+      allow(provider.class).to receive(:command).with(:modify).and_return('modify')
+      allow(provider).to receive(:ia_module_args).and_return(['ia_module_args'])
 
       expect(provider.modifycmd(attributes)).to eql(
         ['modify', 'ia_module_args', 'attribute1=value1', 'attribute2=value2', provider.resource.name]
@@ -496,9 +496,9 @@ bin:2
     end
 
     it 'modifies the AIX object with the new attributes' do
-      provider.stubs(:modifycmd).with(new_attributes).returns('modify_cmd')
-      provider.expects(:execute).with('modify_cmd')
-      provider.expects(:object_info).with(true)
+      allow(provider).to receive(:modifycmd).with(new_attributes).and_return('modify_cmd')
+      expect(provider).to receive(:execute).with('modify_cmd')
+      expect(provider).to receive(:object_info).with(true)
 
       provider.modify_object(new_attributes)
     end
@@ -516,20 +516,20 @@ bin:2
     end
 
     it 'returns :absent if the AIX object does not exist' do
-      provider.stubs(:exists?).returns(false)
+      allow(provider).to receive(:exists?).and_return(false)
       object_info[property] = 15
       
       expect(provider.get(property)).to eql(:absent)
     end
 
     it 'returns :absent if the property is not present on the system' do
-      provider.stubs(:exists?).returns(true)
+      allow(provider).to receive(:exists?).and_return(true)
 
       expect(provider.get(property)).to eql(:absent)
     end
 
     it "returns the property's value" do
-      provider.stubs(:exists?).returns(true)
+      allow(provider).to receive(:exists?).and_return(true)
       object_info[property] = 15
 
       expect(provider.get(property)).to eql(15)
@@ -557,9 +557,9 @@ bin:2
     end
 
     it "raises a Puppet::Error if it fails to set the property's value" do
-      provider.stubs(:modify_object)
+      allow(provider).to receive(:modify_object)
         .with({ :id => value.to_s })
-        .raises(Puppet::ExecutionFailure, 'failed to modify the AIX object!')
+        .and_raise(Puppet::ExecutionFailure, 'failed to modify the AIX object!')
 
       expect { provider.set(property, value) }.to raise_error do |error|
         expect(error).to be_a(Puppet::Error)
@@ -567,7 +567,7 @@ bin:2
     end
 
     it "sets the given property's value to the passed-in value" do
-      provider.expects(:modify_object).with({ :id => value.to_s })
+      expect(provider).to receive(:modify_object).with({ :id => value.to_s })
 
       provider.set(property, value)
     end
@@ -618,9 +618,9 @@ bin:2
     end
 
     it 'raises a Puppet::Error if it fails to set the new AIX attributes' do
-      provider.stubs(:modify_object)
+      allow(provider).to receive(:modify_object)
         .with(new_attributes)
-        .raises(Puppet::ExecutionFailure, 'failed to modify the AIX object!')
+        .and_raise(Puppet::ExecutionFailure, 'failed to modify the AIX object!')
       
       expect { provider.attributes = new_attributes }.to raise_error do |error|
         expect(error).to be_a(Puppet::Error)
@@ -630,7 +630,7 @@ bin:2
     end
 
     it 'sets the new AIX attributes' do
-      provider.expects(:modify_object).with(new_attributes)
+      expect(provider).to receive(:modify_object).with(new_attributes)
 
       provider.attributes = new_attributes
     end
@@ -650,7 +650,7 @@ bin:2
       )
 
       # Mock out our lscmd
-      provider.stubs(:lscmd).returns("lsuser #{resource[:name]}")
+      allow(provider).to receive(:lscmd).and_return("lsuser #{resource[:name]}")
     end
 
     it 'memoizes the result' do
@@ -659,7 +659,7 @@ bin:2
     end
 
     it 'returns nil if the AIX object does not exist' do
-      provider.stubs(:execute).with(provider.lscmd).raises(
+      allow(provider).to receive(:execute).with(provider.lscmd).and_raise(
         Puppet::ExecutionFailure, 'lscmd failed!'
       )
 
@@ -668,7 +668,7 @@ bin:2
 
     it 'collects the Puppet properties' do
       output = 'mock_output'
-      provider.stubs(:execute).with(provider.lscmd).returns(output)
+      allow(provider).to receive(:execute).with(provider.lscmd).and_return(output)
 
       # Mock the AIX attributes on the system
       mock_attributes = {
@@ -677,9 +677,9 @@ bin:2
         :attribute1 => 'value1',
         :attribute2 => 'value2'
       }
-      provider.class.stubs(:parse_aix_objects)
+      allow(provider.class).to receive(:parse_aix_objects)
         .with(output)
-        .returns([{ :name => resource.name, :attributes => mock_attributes }])
+        .and_return([{ :name => resource.name, :attributes => mock_attributes }])
 
       expected_property_values = {
         :uid        => 1,
@@ -696,12 +696,12 @@ bin:2
 
   describe '#exists?' do
     it 'should return true if the AIX object exists' do
-      provider.stubs(:object_info).returns({})
+      allow(provider).to receive(:object_info).and_return({})
       expect(provider.exists?).to be(true)
     end
 
     it 'should return false if the AIX object does not exist' do
-      provider.stubs(:object_info).returns(nil)
+      allow(provider).to receive(:object_info).and_return(nil)
       expect(provider.exists?).to be(false)
     end
   end
@@ -710,9 +710,11 @@ bin:2
     let(:property_attributes) do
       {}
     end
+
     def stub_attributes_property(attributes)
-      provider.resource.stubs(:should).with(:attributes).returns(attributes)
+      allow(provider.resource).to receive(:should).with(:attributes).and_return(attributes)
     end
+
     def set_property(puppet_property, aix_attribute, property_to_attribute, should_value = nil)
       property_to_attribute ||= lambda { |x| x }
 
@@ -721,7 +723,7 @@ bin:2
         aix_attribute: aix_attribute,
         property_to_attribute: property_to_attribute
       )
-      provider.resource.stubs(:should).with(puppet_property).returns(should_value)
+      allow(provider.resource).to receive(:should).with(puppet_property).and_return(should_value)
 
       if should_value
         property_attributes[aix_attribute] = property_to_attribute.call(should_value)
@@ -753,8 +755,8 @@ bin:2
     end
 
     it "raises a Puppet::Error if it fails to create the AIX object" do
-      provider.stubs(:addcmd)
-      provider.stubs(:execute).raises(
+      allow(provider).to receive(:addcmd)
+      allow(provider).to receive(:execute).and_raise(
         Puppet::ExecutionFailure, "addcmd failed!"
       )
 
@@ -769,10 +771,10 @@ bin:2
       attributes = { :fsize => 1000 }
       stub_attributes_property(attributes)
 
-      provider.expects(:addcmd)
+      expect(provider).to receive(:addcmd)
         .with(attributes.merge(property_attributes))
-        .returns('addcmd')
-      provider.expects(:execute).with('addcmd')
+        .and_return('addcmd')
+      expect(provider).to receive(:execute).with('addcmd')
 
       provider.create
     end
@@ -780,11 +782,11 @@ bin:2
  
   describe "#delete" do
     before(:each) do
-      provider.stubs(:deletecmd).returns('deletecmd')
+      allow(provider).to receive(:deletecmd).and_return('deletecmd')
     end
 
     it "raises a Puppet::Error if it fails to delete the AIX object" do
-      provider.stubs(:execute).with(provider.deletecmd).raises(
+      allow(provider).to receive(:execute).with(provider.deletecmd).and_raise(
         Puppet::ExecutionFailure, "deletecmd failed!"
       )
 
@@ -796,8 +798,8 @@ bin:2
     end
 
     it "deletes the AIX object" do
-      provider.expects(:execute).with(provider.deletecmd)
-      provider.expects(:object_info).with(true)
+      expect(provider).to receive(:execute).with(provider.deletecmd)
+      expect(provider).to receive(:object_info).with(true)
 
       provider.delete
     end