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

data/spec/unit/provider/user/windows_adsi_spec.rb

@@ -1,5 +1,3 @@
-#!/usr/bin/env ruby
-
 require 'spec_helper'
 
 describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.features.microsoft_windows? do
@@ -13,20 +11,20 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
 
   let(:provider) { resource.provider }
 
-  let(:connection) { stub 'connection' }
+  let(:connection) { double('connection') }
 
   before :each do
-    Puppet::Util::Windows::ADSI.stubs(:computer_name).returns('testcomputername')
-    Puppet::Util::Windows::ADSI.stubs(:connect).returns connection
+    allow(Puppet::Util::Windows::ADSI).to receive(:computer_name).and_return('testcomputername')
+    allow(Puppet::Util::Windows::ADSI).to receive(:connect).and_return(connection)
     # this would normally query the system, but not needed for these tests
-    Puppet::Util::Windows::ADSI::User.stubs(:localized_domains).returns([])
+    allow(Puppet::Util::Windows::ADSI::User).to receive(:localized_domains).and_return([])
   end
 
   describe ".instances" do
     it "should enumerate all users" do
       names = ['user1', 'user2', 'user3']
-      stub_users = names.map{|n| stub(:name => n)}
-      connection.stubs(:execquery).with('select name from win32_useraccount where localaccount = "TRUE"').returns(stub_users)
+      stub_users = names.map {|n| double(:name => n)}
+      allow(connection).to receive(:execquery).with('select name from win32_useraccount where localaccount = "TRUE"').and_return(stub_users)
 
       expect(described_class.instances.map(&:name)).to match(names)
     end
@@ -39,8 +37,8 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
   describe "when retrieving the password property" do
     context "when the resource has a nil password" do
       it "should never issue a logon attempt" do
-        resource.stubs(:[]).with(any_of(:name, :password)).returns(nil)
-        Puppet::Util::Windows::User.expects(:logon_user).never
+        allow(resource).to receive(:[]).with(eq(:name).or(eq(:password))).and_return(nil)
+        expect(Puppet::Util::Windows::User).not_to receive(:logon_user)
         provider.password
       end
     end
@@ -48,42 +46,41 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
 
   describe "when managing groups" do
     it 'should return the list of groups as an array of strings' do
-      provider.user.stubs(:groups).returns nil
+      allow(provider.user).to receive(:groups).and_return(nil)
       groups = {'group1' => nil, 'group2' => nil, 'group3' => nil}
-      Puppet::Util::Windows::ADSI::Group.expects(:name_sid_hash).returns(groups)
+      expect(Puppet::Util::Windows::ADSI::Group).to receive(:name_sid_hash).and_return(groups)
 
       expect(provider.groups).to eq(groups.keys)
     end
 
     it "should return an empty array if there are no groups" do
-      provider.user.stubs(:groups).returns []
+      allow(provider.user).to receive(:groups).and_return([])
 
       expect(provider.groups).to eq([])
     end
 
     it 'should be able to add a user to a set of groups' do
       resource[:membership] = :minimum
-      provider.user.expects(:set_groups).with('group1,group2', true)
+      expect(provider.user).to receive(:set_groups).with('group1,group2', true)
 
       provider.groups = 'group1,group2'
 
       resource[:membership] = :inclusive
-      provider.user.expects(:set_groups).with('group1,group2', false)
+      expect(provider.user).to receive(:set_groups).with('group1,group2', false)
 
       provider.groups = 'group1,group2'
     end
   end
 
   describe "#groups_insync?" do
-
-    let(:group1) { stub(:account => 'group1', :domain => '.', :sid => 'group1sid') }
-    let(:group2) { stub(:account => 'group2', :domain => '.', :sid => 'group2sid') }
-    let(:group3) { stub(:account => 'group3', :domain => '.', :sid => 'group3sid') }
+    let(:group1) { double(:account => 'group1', :domain => '.', :sid => 'group1sid') }
+    let(:group2) { double(:account => 'group2', :domain => '.', :sid => 'group2sid') }
+    let(:group3) { double(:account => 'group3', :domain => '.', :sid => 'group3sid') }
 
     before :each do
-      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('group1').returns(group1)
-      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('group2').returns(group2)
-      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('group3').returns(group3)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('group1').and_return(group1)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('group2').and_return(group2)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('group3').and_return(group3)
     end
 
     it "should return true for same lists of members" do
