puppet 6.0.7-x86-mingw32 → 6.0.8-x86-mingw32

data/spec/unit/provider/package/freebsd_spec.rb

@@ -3,14 +3,14 @@ require 'spec_helper'
 describe Puppet::Type.type(:package).provider(:freebsd) do
   before :each do
     # Create a mock resource
-    @resource = stub 'resource'
+    @resource = double('resource')
 
     # A catch all; no parameters set
-    @resource.stubs(:[]).returns(nil)
+    allow(@resource).to receive(:[]).and_return(nil)
 
     # But set name and source
-    @resource.stubs(:[]).with(:name).returns   "mypackage"
-    @resource.stubs(:[]).with(:ensure).returns :installed
+    allow(@resource).to receive(:[]).with(:name).and_return("mypackage")
+    allow(@resource).to receive(:[]).with(:ensure).and_return(:installed)
 
     @provider = subject()
     @provider.resource = @resource
@@ -23,15 +23,15 @@ describe Puppet::Type.type(:package).provider(:freebsd) do
 
   context "when installing" do
     before :each do
-      @resource.stubs(:should).with(:ensure).returns(:installed)
+      allow(@resource).to receive(:should).with(:ensure).and_return(:installed)
     end
 
     it "should install a package from a path to a directory" do
       # For better or worse, trailing '/' is needed. --daniel 2011-01-26
       path = '/path/to/directory/'
-      @resource.stubs(:[]).with(:source).returns(path)
-      Puppet::Util.expects(:withenv).once.with({:PKG_PATH => path}).yields
-      @provider.expects(:pkgadd).once.with("mypackage")
+      allow(@resource).to receive(:[]).with(:source).and_return(path)
+      expect(Puppet::Util).to receive(:withenv).once.with({:PKG_PATH => path}).and_yield
+      expect(@provider).to receive(:pkgadd).once.with("mypackage")
 
       expect { @provider.install }.to_not raise_error
     end
@@ -40,9 +40,9 @@ describe Puppet::Type.type(:package).provider(:freebsd) do
       it "should install a package via #{protocol}" do
         # For better or worse, trailing '/' is needed. --daniel 2011-01-26
         path = "#{protocol}://localhost/"
-        @resource.stubs(:[]).with(:source).returns(path)
-        Puppet::Util.expects(:withenv).once.with({:PACKAGESITE => path}).yields
-        @provider.expects(:pkgadd).once.with('-r', "mypackage")
+        allow(@resource).to receive(:[]).with(:source).and_return(path)
+        expect(Puppet::Util).to receive(:withenv).once.with({:PACKAGESITE => path}).and_yield
+        expect(@provider).to receive(:pkgadd).once.with('-r', "mypackage")
 
         expect { @provider.install }.to_not raise_error
       end

data/spec/unit/provider/package/gem_spec.rb

@@ -21,39 +21,43 @@ context Puppet::Type.type(:package).provider(:gem) do
 
     context "when installing" do
       it "should use the path to the gem" do
-        described_class.stubs(:command).with(:gemcmd).returns "/my/gem"
-        provider.expects(:execute).with { |args| args[0] == "/my/gem" }.returns ""
+        allow(described_class).to receive(:command).with(:gemcmd).and_return("/my/gem")
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[0]).to eq("/my/gem") }.and_return("")
         provider.install
       end
 
       it "should specify that the gem is being installed" do
-        provider.expects(:execute).with { |args| args[1] == "install" }.returns ""
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[1]).to eq("install") }.and_return("")
         provider.install
       end
 
       it "should specify that documentation should not be included" do
-        provider.expects(:execute).with { |args| args[2] == "--no-rdoc" }.returns ""
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[2]).to eq("--no-rdoc") }.and_return("")
         provider.install
       end
 
       it "should specify that RI should not be included" do
-        provider.expects(:execute).with { |args| args[3] == "--no-ri" }.returns ""
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[3]).to eq("--no-ri") }.and_return("")
         provider.install
       end
 
       it "should specify the package name" do
