puppet 5.5.22-universal-darwin → 6.0.0-universal-darwin

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:package).provider(:sun) do
@@ -21,14 +22,14 @@ describe Puppet::Type.type(:package).provider(:sun) do
     it "should install a package" do
       resource[:ensure] = :installed
       resource[:source] = '/cdrom'
-      expect(provider).to receive(:pkgadd).with(['-d', '/cdrom', '-n', 'dummy'])
+      provider.expects(:pkgadd).with(['-d', '/cdrom', '-n', 'dummy'])
       provider.install
     end
 
     it "should install a package if it is not present on update" do
-      expect(provider).to receive(:pkginfo).with('-l', 'dummy').and_return(File.read(my_fixture('dummy.server')))
-      expect(provider).to receive(:pkgrm).with(['-n', 'dummy'])
-      expect(provider).to receive(:install)
+      provider.expects(:pkginfo).with('-l', 'dummy').returns File.read(my_fixture('dummy.server'))
+      provider.expects(:pkgrm).with(['-n', 'dummy'])
+      provider.expects(:install)
       provider.update
     end
 
@@ -36,36 +37,36 @@ describe Puppet::Type.type(:package).provider(:sun) do
       resource[:ensure] = :installed
       resource[:source] = '/cdrom'
       resource[:install_options] = '-G'
-      expect(provider).to receive(:pkgadd).with(['-d', '/cdrom', '-G', '-n', 'dummy'])
+      provider.expects(:pkgadd).with(['-d', '/cdrom', '-G', '-n', 'dummy'])
       provider.install
     end
   end
 
   context '#uninstall' do
     it "should uninstall a package" do
-      expect(provider).to receive(:pkgrm).with(['-n','dummy'])
+      provider.expects(:pkgrm).with(['-n','dummy'])
       provider.uninstall
     end
   end
 
   context '#update' do
     it "should call uninstall if not :absent on info2hash" do
-      allow(provider).to receive(:info2hash).and_return({:name => 'SUNWdummy', :ensure => "11.11.0,REV=2010.10.12.04.23"})
-      expect(provider).to receive(:uninstall)
-      expect(provider).to receive(:install)
+      provider.stubs(:info2hash).returns({:name => 'SUNWdummy', :ensure => "11.11.0,REV=2010.10.12.04.23"})
+      provider.expects(:uninstall)
+      provider.expects(:install)
       provider.update
     end
 
     it "should not call uninstall if :absent on info2hash" do
-      allow(provider).to receive(:info2hash).and_return({:name => 'SUNWdummy', :ensure => :absent})
-      expect(provider).to receive(:install)
+      provider.stubs(:info2hash).returns({:name => 'SUNWdummy', :ensure => :absent})
+      provider.expects(:install)
       provider.update
     end
   end
 
   context '#query' do
     it "should find the package on query" do