@@ -191,17 +188,16 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
       resource[:comment]    = 'a test user'
       resource[:home]       = 'C:\Users\testuser'
 
-      user = stub 'user'
-      Puppet::Util::Windows::ADSI::User.expects(:create).with('testuser').returns user
+      user = double('user')
+      expect(Puppet::Util::Windows::ADSI::User).to receive(:create).with('testuser').and_return(user)
 
-      user.stubs(:groups).returns(['group2', 'group3'])
+      allow(user).to receive(:groups).and_return(['group2', 'group3'])
 
-      create = sequence('create')
-      user.expects(:password=).in_sequence(create)
-      user.expects(:commit).in_sequence(create)
-      user.expects(:set_groups).with('group1,group2', false).in_sequence(create)
-      user.expects(:[]=).with('Description', 'a test user')
-      user.expects(:[]=).with('HomeDirectory', 'C:\Users\testuser')
+      expect(user).to receive(:password=).ordered
+      expect(user).to receive(:commit).ordered
+      expect(user).to receive(:set_groups).with('group1,group2', false).ordered
+      expect(user).to receive(:[]=).with('Description', 'a test user')
+      expect(user).to receive(:[]=).with('HomeDirectory', 'C:\Users\testuser')
 
       provider.create
     end
@@ -210,25 +206,28 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
       resource[:password] = '0xDeadBeef'
       resource[:managehome] = true
 
-      user = stub_everything 'user'
-      Puppet::Util::Windows::ADSI::User.expects(:create).with('testuser').returns user
-      Puppet::Util::Windows::User.expects(:load_profile).with('testuser', '0xDeadBeef')
+      user = double('user')
+      allow(user).to receive(:password=)
+      allow(user).to receive(:commit)
+      allow(user).to receive(:[]=)
+      expect(Puppet::Util::Windows::ADSI::User).to receive(:create).with('testuser').and_return(user)
+      expect(Puppet::Util::Windows::User).to receive(:load_profile).with('testuser', '0xDeadBeef')
 
       provider.create
     end
 
     it "should set a user's password" do
-      provider.user.expects(:disabled?).returns(false)
-      provider.user.expects(:locked_out?).returns(false)
-      provider.user.expects(:expired?).returns(false)
-      provider.user.expects(:password=).with('plaintextbad')
+      expect(provider.user).to receive(:disabled?).and_return(false)
+      expect(provider.user).to receive(:locked_out?).and_return(false)
+      expect(provider.user).to receive(:expired?).and_return(false)
+      expect(provider.user).to receive(:password=).with('plaintextbad')
 
       provider.password = "plaintextbad"
     end
 
     it "should test a valid user password" do
       resource[:password] = 'plaintext'
-      provider.user.expects(:password_is?).with('plaintext').returns true
+      expect(provider.user).to receive(:password_is?).with('plaintext').and_return(true)
 
       expect(provider.password).to eq('plaintext')
 
@@ -236,54 +235,54 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
 
     it "should test a bad user password" do
       resource[:password] = 'plaintext'
-      provider.user.expects(:password_is?).with('plaintext').returns false
+      expect(provider.user).to receive(:password_is?).with('plaintext').and_return(false)
 
       expect(provider.password).to be_nil
     end
 
     it "should test a blank user password" do
       resource[:password] = ''
-      provider.user.expects(:password_is?).with('').returns true
+      expect(provider.user).to receive(:password_is?).with('').and_return(true)
 
       expect(provider.password).to eq('')
     end
 
     it 'should not create a user if a group by the same name exists' do
-      Puppet::Util::Windows::ADSI::User.expects(:create).with('testuser').raises( Puppet::Error.new("Cannot create user if group 'testuser' exists.") )
+      expect(Puppet::Util::Windows::ADSI::User).to receive(:create).with('testuser').and_raise(Puppet::Error.new("Cannot create user if group 'testuser' exists."))
       expect{ provider.create }.to raise_error( Puppet::Error,
         /Cannot create user if group 'testuser' exists./ )
     end
 
     it "should fail with an actionable message when trying to create an active directory user" do
       resource[:name] = 'DOMAIN\testdomainuser'