-        provider.expects(:execute).with { |args| args[4] == "myresource" }.returns ""
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[4]).to eq("myresource") }.and_return("")
         provider.install
       end
 
       it "should not append install_options by default" do
-        provider.expects(:execute).with { |args| args.length == 5 }.returns ""
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args.length).to eq(5) }.and_return("")
         provider.install
       end
 
       it "should allow setting an install_options parameter" do
         resource[:install_options] = [ '--force', {'--bindir' => '/usr/bin' } ]
-        provider.expects(:execute).with { |args| args[2] == '--force' && args[3] == '--bindir=/usr/bin' }.returns ''
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) do |args|
+          expect(args[2]).to eq('--force')
+          expect(args[3]).to eq('--bindir=/usr/bin')
+        end.and_return('')
+
         provider.install
       end
 
@@ -61,7 +65,7 @@ context Puppet::Type.type(:package).provider(:gem) do
         context "as a normal file" do
           it "should use the file name instead of the gem name" do
             resource[:source] = "/my/file"
-            provider.expects(:execute).with { |args| args[2] == "/my/file" }.returns ""
+            expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[2]).to eq("/my/file") }.and_return("")
             provider.install
           end
         end
@@ -69,7 +73,7 @@ context Puppet::Type.type(:package).provider(:gem) do
         context "as a file url" do
           it "should use the file name instead of the gem name" do
             resource[:source] = "file:///my/file"
-            provider.expects(:execute).with { |args| args[2] == "/my/file" }.returns ""
+            expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[2]).to eq("/my/file") }.and_return("")
             provider.install
           end
         end
@@ -84,7 +88,7 @@ context Puppet::Type.type(:package).provider(:gem) do
         context "as a non-file and non-puppet url" do
           it "should treat the source as a gem repository" do
             resource[:source] = "http://host/my/file"
-            provider.expects(:execute).with { |args| args[2..4] == ["--source", "http://host/my/file", "myresource"] }.returns ""
+            expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[2..4]).to eq(["--source", "http://host/my/file", "myresource"]) }.and_return("")
             provider.install
           end
         end
@@ -92,14 +96,14 @@ context Puppet::Type.type(:package).provider(:gem) do
         context "as a windows path on windows", :if => Puppet::Util::Platform.windows? do
           it "should treat the source as a local path" do
             resource[:source] = "c:/this/is/a/path/to/a/gem.gem"
-            provider.expects(:execute).with { |args| args[2] == "c:/this/is/a/path/to/a/gem.gem" }.returns ""
+            expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[2]).to eq("c:/this/is/a/path/to/a/gem.gem") }.and_return("")
             provider.install
           end
         end
 
         context "with an invalid uri" do
           it "should fail" do
-            URI.expects(:parse).raises(ArgumentError)
+            expect(URI).to receive(:parse).and_raise(ArgumentError)
             resource[:source] = "http:::::uppet:/:/my/file"
             expect { provider.install }.to raise_error(Puppet::Error)
           end
@@ -112,7 +116,7 @@ context Puppet::Type.type(:package).provider(:gem) do
         #gemlist is used for retrieving both local and remote version numbers, and there are cases
         # (particularly local) where it makes sense for it to return an array.  That doesn't make
         # sense for '#latest', though.