-      expect(provider).to receive(:pkginfo).with('-l', 'dummy').and_return(File.read(my_fixture('dummy.server')))
+      provider.expects(:pkginfo).with('-l', 'dummy').returns File.read(my_fixture('dummy.server'))
       expect(provider.query).to eq({
         :name     => 'SUNWdummy',
         :category=>"system",
@@ -78,19 +79,19 @@ describe Puppet::Type.type(:package).provider(:sun) do
     end
 
     it "shouldn't find the package on query if it is not present" do
-      expect(provider).to receive(:pkginfo).with('-l', 'dummy').and_raise(Puppet::ExecutionFailure, "Execution of 'pkginfo -l dummy' returned 3: ERROR: information for \"dummy\" not found.")
+      provider.expects(:pkginfo).with('-l', 'dummy').raises Puppet::ExecutionFailure, "Execution of 'pkginfo -l dummy' returned 3: ERROR: information for \"dummy\" not found."
       expect(provider.query).to eq({:ensure => :absent})
     end
 
     it "unknown message should raise error." do
-      expect(provider).to receive(:pkginfo).with('-l', 'dummy').and_return('RANDOM')
+      provider.expects(:pkginfo).with('-l', 'dummy').returns 'RANDOM'
       expect { provider.query }.to raise_error Puppet::Error
     end
   end
 
   context '#instance' do
     it "should list instances when there are packages in the system" do
-      expect(described_class).to receive(:pkginfo).with('-l').and_return(File.read(my_fixture('simple')))
+      described_class.expects(:pkginfo).with('-l').returns File.read(my_fixture('simple'))
       instances = provider.class.instances.map { |p| {:name => p.get(:name), :ensure => p.get(:ensure)} }
       expect(instances.size).to eq(2)
       expect(instances[0]).to eq({
@@ -104,9 +105,10 @@ describe Puppet::Type.type(:package).provider(:sun) do
     end
 
     it "should return empty if there were no packages" do
-      expect(described_class).to receive(:pkginfo).with('-l').and_return('')
+      described_class.expects(:pkginfo).with('-l').returns ''
       instances = provider.class.instances
       expect(instances.size).to eq(0)
     end
+
   end
 end

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

@@ -2,14 +2,17 @@ require 'spec_helper'
 
 # Note that much of the functionality of the tdnf provider is already tested with yum provider tests,
 # as yum is the parent provider, via dnf
-describe Puppet::Type.type(:package).provider(:tdnf) do
-  it_behaves_like 'RHEL package provider', described_class, 'tdnf'
-
-  context 'default' do
-    it 'should be the default provider on PhotonOS' do
-      allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return("PhotonOS")
-      expect(described_class).to be_default
-    end
+
+provider_class = Puppet::Type.type(:package).provider(:tdnf)
+
+context 'default' do
+  it 'should be the default provider on PhotonOS' do
+    Facter.stubs(:value).with(:osfamily).returns(:redhat)
+    Facter.stubs(:value).with(:operatingsystem).returns("PhotonOS")
+    expect(provider_class).to be_default
   end
 end
+
+describe provider_class do
+  it_behaves_like 'RHEL package provider', provider_class, 'tdnf'
+end

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

@@ -1,6 +1,8 @@
+# spec/unit/provider/package/up2date_spec.rb
 require 'spec_helper'
 
 describe 'up2date package provider' do
+
   # This sets the class itself as the subject rather than
   # an instance of the class.
   subject do
@@ -13,8 +15,8 @@ describe 'up2date package provider' do
   osfamilies.each do |osfamily|
     releases.each do |release|
       it "should be the default provider on #{osfamily} #{release}" do
-        allow(Facter).to receive(:value).with(:osfamily).and_return(osfamily)
-        allow(Facter).to receive(:value).with(:lsbdistrelease).and_return(release)
+        Facter.expects(:value).with(:osfamily).returns(osfamily)
+        Facter.expects(:value).with(:lsbdistrelease).returns(release)
         expect(subject.default?).to be_truthy
       end
     end

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

@@ -1,13 +1,15 @@
 require 'spec_helper'
 
 describe Puppet::Type.type(:package).provider(:urpmi) do
+
   before do
+    Puppet::Util::Execution.expects(:execute).never
     %w[rpm urpmi urpme urpmq].each do |executable|
-      allow(Puppet::Util).to receive(:which).with(executable).and_return(executable)
+      Puppet::Util.stubs(:which).with(executable).returns(executable)
     end
-    allow(Puppet::Util::Execution).to receive(:execute)
+    Puppet::Util::Execution.stubs(:execute)
       .with(['rpm', '--version'], anything)
-      .and_return(Puppet::Util::Execution::ProcessOutput.new('RPM version 4.9.1.3', 0))
+      .returns(Puppet::Util::Execution::ProcessOutput.new('RPM version 4.9.1.3', 0))
   end
 
   let(:resource) do
@@ -16,18 +18,18 @@ describe Puppet::Type.type(:package).provider(:urpmi) do
 
   before do
     subject.resource = resource
-    allow(Puppet::Type.type(:package)).to receive(:defaultprovider).and_return(described_class)
+    Puppet::Type.type(:package).stubs(:defaultprovider).returns described_class
   end
 
   describe '#install' do
     before do
-      allow(subject).to receive(:rpm).with('-q', 'foopkg', any_args).and_return("foopkg 0 1.2.3.4 5 noarch :DESC:\n")
+      subject.stubs(:rpm).with('-q', 'foopkg', any_parameters).returns "foopkg 0 1.2.3.4 5 noarch :DESC:\n"
     end
 
     describe 'without a version' do
       it 'installs the unversioned package' do
         resource[:ensure] = :present
-        expect(Puppet::Util::Execution).to receive(:execute).with(['urpmi', '--auto', 'foopkg'], anything)
+        Puppet::Util::Execution.expects(:execute).with(['urpmi', '--auto', 'foopkg'], anything)
         subject.install
       end
     end
@@ -35,15 +37,15 @@ describe Puppet::Type.type(:package).provider(:urpmi) do
     describe 'with a version' do
       it 'installs the versioned package' do
         resource[:ensure] = '4.5.6'
-        expect(Puppet::Util::Execution).to receive(:execute).with(['urpmi', '--auto', 'foopkg-4.5.6'], anything)
+        Puppet::Util::Execution.expects(:execute).with(['urpmi', '--auto', 'foopkg-4.5.6'], anything)
         subject.install
       end
     end
 
     describe "and the package install fails" do
       it "raises an error" do
-        allow(Puppet::Util::Execution).to receive(:execute).with(['urpmi', '--auto', 'foopkg'], anything)
-        allow(subject).to receive(:query)
+        Puppet::Util::Execution.stubs(:execute).with(['urpmi', '--auto', 'foopkg'], anything)
+        subject.stubs(:query)
         expect { subject.install }.to raise_error Puppet::Error, /Package \S+ was not present after trying to install it/
       end
     end
@@ -53,31 +55,31 @@ describe Puppet::Type.type(:package).provider(:urpmi) do
     let(:urpmq_output) { 'foopkg : Lorem ipsum dolor sit amet, consectetur adipisicing elit ( 7.8.9-1.mga2 )' }
 
     it "uses urpmq to determine the latest package" do
-      expect(Puppet::Util::Execution).to receive(:execute)
+      Puppet::Util::Execution.expects(:execute)
         .with(['urpmq', '-S', 'foopkg'], anything)
-        .and_return(Puppet::Util::Execution::ProcessOutput.new(urpmq_output, 0))
+        .returns(Puppet::Util::Execution::ProcessOutput.new(urpmq_output, 0))
       expect(subject.latest).to eq('7.8.9-1.mga2')
     end
 
     it "falls back to the current version" do
       resource[:ensure] = '5.4.3'
-      expect(Puppet::Util::Execution).to receive(:execute)
+      Puppet::Util::Execution.expects(:execute)
         .with(['urpmq', '-S', 'foopkg'], anything)
-        .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+        .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
       expect(subject.latest).to eq('5.4.3')
     end
   end
 
   describe '#update' do
     it 'delegates to #install' do
-      expect(subject).to receive(:install)
+      subject.expects(:install)
       subject.update
     end
   end
 
   describe '#purge' do
     it 'uses urpme to purge packages' do
-      expect(Puppet::Util::Execution).to receive(:execute).with(['urpme', '--auto', 'foopkg'], anything)
+      Puppet::Util::Execution.expects(:execute).with(['urpme', '--auto', 'foopkg'], anything)
       subject.purge
     end
   end

data/spec/unit/provider/package/windows/exe_package_spec.rb

@@ -1,7 +1,10 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/provider/package/windows/exe_package'
 
 describe Puppet::Provider::Package::Windows::ExePackage do
+  subject { described_class }
+
   let (:name)        { 'Git version 1.7.11' }
   let (:version)     { '1.7.11' }
   let (:source)      { 'E:\Git-1.7.11.exe' }
@@ -9,18 +12,18 @@ describe Puppet::Provider::Package::Windows::ExePackage do
 
   context '::from_registry' do
     it 'should return an instance of ExePackage' do
-      expect(described_class).to receive(:valid?).and_return(true)
+      subject.expects(:valid?).returns(true)
 
-      pkg = described_class.from_registry('', {'DisplayName' => name, 'DisplayVersion' => version, 'UninstallString' => uninstall})
+      pkg = subject.from_registry('', {'DisplayName' => name, 'DisplayVersion' => version, 'UninstallString' => uninstall})
       expect(pkg.name).to eq(name)
       expect(pkg.version).to eq(version)
       expect(pkg.uninstall_string).to eq(uninstall)
     end
 
     it 'should return nil if it is not a valid executable' do
-      expect(described_class).to receive(:valid?).and_return(false)
+      subject.expects(:valid?).returns(false)
 
-      expect(described_class.from_registry('', {})).to be_nil
+      expect(subject.from_registry('', {})).to be_nil
     end
   end
 
@@ -39,26 +42,26 @@ describe Puppet::Provider::Package::Windows::ExePackage do
     }.each_pair do |k, arr|
       it "should accept '#{k}' with value '#{arr[0]}'" do
         values[k] = arr[0]
-        expect(described_class.valid?(name, values)).to be_truthy
+        expect(subject.valid?(name, values)).to be_truthy
       end
 
       it "should reject '#{k}' with value '#{arr[1]}'" do
         values[k] = arr[1]
-        expect(described_class.valid?(name, values)).to be_falsey
+        expect(subject.valid?(name, values)).to be_falsey
       end
     end
 
     it 'should reject packages whose name starts with "KBXXXXXX"' do
-      expect(described_class.valid?('KB890830', values)).to be_falsey
+      expect(subject.valid?('KB890830', values)).to be_falsey
     end
 
     it 'should accept packages whose name does not start with "KBXXXXXX"' do
-      expect(described_class.valid?('My Update (KB890830)', values)).to be_truthy
+      expect(subject.valid?('My Update (KB890830)', values)).to be_truthy
     end
   end
 
   context '#match?' do
-    let(:pkg) { described_class.new(name, version, uninstall) }
+    let(:pkg) { subject.new(name, version, uninstall) }
 
     it 'should match product name' do
       expect(pkg.match?({:name => name})).to be_truthy
@@ -71,25 +74,25 @@ describe Puppet::Provider::Package::Windows::ExePackage do
 
   context '#install_command' do
     it 'should install using the source' do
-      cmd = described_class.install_command({:source => source})
+      cmd = subject.install_command({:source => source})
 
-      expect(cmd).to eq(source)
+      expect(cmd).to eq(['cmd.exe', '/c', 'start', '"puppet-install"', '/w', source])
     end
   end
 
   context '#uninstall_command' do
     ['C:\uninstall.exe', 'C:\Program Files\uninstall.exe'].each do |exe|
       it "should quote #{exe}" do
-        expect(described_class.new(name, version, exe).uninstall_command).to eq(
-          "\"#{exe}\""
+        expect(subject.new(name, version, exe).uninstall_command).to eq(
+          ['cmd.exe', '/c', 'start', '"puppet-uninstall"', '/w', "\"#{exe}\""]
         )
       end
     end
 
     ['"C:\Program Files\uninstall.exe"', '"C:\Program Files (x86)\Git\unins000.exe" /SILENT"'].each do |exe|
       it "should not quote #{exe}" do
-        expect(described_class.new(name, version, exe).uninstall_command).to eq(
-          exe
+        expect(subject.new(name, version, exe).uninstall_command).to eq(
+          ['cmd.exe', '/c', 'start', '"puppet-uninstall"', '/w', exe]
         )
       end
     end

data/spec/unit/provider/package/windows/msi_package_spec.rb

@@ -1,7 +1,10 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/provider/package/windows/msi_package'
 
 describe Puppet::Provider::Package::Windows::MsiPackage do
+  subject { described_class }
+
   let (:name)        { 'mysql-5.1.58-win-x64' }
   let (:version)     { '5.1.58' }
   let (:source)      { 'E:\mysql-5.1.58-win-x64.msi' }
@@ -9,24 +12,24 @@ describe Puppet::Provider::Package::Windows::MsiPackage do
   let (:packagecode) { '{5A6FD560-763A-4BC1-9E03-B18DFFB7C72C}' }
 
   def expect_installer
-    inst = double()
-    expect(inst).to receive(:ProductState).and_return(5)
-    expect(inst).to receive(:ProductInfo).with(productcode, 'PackageCode').and_return(packagecode)
-    expect(described_class).to receive(:installer).and_return(inst)
+    inst = mock
+    inst.expects(:ProductState).returns(5)
+    inst.expects(:ProductInfo).with(productcode, 'PackageCode').returns(packagecode)
+    subject.expects(:installer).returns(inst)
   end
 
-  context '::installer', :if => Puppet.features.microsoft_windows? do
+  context '::installer', :if => Puppet::Util::Platform.windows? do
     it 'should return an instance of the COM interface' do
-      expect(described_class.installer).not_to be_nil
+      expect(subject.installer).not_to be_nil
     end
   end
 
   context '::from_registry' do
     it 'should return an instance of MsiPackage' do
-      expect(described_class).to receive(:valid?).and_return(true)
+      subject.expects(:valid?).returns(true)
       expect_installer
 
-      pkg = described_class.from_registry(productcode, {'DisplayName' => name, 'DisplayVersion' => version})
+      pkg = subject.from_registry(productcode, {'DisplayName' => name, 'DisplayVersion' => version})
       expect(pkg.name).to eq(name)
       expect(pkg.version).to eq(version)
       expect(pkg.productcode).to eq(productcode)
@@ -34,9 +37,9 @@ describe Puppet::Provider::Package::Windows::MsiPackage do
     end
 
     it 'should return nil if it is not a valid MSI' do
-      expect(described_class).to receive(:valid?).and_return(false)
+      subject.expects(:valid?).returns(false)
 
-      expect(described_class.from_registry(productcode, {})).to be_nil
+      expect(subject.from_registry(productcode, {})).to be_nil
     end
   end
 
@@ -49,45 +52,45 @@ describe Puppet::Provider::Package::Windows::MsiPackage do
     }.each_pair do |k, arr|
       it "should accept '#{k}' with value '#{arr[0]}'" do
         values[k] = arr[0]
-        expect(described_class.valid?(productcode, values)).to be_truthy
+        expect(subject.valid?(productcode, values)).to be_truthy
       end
 
       it "should reject '#{k}' with value '#{arr[1]}'" do
         values[k] = arr[1]
-        expect(described_class.valid?(productcode, values)).to be_falsey
+        expect(subject.valid?(productcode, values)).to be_falsey
       end
     end
 
     it 'should reject packages whose name is not a productcode' do
-     expect(described_class.valid?('AddressBook', values)).to be_falsey
+     expect(subject.valid?('AddressBook', values)).to be_falsey
    end
 
    it 'should accept packages whose name is a productcode' do
-     expect(described_class.valid?(productcode, values)).to be_truthy
+     expect(subject.valid?(productcode, values)).to be_truthy
    end
   end
 
   context '#match?' do
     it 'should match package codes case-insensitively' do
-      pkg = described_class.new(name, version, productcode, packagecode.upcase)
+      pkg = subject.new(name, version, productcode, packagecode.upcase)
 
       expect(pkg.match?({:name => packagecode.downcase})).to be_truthy
     end
 
     it 'should match product codes case-insensitively' do
-      pkg = described_class.new(name, version, productcode.upcase, packagecode)
+      pkg = subject.new(name, version, productcode.upcase, packagecode)
 
       expect(pkg.match?({:name => productcode.downcase})).to be_truthy
     end
 
     it 'should match product name' do
-      pkg = described_class.new(name, version, productcode, packagecode)
+      pkg = subject.new(name, version, productcode, packagecode)
 
       expect(pkg.match?({:name => name})).to be_truthy
     end
 
     it 'should return false otherwise' do
-      pkg = described_class.new(name, version, productcode, packagecode)
+      pkg = subject.new(name, version, productcode, packagecode)
 
       expect(pkg.match?({:name => 'not going to find it'})).to be_falsey
     end
@@ -95,7 +98,7 @@ describe Puppet::Provider::Package::Windows::MsiPackage do
 
   context '#install_command' do
     it 'should install using the source' do
-      cmd = described_class.install_command({:source => source})
+      cmd = subject.install_command({:source => source})
 
       expect(cmd).to eq(['msiexec.exe', '/qn', '/norestart', '/i', source])
     end
@@ -103,7 +106,7 @@ describe Puppet::Provider::Package::Windows::MsiPackage do
 
   context '#uninstall_command' do
     it 'should uninstall using the productcode' do
-      pkg = described_class.new(name, version, productcode, packagecode)
+      pkg = subject.new(name, version, productcode, packagecode)
 
       expect(pkg.uninstall_command).to eq(['msiexec.exe', '/qn', '/norestart', '/x', productcode])
     end