-      Puppet::Util::Windows::ADSI::Group.expects(:exists?).with(resource[:name]).returns(false)
-      connection.expects(:Create)
-      connection.expects(:Get).with('UserFlags')
-      connection.expects(:Put).with('UserFlags', true)
-      connection.expects(:SetInfo).raises( WIN32OLERuntimeError.new("(in OLE method `SetInfo': )\n    OLE error code:8007089A in Active Directory\n      The specified username is invalid.\r\n\n    HRESULT error code:0x80020009\n      Exception occurred."))
+      expect(Puppet::Util::Windows::ADSI::Group).to receive(:exists?).with(resource[:name]).and_return(false)
+      expect(connection).to receive(:Create)
+      expect(connection).to receive(:Get).with('UserFlags')
+      expect(connection).to receive(:Put).with('UserFlags', true)
+      expect(connection).to receive(:SetInfo).and_raise(WIN32OLERuntimeError.new("(in OLE method `SetInfo': )\n    OLE error code:8007089A in Active Directory\n      The specified username is invalid.\r\n\n    HRESULT error code:0x80020009\n      Exception occurred."))
 
       expect{ provider.create }.to raise_error(Puppet::Error)
     end
   end
 
   it 'should be able to test whether a user exists' do
-    Puppet::Util::Windows::SID.stubs(:name_to_principal).returns(nil)
-    Puppet::Util::Windows::ADSI.stubs(:connect).returns stub('connection', :Class => 'User')
+    allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).and_return(nil)
+    allow(Puppet::Util::Windows::ADSI).to receive(:connect).and_return(double('connection', :Class => 'User'))
     expect(provider).to be_exists
 
-    Puppet::Util::Windows::ADSI.stubs(:connect).returns nil
+    allow(Puppet::Util::Windows::ADSI).to receive(:connect).and_return(nil)
     expect(provider).not_to be_exists
   end
 
   it 'should be able to delete a user' do
-    connection.expects(:Delete).with('user', 'testuser')
+    expect(connection).to receive(:Delete).with('user', 'testuser')
 
     provider.delete
   end
 
   it 'should not run commit on a deleted user' do
-    connection.expects(:Delete).with('user', 'testuser')
-    connection.expects(:SetInfo).never
+    expect(connection).to receive(:Delete).with('user', 'testuser')
+    expect(connection).not_to receive(:SetInfo)
 
     provider.delete
     provider.flush
@@ -293,33 +292,33 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
     resource[:managehome] = true
 
     sid = 'S-A-B-C'
-    Puppet::Util::Windows::SID.expects(:name_to_sid).with('testuser').returns(sid)
-    Puppet::Util::Windows::ADSI::UserProfile.expects(:delete).with(sid)
-    connection.expects(:Delete).with('user', 'testuser')
+    expect(Puppet::Util::Windows::SID).to receive(:name_to_sid).with('testuser').and_return(sid)
+    expect(Puppet::Util::Windows::ADSI::UserProfile).to receive(:delete).with(sid)
+    expect(connection).to receive(:Delete).with('user', 'testuser')
 
     provider.delete
   end
 
   it "should commit the user when flushed" do
-    provider.user.expects(:commit)
+    expect(provider.user).to receive(:commit)
 
     provider.flush
   end
 
   it "should return the user's SID as uid" do
-    Puppet::Util::Windows::SID.expects(:name_to_sid).with('testuser').returns('S-1-5-21-1362942247-2130103807-3279964888-1111')
+    expect(Puppet::Util::Windows::SID).to receive(:name_to_sid).with('testuser').and_return('S-1-5-21-1362942247-2130103807-3279964888-1111')
 
     expect(provider.uid).to eq('S-1-5-21-1362942247-2130103807-3279964888-1111')
   end
 
   it "should fail when trying to manage the uid property" do
-    provider.expects(:fail).with { |msg| msg =~ /uid is read-only/ }
+    expect(provider).to receive(:fail).with(/uid is read-only/)
     provider.send(:uid=, 500)
   end
 
   [:gid, :shell].each do |prop|
     it "should fail when trying to manage the #{prop} property" do