-        provider.class.expects(:gemlist).with({ :justme => 'myresource'}).returns({
+        expect(provider.class).to receive(:gemlist).with({:justme => 'myresource'}).and_return({
           :name     => 'myresource',
           :ensure   => ["3.0"],
           :provider => :gem,
@@ -122,29 +126,29 @@ context Puppet::Type.type(:package).provider(:gem) do
 
       it "should list from the specified source repository" do
         resource[:source] = "http://foo.bar.baz/gems"
-        provider.class.expects(:gemlist).
+        expect(provider.class).to receive(:gemlist).
           with({:justme => 'myresource', :source => "http://foo.bar.baz/gems"}).
-          returns({
+          and_return({
             :name     => 'myresource',
             :ensure   => ["3.0"],
             :provider => :gem,
           })
-          expect(provider.latest).to eq("3.0")
+        expect(provider.latest).to eq("3.0")
       end
     end
 
     context "#instances" do
       before do
-        described_class.stubs(:command).with(:gemcmd).returns "/my/gem"
+        allow(described_class).to receive(:command).with(:gemcmd).and_return("/my/gem")
       end
 
       it "should return an empty array when no gems installed" do
-        described_class.expects(:execute).with(%w{/my/gem list --local}, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).returns("\n")
+        expect(described_class).to receive(:execute).with(%w{/my/gem list --local}, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).and_return("\n")
         expect(described_class.instances).to eq([])
       end
 
       it "should return ensure values as an array of installed versions" do
-        described_class.expects(:execute).with(%w{/my/gem list --local}, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).returns <<-HEREDOC.gsub(/        /, '')
+        expect(described_class).to receive(:execute).with(%w{/my/gem list --local}, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).and_return(<<-HEREDOC.gsub(/        /, ''))
         systemu (1.2.0)
         vagrant (0.8.7, 0.6.9)
         HEREDOC
@@ -156,7 +160,7 @@ context Puppet::Type.type(:package).provider(:gem) do
       end
 
       it "should ignore platform specifications" do
-        described_class.expects(:execute).with(%w{/my/gem list --local}, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).returns <<-HEREDOC.gsub(/        /, '')
+        expect(described_class).to receive(:execute).with(%w{/my/gem list --local}, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).and_return(<<-HEREDOC.gsub(/        /, ''))
         systemu (1.2.0)
         nokogiri (1.6.1 ruby java x86-mingw32 x86-mswin32-60, 1.4.4.1 x86-mswin32)
         HEREDOC
@@ -168,7 +172,7 @@ context Puppet::Type.type(:package).provider(:gem) do
       end
 
       it "should not list 'default: ' text from rubygems''" do
-        described_class.expects(:execute).with(%w{/my/gem list --local}, anything).returns <<-HEREDOC.gsub(/        /, '')
+        expect(described_class).to receive(:execute).with(%w{/my/gem list --local}, anything).and_return(<<-HEREDOC.gsub(/        /, ''))
         bundler (1.16.1, default: 1.16.0, 1.15.1)
         HEREDOC
 
@@ -178,27 +182,27 @@ context Puppet::Type.type(:package).provider(:gem) do
       end
 
       it "should not fail when an unmatched line is returned" do
-        described_class.expects(:execute).with(%w{/my/gem list --local}, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).
-          returns(File.read(my_fixture('line-with-1.8.5-warning')))
+        expect(described_class).to receive(:execute).with(%w{/my/gem list --local}, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).
+          and_return(File.read(my_fixture('line-with-1.8.5-warning')))
 
         expect(described_class.instances.map {|p| p.properties}).
-          to eq([{:provider=>:gem, :ensure=>["0.3.2"], :name=>"columnize"},
-                 {:provider=>:gem, :ensure=>["1.1.3"], :name=>"diff-lcs"},
-                 {:provider=>:gem, :ensure=>["0.0.1"], :name=>"metaclass"},
-                 {:provider=>:gem, :ensure=>["0.10.5"], :name=>"mocha"},
-                 {:provider=>:gem, :ensure=>["0.8.7"], :name=>"rake"},
-                 {:provider=>:gem, :ensure=>["2.9.0"], :name=>"rspec-core"},
-                 {:provider=>:gem, :ensure=>["2.9.1"], :name=>"rspec-expectations"},
-                 {:provider=>:gem, :ensure=>["2.9.0"], :name=>"rspec-mocks"},
-                 {:provider=>:gem, :ensure=>["0.9.0"], :name=>"rubygems-bundler"},
-                 {:provider=>:gem, :ensure=>["1.11.3.3"], :name=>"rvm"}])
+          to eq([{provider: :gem, ensure: ["0.3.2"],    name: "columnize"},
+                 {provider: :gem, ensure: ["1.1.3"],    name: "diff-lcs"},
+                 {provider: :gem, ensure: ["0.0.1"],    name: "metaclass"},
+                 {provider: :gem, ensure: ["0.10.5"],   name: "mocha"},
+                 {provider: :gem, ensure: ["0.8.7"],    name: "rake"},
+                 {provider: :gem, ensure: ["2.9.0"],    name: "rspec-core"},
+                 {provider: :gem, ensure: ["2.9.1"],    name: "rspec-expectations"},
+                 {provider: :gem, ensure: ["2.9.0"],    name: "rspec-mocks"},
+                 {provider: :gem, ensure: ["0.9.0"],    name: "rubygems-bundler"},
+                 {provider: :gem, ensure: ["1.11.3.3"], name: "rvm"}])
       end
     end
 
     context "listing gems" do
       context "searching for a single package" do
         it "searches for an exact match" do
-          described_class.expects(:execute).with(includes('\Abundler\z'), {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).returns(File.read(my_fixture('gem-list-single-package')))
+          expect(described_class).to receive(:execute).with(include('\Abundler\z'), {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).and_return(File.read(my_fixture('gem-list-single-package')))
           expected = {:name => 'bundler', :ensure => %w[1.6.2], :provider => :gem}
           expect(described_class.gemlist({:justme => 'bundler'})).to eq(expected)
         end
@@ -296,39 +300,43 @@ context Puppet::Type.type(:package).provider(:gem) do
 
     context "when uninstalling" do
       it "should use the path to the gem" do
-        described_class.stubs(:command).with(:gemcmd).returns "/my/gem"
-        provider.expects(:execute).with { |args| args[0] == "/my/gem" }.returns ""
+        allow(described_class).to receive(:command).with(:gemcmd).and_return("/my/gem")
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[0]).to eq("/my/gem") }.and_return("")
         provider.uninstall
       end
 
       it "should specify that the gem is being uninstalled" do
-        provider.expects(:execute).with { |args| args[1] == "uninstall" }.returns ""
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[1]).to eq("uninstall") }.and_return("")
         provider.uninstall
       end
 
       it "should specify that the relevant executables should be removed without confirmation" do
-        provider.expects(:execute).with { |args| args[2] == "--executables" }.returns ""
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[2]).to eq("--executables") }.and_return("")
         provider.uninstall
       end
 
       it "should specify that all the matching versions should be removed" do
-        provider.expects(:execute).with { |args| args[3] == "--all" }.returns ""
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[3]).to eq("--all") }.and_return("")
         provider.uninstall
       end
 
       it "should specify the package name" do
-        provider.expects(:execute).with { |args| args[4] == "myresource" }.returns ""
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[4]).to eq("myresource") }.and_return("")
         provider.uninstall
       end
 
       it "should not append uninstall_options by default" do
-        provider.expects(:execute).with { |args| args.length == 5 }.returns ""
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args.length).to eq(5) }.and_return("")
         provider.uninstall
       end
 
       it "should allow setting an uninstall_options parameter" do
         resource[:uninstall_options] = [ '--ignore-dependencies', {'--version' => '0.1.1' } ]
-        provider.expects(:execute).with { |args| args[5] == '--ignore-dependencies' && args[6] == '--version=0.1.1' }.returns ''
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) do |args|
+          expect(args[5]).to eq('--ignore-dependencies')
+          expect(args[6]).to eq('--version=0.1.1')
+        end.and_return('')
+
         provider.uninstall
       end
     end

data/spec/unit/provider/package/hpux_spec.rb

@@ -3,18 +3,18 @@ require 'spec_helper'
 describe Puppet::Type.type(:package).provider(:hpux) do
   before(:each) do
     # Create a mock resource
-    @resource = stub 'resource'
+    @resource = double('resource')
 
     # A catch all; no parameters set
-    @resource.stubs(:[]).returns(nil)
+    allow(@resource).to receive(:[]).and_return(nil)
 
     # But set name and source