-      provider.expects(:fail).with { |msg| msg =~ /No support for managing property #{prop}/ }
+      expect(provider).to receive(:fail).with(/No support for managing property #{prop}/)
       provider.send("#{prop}=", 'foo')
     end
   end

data/spec/unit/provider/vlan/cisco_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/provider/vlan/cisco'
@@ -7,8 +6,8 @@ provider_class = Puppet::Type.type(:vlan).provider(:cisco)
 
 describe provider_class do
   before do
-    @device = stub_everything 'device'
-    @resource = stub("resource", :name => "200")
+    @device = double('device')
+    @resource = double("resource", :name => "200")
     @provider = provider_class.new(@device, @resource)
   end
 
@@ -22,19 +21,18 @@ describe provider_class do
 
   describe "when looking up instances at prefetch" do
     before do
-      @device.stubs(:command).yields(@device)
+      allow(@device).to receive(:command).and_yield(@device)
     end
 
     it "should delegate to the device vlans" do
-      @device.expects(:parse_vlans)
+      expect(@device).to receive(:parse_vlans)
       provider_class.lookup(@device, "200")
     end
 
     it "should return only the given vlan" do
-      @device.expects(:parse_vlans).returns({"200" => { :description => "thisone" }, "1" => { :description => "nothisone" }})
+      expect(@device).to receive(:parse_vlans).and_return({"200" => { :description => "thisone" }, "1" => { :description => "nothisone" }})
       expect(provider_class.lookup(@device, "200")).to eq({:description => "thisone" })
     end
-
   end
 
   describe "when an instance is being flushed" do
@@ -42,11 +40,11 @@ describe provider_class do
       @instance = provider_class.new(@device, :ensure => :present, :name => "200", :description => "myvlan")
       @instance.description = "myvlan2"
       @instance.resource = @resource
-      @resource.stubs(:[]).with(:name).returns("200")
-      device = stub_everything 'device'
-      @instance.stubs(:device).returns(device)
-      device.expects(:command).yields(device)
-      device.expects(:update_vlan).with(@instance.name, {:ensure => :present, :name => "200", :description => "myvlan"},
+      allow(@resource).to receive(:[]).with(:name).and_return("200")
+      device = double('device')
+      allow(@instance).to receive(:device).and_return(device)
+      expect(device).to receive(:command).and_yield(device)
+      expect(device).to receive(:update_vlan).with(@instance.name, {:ensure => :present, :name => "200", :description => "myvlan"},
                                                    {:ensure => :present, :name => "200", :description => "myvlan2"})
 
       @instance.flush

data/spec/unit/provider/yumrepo/inifile_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 require 'puppet_spec/files'
 
 describe Puppet::Type.type(:yumrepo).provider(:inifile) do
-
   include PuppetSpec::Files
 
   after(:each) do
@@ -11,9 +10,9 @@ describe Puppet::Type.type(:yumrepo).provider(:inifile) do
 
   describe "enumerating all yum repo files" do
     it "reads all files in the directories specified by reposdir" do
-      described_class.expects(:reposdir).returns ['/etc/yum.repos.d']
+      expect(described_class).to receive(:reposdir).and_return(['/etc/yum.repos.d'])
 
-      Dir.expects(:glob).with("/etc/yum.repos.d/*.repo").returns(['/etc/yum.repos.d/first.repo', '/etc/yum.repos.d/second.repo'])
+      expect(Dir).to receive(:glob).with("/etc/yum.repos.d/*.repo").and_return(['/etc/yum.repos.d/first.repo', '/etc/yum.repos.d/second.repo'])
 
       actual = described_class.repofiles
       expect(actual).to include("/etc/yum.repos.d/first.repo")
@@ -21,7 +20,7 @@ describe Puppet::Type.type(:yumrepo).provider(:inifile) do
     end
 
     it "includes '/etc/yum.conf' as the first element" do
-      described_class.expects(:reposdir).returns []
+      expect(described_class).to receive(:reposdir).and_return([])
 
       actual = described_class.repofiles
       expect(actual[0]).to eq "/etc/yum.conf"
@@ -30,42 +29,42 @@ describe Puppet::Type.type(:yumrepo).provider(:inifile) do
 
   describe "generating the virtual inifile" do
     let(:files) { ['/etc/yum.repos.d/first.repo', '/etc/yum.repos.d/second.repo', '/etc/yum.conf'] }
-    let(:collection) { mock('virtual inifile') }
+    let(:collection) { double('virtual inifile') }
 
     before do
       described_class.clear
-      Puppet::Util::IniConfig::FileCollection.expects(:new).returns collection
+      expect(Puppet::Util::IniConfig::FileCollection).to receive(:new).and_return(collection)
     end
 
     it "reads all files in the directories specified by self.repofiles" do
-      described_class.expects(:repofiles).returns(files)
+      expect(described_class).to receive(:repofiles).and_return(files)
 
       files.each do |file|
-        Puppet::FileSystem.stubs(:file?).with(file).returns true
-        collection.expects(:read).with(file)
+        allow(Puppet::FileSystem).to receive(:file?).with(file).and_return(true)
+        expect(collection).to receive(:read).with(file)
       end
       described_class.virtual_inifile
     end
 
     it "ignores repofile entries that are not files" do
-      described_class.expects(:repofiles).returns(files)
+      expect(described_class).to receive(:repofiles).and_return(files)
 
-      Puppet::FileSystem.stubs(:file?).with('/etc/yum.repos.d/first.repo').returns true
-      Puppet::FileSystem.stubs(:file?).with('/etc/yum.repos.d/second.repo').returns false
-      Puppet::FileSystem.stubs(:file?).with('/etc/yum.conf').returns true
+      allow(Puppet::FileSystem).to receive(:file?).with('/etc/yum.repos.d/first.repo').and_return(true)
+      allow(Puppet::FileSystem).to receive(:file?).with('/etc/yum.repos.d/second.repo').and_return(false)
+      allow(Puppet::FileSystem).to receive(:file?).with('/etc/yum.conf').and_return(true)
 
-      collection.expects(:read).with('/etc/yum.repos.d/first.repo').once
-      collection.expects(:read).with('/etc/yum.repos.d/second.repo').never
-      collection.expects(:read).with('/etc/yum.conf').once
+      expect(collection).to receive(:read).with('/etc/yum.repos.d/first.repo').once
+      expect(collection).not_to receive(:read).with('/etc/yum.repos.d/second.repo')
+      expect(collection).to receive(:read).with('/etc/yum.conf').once
       described_class.virtual_inifile
     end
   end
 
   describe 'creating provider instances' do
-    let(:virtual_inifile) { stub('virtual inifile') }
+    let(:virtual_inifile) { double('virtual inifile') }
 
     before :each do
-      described_class.stubs(:virtual_inifile).returns(virtual_inifile)
+      allow(described_class).to receive(:virtual_inifile).and_return(virtual_inifile)
     end
 
     let(:main_section) do
@@ -85,7 +84,7 @@ describe Puppet::Type.type(:yumrepo).provider(:inifile) do
     end
 
     it "ignores the main section" do
-      virtual_inifile.expects(:each_section).multiple_yields(main_section, updates_section)
+      expect(virtual_inifile).to receive(:each_section).and_yield(main_section).and_yield(updates_section)
 
       instances = described_class.instances
       expect(instances).to have(1).items
@@ -93,7 +92,7 @@ describe Puppet::Type.type(:yumrepo).provider(:inifile) do
     end
 
     it "creates provider instances for every non-main section that was found" do
-      virtual_inifile.expects(:each_section).multiple_yields(main_section, updates_section)
+      expect(virtual_inifile).to receive(:each_section).and_yield(main_section).and_yield(updates_section)
 
       sect = described_class.instances.first
       expect(sect.name).to eq 'updates'
@@ -103,18 +102,16 @@ describe Puppet::Type.type(:yumrepo).provider(:inifile) do
   end
 
   describe "retrieving a section from the inifile" do
-
-    let(:collection) { stub('ini file collection') }
-
-    let(:ini_section) { stub('ini file section') }
+    let(:collection) { double('ini file collection') }
+    let(:ini_section) { double('ini file section') }
 
     before do
-      described_class.stubs(:virtual_inifile).returns(collection)
+      allow(described_class).to receive(:virtual_inifile).and_return(collection)
     end
 
     describe "and the requested section exists" do
       before do
-        collection.stubs(:[]).with('updates').returns ini_section
+        allow(collection).to receive(:[]).with('updates').and_return(ini_section)
       end
 
       it "returns the existing section" do
@@ -122,24 +119,24 @@ describe Puppet::Type.type(:yumrepo).provider(:inifile) do
       end
 
       it "doesn't create a new section" do
-        collection.expects(:add_section).never
+        expect(collection).not_to receive(:add_section)
         described_class.section('updates')
       end
     end
 
     describe "and the requested section doesn't exist" do
       it "creates a section in the preferred repodir" do
-        described_class.stubs(:reposdir).returns ['/etc/yum.repos.d', '/etc/alternate.repos.d']
-        collection.expects(:[]).with('updates')
-        collection.expects(:add_section).with('updates', '/etc/alternate.repos.d/updates.repo')
+        allow(described_class).to receive(:reposdir).and_return(['/etc/yum.repos.d', '/etc/alternate.repos.d'])
+        expect(collection).to receive(:[]).with('updates')
+        expect(collection).to receive(:add_section).with('updates', '/etc/alternate.repos.d/updates.repo')
 
         described_class.section('updates')
       end
 
       it "creates a section in yum.conf if no repodirs exist" do
-        described_class.stubs(:reposdir).returns []
-        collection.expects(:[]).with('updates')
-        collection.expects(:add_section).with('updates', '/etc/yum.conf')
+        allow(described_class).to receive(:reposdir).and_return([])
+        expect(collection).to receive(:[]).with('updates')
+        expect(collection).to receive(:add_section).with('updates', '/etc/yum.conf')
 
         described_class.section('updates')
       end
@@ -147,7 +144,6 @@ describe Puppet::Type.type(:yumrepo).provider(:inifile) do
   end
 
   describe "setting and getting properties" do
-
     let(:type_instance) do
       Puppet::Type.type(:yumrepo).new(
         :name     => 'puppetlabs-products',
@@ -165,68 +161,68 @@ describe Puppet::Type.type(:yumrepo).provider(:inifile) do
     end
 
     let(:section) do
-      stub('inifile puppetlabs section', :name => 'puppetlabs-products')
+      double('inifile puppetlabs section', :name => 'puppetlabs-products')
     end
 
     before do
       type_instance.provider = provider
-      described_class.stubs(:section).with('puppetlabs-products').returns(section)
+      allow(described_class).to receive(:section).with('puppetlabs-products').and_return(section)
     end
 
     describe "methods used by ensurable" do
       it "#create sets the yumrepo properties on the according section" do
-        section.expects(:[]=).with('baseurl', 'http://yum.puppetlabs.com/el/6/products/$basearch')
-        section.expects(:[]=).with('name', 'Puppet Labs Products El 6 - $basearch')
-        section.expects(:[]=).with('enabled', '1')
-        section.expects(:[]=).with('gpgcheck', '1')
-        section.expects(:[]=).with('gpgkey', 'file:///etc/pki/rpm-gpg/RPM-GPG-KEY-puppetlabs')
+        expect(section).to receive(:[]=).with('baseurl', 'http://yum.puppetlabs.com/el/6/products/$basearch')
+        expect(section).to receive(:[]=).with('name', 'Puppet Labs Products El 6 - $basearch')
+        expect(section).to receive(:[]=).with('enabled', '1')
+        expect(section).to receive(:[]=).with('gpgcheck', '1')
+        expect(section).to receive(:[]=).with('gpgkey', 'file:///etc/pki/rpm-gpg/RPM-GPG-KEY-puppetlabs')
 
         provider.create
       end
 
       it "#exists? checks if the repo has been marked as present" do
-        described_class.stubs(:section).returns(stub(:[]= => nil))
+        allow(described_class).to receive(:section).and_return(double(:[]= => nil))
         provider.create
         expect(provider).to be_exist
       end
 
       it "#destroy deletes the associated ini file section" do
-        described_class.expects(:section).returns(section)
-        section.expects(:destroy=).with(true)
+        expect(described_class).to receive(:section).and_return(section)
+        expect(section).to receive(:destroy=).with(true)
         provider.destroy
       end
     end
 
     describe "getting properties" do
       it "maps the 'descr' property to the 'name' INI property" do
-        section.expects(:[]).with('name').returns 'Some rather long description of the repository'
+        expect(section).to receive(:[]).with('name').and_return('Some rather long description of the repository')
         expect(provider.descr).to eq 'Some rather long description of the repository'
       end
 
       it "gets the property from the INI section" do
-        section.expects(:[]).with('enabled').returns '1'
+        expect(section).to receive(:[]).with('enabled').and_return('1')
         expect(provider.enabled).to eq '1'
       end
 
       it "sets the property as :absent if the INI property is nil" do
-        section.expects(:[]).with('exclude').returns nil
+        expect(section).to receive(:[]).with('exclude').and_return(nil)
         expect(provider.exclude).to eq :absent
       end
     end
 
     describe "setting properties" do
       it "maps the 'descr' property to the 'name' INI property" do
-        section.expects(:[]=).with('name', 'Some rather long description of the repository')
+        expect(section).to receive(:[]=).with('name', 'Some rather long description of the repository')
         provider.descr = 'Some rather long description of the repository'
       end
 
       it "sets the property on the INI section" do
-        section.expects(:[]=).with('enabled', '0')
+        expect(section).to receive(:[]=).with('enabled', '0')
         provider.enabled = '0'
       end
 
       it "sets the section field to nil when the specified value is absent" do
-        section.expects(:[]=).with('exclude', nil)
+        expect(section).to receive(:[]=).with('exclude', nil)
         provider.exclude = :absent
       end
     end
@@ -236,51 +232,50 @@ describe Puppet::Type.type(:yumrepo).provider(:inifile) do
     let(:defaults) { ['/etc/yum.repos.d', '/etc/yum/repos.d'] }
 
     before do
-      Puppet::FileSystem.stubs(:exist?).with('/etc/yum.repos.d').returns(true)
-      Puppet::FileSystem.stubs(:exist?).with('/etc/yum/repos.d').returns(true)
+      allow(Puppet::FileSystem).to receive(:exist?).with('/etc/yum.repos.d').and_return(true)
+      allow(Puppet::FileSystem).to receive(:exist?).with('/etc/yum/repos.d').and_return(true)
     end
 
     it "returns the default directories if yum.conf doesn't contain a `reposdir` entry" do
-      described_class.stubs(:find_conf_value).with('reposdir', '/etc/yum.conf')
+      allow(described_class).to receive(:find_conf_value).with('reposdir', '/etc/yum.conf')
       expect(described_class.reposdir('/etc/yum.conf')).to eq(defaults)
     end
 
     it "includes the directory specified by the yum.conf 'reposdir' entry when the directory is present" do
-      Puppet::FileSystem.expects(:exist?).with("/etc/yum/extra.repos.d").returns(true)
+      expect(Puppet::FileSystem).to receive(:exist?).with("/etc/yum/extra.repos.d").and_return(true)
 
-      described_class.expects(:find_conf_value).with('reposdir', '/etc/yum.conf').returns "/etc/yum/extra.repos.d"
+      expect(described_class).to receive(:find_conf_value).with('reposdir', '/etc/yum.conf').and_return("/etc/yum/extra.repos.d")
       expect(described_class.reposdir('/etc/yum.conf')).to include("/etc/yum/extra.repos.d")
     end
 
     it "includes the directory if the value is split by whitespace" do
-      Puppet::FileSystem.expects(:exist?).with("/etc/yum/extra.repos.d").returns(true)
-      Puppet::FileSystem.expects(:exist?).with("/etc/yum/misc.repos.d").returns(true)
+      expect(Puppet::FileSystem).to receive(:exist?).with("/etc/yum/extra.repos.d").and_return(true)
+      expect(Puppet::FileSystem).to receive(:exist?).with("/etc/yum/misc.repos.d").and_return(true)
 
-      described_class.expects(:find_conf_value).with('reposdir', '/etc/yum.conf').returns "/etc/yum/extra.repos.d /etc/yum/misc.repos.d"
+      expect(described_class).to receive(:find_conf_value).with('reposdir', '/etc/yum.conf').and_return("/etc/yum/extra.repos.d /etc/yum/misc.repos.d")
       expect(described_class.reposdir('/etc/yum.conf')).to include("/etc/yum/extra.repos.d", "/etc/yum/misc.repos.d")
     end
 
     it "includes the directory if the value is split by new lines" do
-      Puppet::FileSystem.expects(:exist?).with("/etc/yum/extra.repos.d").returns(true)
-      Puppet::FileSystem.expects(:exist?).with("/etc/yum/misc.repos.d").returns(true)
+      expect(Puppet::FileSystem).to receive(:exist?).with("/etc/yum/extra.repos.d").and_return(true)
+      expect(Puppet::FileSystem).to receive(:exist?).with("/etc/yum/misc.repos.d").and_return(true)
 
-      described_class.expects(:find_conf_value).with('reposdir', '/etc/yum.conf').returns "/etc/yum/extra.repos.d\n/etc/yum/misc.repos.d"
+      expect(described_class).to receive(:find_conf_value).with('reposdir', '/etc/yum.conf').and_return("/etc/yum/extra.repos.d\n/etc/yum/misc.repos.d")
       expect(described_class.reposdir('/etc/yum.conf')).to include("/etc/yum/extra.repos.d", "/etc/yum/misc.repos.d")
     end
 
     it "doesn't include the directory specified by the yum.conf 'reposdir' entry when the directory is absent" do
-      Puppet::FileSystem.expects(:exist?).with("/etc/yum/extra.repos.d").returns(false)
+      expect(Puppet::FileSystem).to receive(:exist?).with("/etc/yum/extra.repos.d").and_return(false)
 
-      described_class.expects(:find_conf_value).with('reposdir', '/etc/yum.conf').returns "/etc/yum/extra.repos.d"
+      expect(described_class).to receive(:find_conf_value).with('reposdir', '/etc/yum.conf').and_return("/etc/yum/extra.repos.d")
       expect(described_class.reposdir('/etc/yum.conf')).not_to include("/etc/yum/extra.repos.d")
     end
 
     it "logs a warning and returns an empty array if none of the specified repo directories exist" do
-      Puppet::FileSystem.unstub(:exist?)
-      Puppet::FileSystem.stubs(:exist?).returns false
+      allow(Puppet::FileSystem).to receive(:exist?).and_return(false)
 
-      described_class.stubs(:find_conf_value).with('reposdir', '/etc/yum.conf')
-      Puppet.expects(:debug).with('No yum directories were found on the local filesystem')
+      allow(described_class).to receive(:find_conf_value).with('reposdir', '/etc/yum.conf')
+      expect(Puppet).to receive(:debug).with('No yum directories were found on the local filesystem')
       expect(described_class.reposdir('/etc/yum.conf')).to be_empty
     end
   end
@@ -288,40 +283,40 @@ describe Puppet::Type.type(:yumrepo).provider(:inifile) do
   describe "looking up a conf value" do
     describe "and the file doesn't exist" do
       it "returns nil" do
-        Puppet::FileSystem.stubs(:exist?).returns false
+        allow(Puppet::FileSystem).to receive(:exist?).and_return(false)
         expect(described_class.find_conf_value('reposdir')).to be_nil
       end
     end
 
     describe "and the file exists" do
-      let(:pfile) { stub('yum.conf physical file') }
-      let(:sect) { stub('ini section') }
+      let(:pfile) { double('yum.conf physical file') }
+      let(:sect ) { double('ini section') }
 
       before do
-        Puppet::FileSystem.stubs(:exist?).with('/etc/yum.conf').returns true
-        Puppet::Util::IniConfig::PhysicalFile.stubs(:new).with('/etc/yum.conf').returns pfile
-        pfile.expects(:read)
+        allow(Puppet::FileSystem).to receive(:exist?).with('/etc/yum.conf').and_return(true)
+        allow(Puppet::Util::IniConfig::PhysicalFile).to receive(:new).with('/etc/yum.conf').and_return(pfile)
+        expect(pfile).to receive(:read)
       end
 
       it "creates a PhysicalFile to parse the given file" do
-        pfile.expects(:get_section)
+        expect(pfile).to receive(:get_section)
         described_class.find_conf_value('reposdir')
       end
 
       it "returns nil if the file exists but the 'main' section doesn't exist" do
-        pfile.expects(:get_section).with('main')
+        expect(pfile).to receive(:get_section).with('main')
         expect(described_class.find_conf_value('reposdir')).to be_nil
       end
 
       it "returns nil if the file exists but the INI property doesn't exist" do
-        pfile.expects(:get_section).with('main').returns sect
-        sect.expects(:[]).with('reposdir')
+        expect(pfile).to receive(:get_section).with('main').and_return(sect)
+        expect(sect).to receive(:[]).with('reposdir')
         expect(described_class.find_conf_value('reposdir')).to be_nil
       end
 
       it "returns the value if the value is defined in the PhysicalFile" do
-        pfile.expects(:get_section).with('main').returns sect
-        sect.expects(:[]).with('reposdir').returns '/etc/alternate.repos.d'
+        expect(pfile).to receive(:get_section).with('main').and_return(sect)
+        expect(sect).to receive(:[]).with('reposdir').and_return('/etc/alternate.repos.d')
         expect(described_class.find_conf_value('reposdir')).to eq '/etc/alternate.repos.d'
       end
     end
@@ -347,7 +342,7 @@ describe Puppet::Type.type(:yumrepo).provider(:inifile) do
     before :each do
       @yumrepo_dir = tmpdir('yumrepo_integration_specs')
       @yumrepo_conf_file = tmpfile('yumrepo_conf_file', @yumrepo_dir)
-      described_class.stubs(:reposdir).returns [@yumrepo_dir]
+      allow(described_class).to receive(:reposdir).and_return([@yumrepo_dir])
       type_instance.provider = provider
     end