-    @resource.stubs(:[]).with(:name).returns "mypackage"
-    @resource.stubs(:[]).with(:source).returns "mysource"
-    @resource.stubs(:[]).with(:ensure).returns :installed
+    allow(@resource).to receive(:[]).with(:name).and_return("mypackage")
+    allow(@resource).to receive(:[]).with(:source).and_return("mysource")
+    allow(@resource).to receive(:[]).with(:ensure).and_return(:installed)
 
     @provider = subject()
-    @provider.stubs(:resource).returns @resource
+    allow(@provider).to receive(:resource).and_return(@resource)
   end
 
   it "should have an install method" do
@@ -34,14 +34,14 @@ describe Puppet::Type.type(:package).provider(:hpux) do
 
   context "when installing" do
     it "should use a command-line like 'swinstall -x mount_all_filesystems=false -s SOURCE PACKAGE-NAME'" do
-      @provider.expects(:swinstall).with('-x', 'mount_all_filesystems=false', '-s', 'mysource', 'mypackage')
+      expect(@provider).to receive(:swinstall).with('-x', 'mount_all_filesystems=false', '-s', 'mysource', 'mypackage')
       @provider.install
     end
   end
 
   context "when uninstalling" do
     it "should use a command-line like 'swremove -x mount_all_filesystems=false PACKAGE-NAME'" do
-      @provider.expects(:swremove).with('-x', 'mount_all_filesystems=false', 'mypackage')
+      expect(@provider).to receive(:swremove).with('-x', 'mount_all_filesystems=false', 'mypackage')
       @provider.uninstall
     end
   end

data/spec/unit/provider/package/macports_spec.rb

@@ -11,7 +11,7 @@ describe Puppet::Type.type(:package).provider(:macports) do
 
   let :provider do
     prov = resource.provider
-    prov.expects(:execute).never
+    expect(prov).not_to receive(:execute)
     prov
   end
 
@@ -30,17 +30,17 @@ describe Puppet::Type.type(:package).provider(:macports) do
 
   context "when listing all instances" do
     it "should call port -q installed" do
-      described_class.expects(:port).with("-q", :installed).returns("")
+      expect(described_class).to receive(:port).with("-q", :installed).and_return("")
       described_class.instances
     end
 
     it "should create instances from active ports" do
-      described_class.expects(:port).returns("foo @1.234.5_2 (active)")
+      expect(described_class).to receive(:port).and_return("foo @1.234.5_2 (active)")
       expect(described_class.instances.size).to eq(1)
     end
 
     it "should ignore ports that aren't activated" do
-      described_class.expects(:port).returns("foo @1.234.5_2")
+      expect(described_class).to receive(:port).and_return("foo @1.234.5_2")
       expect(described_class.instances.size).to eq(0)
     end
 
@@ -52,68 +52,72 @@ describe Puppet::Type.type(:package).provider(:macports) do
   end
 
   context "when installing" do
-   it "should not specify a version when ensure is set to latest" do
-     resource[:ensure] = :latest
-     provider.expects(:port).with { |flag, method, name, version|
-       expect(version).to be_nil
-     }
-     provider.install
-   end
-
-   it "should not specify a version when ensure is set to present" do
-     resource[:ensure] = :present
-     provider.expects(:port).with { |flag, method, name, version|
-       expect(version).to be_nil
-     }
-     provider.install
-   end
-
-   it "should specify a version when ensure is set to a version" do
-     resource[:ensure] = "1.2.3"
-     provider.expects(:port).with { |flag, method, name, version|
-       expect(version).to be
-     }
-     provider.install
-   end
+    it "should not specify a version when ensure is set to latest" do
+      resource[:ensure] = :latest
+      # version would be the 4th argument, if provided.
+      expect(provider).to receive(:port).with(anything, anything, anything)
+
+      provider.install
+    end
+
+    it "should not specify a version when ensure is set to present" do
+      resource[:ensure] = :present
+      # version would be the 4th argument, if provided.
+      expect(provider).to receive(:port).with(anything, anything, anything)
+
+      provider.install
+    end
+
+    it "should specify a version when ensure is set to a version" do
+      resource[:ensure] = "1.2.3"
+      expect(provider).to receive(:port).with(anything, anything, anything, '@1.2.3')
+
+      provider.install
+    end
   end
 
   context "when querying for the latest version" do
-    let :new_info_line do
+    # Redefine provider to avoid the "expect(prov).not_to receive(:execute)"
+    # that was set in the original definition.
+    let(:provider) { resource.provider }
+    let(:new_info_line) do
       "1.2.3 2"
     end
-    let :infoargs do
+    let(:infoargs) do
       ["/opt/local/bin/port", "-q", :info, "--line", "--version", "--revision",  resource_name]
     end
-    let(:arguments) do {:failonfail => false, :combine => false} end
+    let(:arguments) do
+      {:failonfail => false, :combine => false}
+    end
 
     before :each do
-      provider.stubs(:command).with(:port).returns("/opt/local/bin/port")
+      allow(provider).to receive(:command).with(:port).and_return("/opt/local/bin/port")
     end
 
     it "should return nil when the package cannot be found" do
       resource[:name] = resource_name
-      provider.expects(:execute).with(infoargs, arguments).returns("")
+      expect(provider).to receive(:execute).with(infoargs, arguments).and_return("")
       expect(provider.latest).to eq(nil)
     end
 
     it "should return the current version if the installed port has the same revision" do
       current_hash[:revision] = "2"
-      provider.expects(:execute).with(infoargs, arguments).returns(new_info_line)
-      provider.expects(:query).returns(current_hash)
+      expect(provider).to receive(:execute).with(infoargs, arguments).and_return(new_info_line)
+      expect(provider).to receive(:query).and_return(current_hash)
       expect(provider.latest).to eq(current_hash[:ensure])
     end
 
     it "should return the new version_revision if the installed port has a lower revision" do
       current_hash[:revision] = "1"
-      provider.expects(:execute).with(infoargs, arguments).returns(new_info_line)
-      provider.expects(:query).returns(current_hash)
+      expect(provider).to receive(:execute).with(infoargs, arguments).and_return(new_info_line)
+      expect(provider).to receive(:query).and_return(current_hash)
       expect(provider.latest).to eq("1.2.3_2")
     end
 
     it "should return the newest version if the port is not installed" do
       resource[:name] = resource_name
-      provider.expects(:execute).with(infoargs, arguments).returns(new_info_line)
-      provider.expects(:execute).with(["/opt/local/bin/port", "-q", :installed, resource[:name]], arguments).returns("")
+      expect(provider).to receive(:execute).with(infoargs, arguments).and_return(new_info_line)
+      expect(provider).to receive(:execute).with(["/opt/local/bin/port", "-q", :installed, resource[:name]], arguments).and_return("")
       expect(provider.latest).to eq("1.2.3_2")
     end
   end
@@ -122,16 +126,16 @@ describe Puppet::Type.type(:package).provider(:macports) do
     it "should execute port install if the port is installed" do
       resource[:name] = resource_name
       resource[:ensure] = :present
-      provider.stubs(:query).returns(current_hash)
-      provider.expects(:port).with("-q", :install, resource_name)
+      allow(provider).to receive(:query).and_return(current_hash)
+      expect(provider).to receive(:port).with("-q", :install, resource_name)
       provider.update
     end
 
     it "should execute port install if the port is not installed" do
       resource[:name] = resource_name
       resource[:ensure] = :present
-      provider.stubs(:query).returns("")
-      provider.expects(:port).with("-q", :install, resource_name)
+      allow(provider).to receive(:query).and_return("")
+      expect(provider).to receive(:port).with("-q", :install, resource_name)
       provider.update
     end
   end