puppet 5.5.22-x64-mingw32 → 6.0.0-x64-mingw32

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

@@ -4,15 +4,15 @@ require 'puppet/provider/package'
 describe Puppet::Provider::Package do
   it 'returns absent for uninstalled packages when not purgeable' do
     provider = Puppet::Provider::Package.new
-    expect(provider).to receive(:query).and_return(nil)
-    expect(provider.class).to receive(:feature?).with(:purgeable).and_return(false)
+    provider.expects(:query).returns nil
+    provider.class.expects(:feature?).with(:purgeable).returns false
     expect(provider.properties[:ensure]).to eq(:absent)
   end
 
   it 'returns purged for uninstalled packages when purgeable' do
     provider = Puppet::Provider::Package.new
-    expect(provider).to receive(:query).and_return(nil)
-    expect(provider.class).to receive(:feature?).with(:purgeable).and_return(true)
+    provider.expects(:query).returns nil
+    provider.class.expects(:feature?).with(:purgeable).returns true
     expect(provider.properties[:ensure]).to eq(:purged)
   end
 end

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

@@ -2,47 +2,36 @@ require 'spec_helper'
 
 # Note that much of the functionality of the dnf provider is already tested with yum provider tests,
 # as yum is the parent provider.
-describe Puppet::Type.type(:package).provider(:dnf) do
-  context 'default' do
-    (19..21).each do |ver|
-      it "should not be the default provider on fedora#{ver}" do
-        allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-        allow(Facter).to receive(:value).with(:operatingsystem).and_return(:fedora)
-        allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("#{ver}")
-        expect(described_class).to_not be_default
-      end
-    end
 
-    (22..26).each do |ver|
-      it "should be the default provider on fedora#{ver}" do
-        allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-        allow(Facter).to receive(:value).with(:operatingsystem).and_return(:fedora)
-        allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("#{ver}")
-        expect(described_class).to be_default
-      end
-    end
+provider_class = Puppet::Type.type(:package).provider(:dnf)
 
-    it "should not be the default provider on rhel7" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("7")
-      expect(described_class).to_not be_default
+context 'default' do
+  (19..21).each do |ver|
+    it "should not be the default provider on fedora#{ver}" do
+      Facter.stubs(:value).with(:osfamily).returns(:redhat)
+      Facter.stubs(:value).with(:operatingsystem).returns(:fedora)
+      Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
+      expect(provider_class).to_not be_default
     end
+  end
 
-    it "should be the default provider on rhel8" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("8")
-      expect(described_class).to be_default
+  (22..26).each do |ver|
+    it "should be the default provider on fedora#{ver}" do
+      Facter.stubs(:value).with(:osfamily).returns(:redhat)
+      Facter.stubs(:value).with(:operatingsystem).returns(:fedora)
+      Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
+      expect(provider_class).to be_default
     end
   end
 
-  describe 'provider features' do
-    it { is_expected.to be_versionable }
-    it { is_expected.to be_install_options }
-    it { is_expected.to be_virtual_packages }
-    it { is_expected.to be_install_only }
+  it "should be the default provider on some random future fedora" do
+    Facter.stubs(:value).with(:osfamily).returns(:redhat)
+    Facter.stubs(:value).with(:operatingsystem).returns(:fedora)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("8675")
+    expect(provider_class).to be_default
   end
+end
 
-  it_behaves_like 'RHEL package provider', described_class, 'dnf'
+describe provider_class do
+  it_behaves_like 'RHEL package provider', provider_class, 'dnf'
 end

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

@@ -1,7 +1,10 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'stringio'
 
-describe Puppet::Type.type(:package).provider(:dpkg) do
+provider_class = Puppet::Type.type(:package).provider(:dpkg)
+
+describe provider_class do
   let(:bash_version) { '4.2-5ubuntu3' }
   let(:bash_installed_output) { "install ok installed bash #{bash_version}\n" }
   let(:bash_installed_io) { StringIO.new(bash_installed_output) }
@@ -12,52 +15,52 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
     {:failonfail => true, :combine => true, :custom_environment => {}}
   end
   let(:resource_name) { 'package' }
-  let(:resource) { double('resource', :[] => resource_name) }
-  let(:provider) { described_class.new(resource) }
+  let(:resource) { stub 'resource', :[] => resource_name }
+  let(:provider) { provider_class.new(resource) }
 
   it "has documentation" do
-    expect(described_class.doc).to be_instance_of(String)
+    expect(provider_class.doc).to be_instance_of(String)
   end
 
-  context "when listing all instances" do
+  describe "when listing all instances" do
     let(:execpipe_args) { args.unshift('myquery') }
 
     before do
-      allow(described_class).to receive(:command).with(:dpkgquery).and_return('myquery')
+      provider_class.stubs(:command).with(:dpkgquery).returns 'myquery'
     end
 
     it "creates and return an instance for a single dpkg-query entry" do
-      expect(Puppet::Util::Execution).to receive(:execpipe).with(execpipe_args).and_yield(bash_installed_io)
+      Puppet::Util::Execution.expects(:execpipe).with(execpipe_args).yields bash_installed_io
 
-      installed = double('bash')
-      expect(described_class).to receive(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg).and_return(installed)
+      installed = mock 'bash'
+      provider_class.expects(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg).returns installed
 
-      expect(described_class.instances).to eq([installed])
+      expect(provider_class.instances).to eq([installed])
     end
 
     it "parses multiple dpkg-query multi-line entries in the output" do
-      expect(Puppet::Util::Execution).to receive(:execpipe).with(execpipe_args).and_yield(all_installed_io)
+      Puppet::Util::Execution.expects(:execpipe).with(execpipe_args).yields all_installed_io
 
-      bash = double('bash')
-      expect(described_class).to receive(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg).and_return(bash)
-      vim = double('vim')
-      expect(described_class).to receive(:new).with(:ensure => "2:7.3.547-6ubuntu5", :error => "ok", :desired => "install", :name => "vim", :status => "installed", :provider => :dpkg).and_return(vim)
+      bash = mock 'bash'
+      provider_class.expects(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg).returns bash
+      vim = mock 'vim'
+      provider_class.expects(:new).with(:ensure => "2:7.3.547-6ubuntu5", :error => "ok", :desired => "install", :name => "vim", :status => "installed", :provider => :dpkg).returns vim
 
-      expect(described_class.instances).to eq([bash, vim])
+      expect(provider_class.instances).to eq([bash, vim])
     end
 
     it "continues without failing if it encounters bad lines between good entries" do
-      expect(Puppet::Util::Execution).to receive(:execpipe).with(execpipe_args).and_yield(StringIO.new([bash_installed_output, "foobar\n", vim_installed_output].join))
+      Puppet::Util::Execution.expects(:execpipe).with(execpipe_args).yields StringIO.new([bash_installed_output, "foobar\n", vim_installed_output].join)
 
-      bash = double('bash')
-      vim = double('vim')
-      expect(described_class).to receive(:new).twice.and_return(bash, vim)
+      bash = mock 'bash'
+      vim = mock 'vim'
+      provider_class.expects(:new).twice.returns(bash, vim)
 
-      expect(described_class.instances).to eq([bash, vim])
+      expect(provider_class.instances).to eq([bash, vim])
     end
   end
 
-  context "when querying the current state" do
+  describe "when querying the current state" do
     let(:dpkgquery_path) { '/bin/dpkg-query' }
     let(:query_args) do
       args.unshift(dpkgquery_path)
@@ -65,15 +68,15 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
     end
 
     def dpkg_query_execution_returns(output)
-      expect(Puppet::Util::Execution).to receive(:execute).with(query_args, execute_options).and_return(Puppet::Util::Execution::ProcessOutput.new(output, 0))
+      Puppet::Util::Execution.expects(:execute).with(query_args, execute_options).returns(Puppet::Util::Execution::ProcessOutput.new(output, 0))
     end
 
     before do
-      allow(Puppet::Util).to receive(:which).with('/usr/bin/dpkg-query').and_return(dpkgquery_path)
+      Puppet::Util.stubs(:which).with('/usr/bin/dpkg-query').returns(dpkgquery_path)
     end
 
     it "considers the package purged if dpkg-query fails" do
-      allow(Puppet::Util::Execution).to receive(:execute).with(query_args, execute_options).and_raise(Puppet::ExecutionFailure.new("eh"))
+      Puppet::Util::Execution.expects(:execute).with(query_args, execute_options).raises Puppet::ExecutionFailure.new("eh")
 
       expect(provider.query[:ensure]).to eq(:purged)
     end
@@ -126,13 +129,10 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
 
     it "considers the package held if its state is 'hold'" do
       dpkg_query_execution_returns(bash_installed_output.gsub("install","hold"))
-      query=provider.query
-      expect(query[:ensure]).to eq("4.2-5ubuntu3")
-      expect(query[:mark]).to eq(:hold)
-
+      expect(provider.query[:ensure]).to eq(:held)
     end
 
-    context "parsing tests" do
+    describe "parsing tests" do
       let(:resource_name) { 'name' }
       let(:package_hash) do
         {
@@ -150,8 +150,8 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
 
       def parser_test(dpkg_output_string, gold_hash, number_of_debug_logs = 0)
         dpkg_query_execution_returns(dpkg_output_string)
-        expect(Puppet).not_to receive(:warning)
-        expect(Puppet).to receive(:debug).exactly(number_of_debug_logs).times
+        Puppet.expects(:warning).never
+        Puppet.expects(:debug).times(number_of_debug_logs)
 
         expect(provider.query).to eq(gold_hash)
       end
@@ -166,158 +166,116 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
       end
 
       it "does not log if execution returns with non-zero exit code" do
-        expect(Puppet::Util::Execution).to receive(:execute).with(query_args, execute_options).and_raise(Puppet::ExecutionFailure.new("failed"))
-        expect(Puppet).not_to receive(:debug)
+        Puppet::Util::Execution.expects(:execute).with(query_args, execute_options).raises Puppet::ExecutionFailure.new("failed")
+        Puppet::expects(:debug).never
 
         expect(provider.query).to eq(package_not_found_hash)
       end
     end
   end
 
-  context "when installing" do
+  describe "when installing" do
     before do
-      allow(resource).to receive(:[]).with(:source).and_return("mypkg")
+      resource.stubs(:[]).with(:source).returns "mypkg"
     end
 
     it "fails to install if no source is specified in the resource" do
-      expect(resource).to receive(:[]).with(:source).and_return(nil)
+      resource.expects(:[]).with(:source).returns nil
 
       expect { provider.install }.to raise_error(ArgumentError)
     end
 
     it "uses 'dpkg -i' to install the package" do
-      expect(resource).to receive(:[]).with(:source).and_return("mypackagefile")
-      expect(provider).to receive(:properties).and_return({:mark => :hold})
-      expect(provider).to receive(:unhold)
-      expect(provider).to receive(:dpkg).with(any_args, "-i", "mypackagefile")
+      resource.expects(:[]).with(:source).returns "mypackagefile"
+      provider.expects(:unhold)
+      provider.expects(:dpkg).with { |*command| command[-1] == "mypackagefile"  and command[-2] == "-i" }
+
       provider.install
     end
 
     it "keeps old config files if told to do so" do
-      expect(resource).to receive(:[]).with(:configfiles).and_return(:keep)
-      expect(provider).to receive(:properties).and_return({:mark => :hold})
-      expect(provider).to receive(:unhold)
-      expect(provider).to receive(:dpkg).with("--force-confold", any_args)
+      resource.expects(:[]).with(:configfiles).returns :keep
+      provider.expects(:unhold)
+      provider.expects(:dpkg).with { |*command| command[0] == "--force-confold" }
 
       provider.install
     end
 
     it "replaces old config files if told to do so" do
-      expect(resource).to receive(:[]).with(:configfiles).and_return(:replace)
-      expect(provider).to receive(:properties).and_return({:mark => :hold})
-      expect(provider).to receive(:unhold)
-      expect(provider).to receive(:dpkg).with("--force-confnew", any_args)
+      resource.expects(:[]).with(:configfiles).returns :replace
+      provider.expects(:unhold)
+      provider.expects(:dpkg).with { |*command| command[0] == "--force-confnew" }
 
       provider.install
     end
 
     it "ensures any hold is removed" do
-      expect(provider).to receive(:properties).and_return({:mark => :hold})
-      expect(provider).to receive(:unhold).once
-      expect(provider).to receive(:dpkg)
+      provider.expects(:unhold).once
+      provider.expects(:dpkg)
       provider.install
     end
   end
 
-  context "when holding or unholding" do
-    let(:tempfile) { double('tempfile', :print => nil, :close => nil, :flush => nil, :path => "/other/file") }
+  describe "when holding or unholding" do
+    let(:tempfile) { stub 'tempfile', :print => nil, :close => nil, :flush => nil, :path => "/other/file" }
 
     before do
-      allow(tempfile).to receive(:write)
-      allow(Tempfile).to receive(:new).and_return(tempfile)
-    end
-
-    it "installs first if package is not present and ensure holding" do
-      allow(provider).to receive(:execute)
-      allow(provider).to receive(:package_not_installed?).and_return(true)
-      expect(provider).to receive(:install).once
-      expect(provider).to receive(:hold)
-      provider.deprecated_hold
+      tempfile.stubs(:write)
+      Tempfile.stubs(:open).yields tempfile
     end
 
-
-    it "skips install new package if hold is true" do
-      allow(provider).to receive(:execute)
-      allow(provider).to receive(:package_not_installed?).and_return(true)
-      expect(provider).to receive(:install).once
-      expect(provider).to receive(:hold)
-      provider.deprecated_hold
-    end
-
-    it "skips install new package if package is allready installed" do
-      allow(provider).to receive(:execute)
-      allow(provider).to receive(:package_not_installed?).and_return(false)
-      expect(provider).not_to receive(:install)
-      expect(provider).to receive(:hold)
-      provider.deprecated_hold
+    it "installs first if holding" do
+      provider.stubs(:execute)
+      provider.expects(:install).once
+      provider.hold
     end
 
     it "executes dpkg --set-selections when holding" do
-      allow(provider).to receive(:package_not_installed?).and_return(false)
-      allow(provider).to receive(:install)
-      expect(provider).to receive(:execute).with([:dpkg, '--set-selections'], {:failonfail => false, :combine => false, :stdinfile => tempfile.path}).once
+      provider.stubs(:install)
+      provider.expects(:execute).with([:dpkg, '--set-selections'], {:failonfail => false, :combine => false, :stdinfile => tempfile.path}).once
       provider.hold
     end
 
     it "executes dpkg --set-selections when unholding" do
-      allow(provider).to receive(:package_not_installed?).and_return(false)
-      allow(provider).to receive(:install)
-      expect(provider).to receive(:execute).with([:dpkg, '--set-selections'], {:failonfail => false, :combine => false, :stdinfile => tempfile.path}).once
+      provider.stubs(:install)
+      provider.expects(:execute).with([:dpkg, '--set-selections'], {:failonfail => false, :combine => false, :stdinfile => tempfile.path}).once
       provider.hold
     end
   end
 
   it "uses :install to update" do
-    expect(provider).to receive(:install)
+    provider.expects(:install)
     provider.update
   end
 
-  context "when determining latest available version" do
+  describe "when determining latest available version" do
     it "returns the version found by dpkg-deb" do
-      expect(resource).to receive(:[]).with(:source).and_return("myfile")
-      expect(provider).to receive(:dpkg_deb).with(any_args, "myfile").and_return("package\t1.0")
+      resource.expects(:[]).with(:source).returns "myfile"
+      provider.expects(:dpkg_deb).with { |*command| command[-1] == "myfile" }.returns "package\t1.0"
       expect(provider.latest).to eq("1.0")
     end
 
     it "warns if the package file contains a different package" do
-      expect(provider).to receive(:dpkg_deb).and_return("foo\tversion")
-      expect(provider).to receive(:warning)
+      provider.expects(:dpkg_deb).returns("foo\tversion")
+      provider.expects(:warning)
       provider.latest
     end
 
     it "copes with names containing ++" do
-      resource = double('resource', :[] => "package++")
-      provider = described_class.new(resource)
-      expect(provider).to receive(:dpkg_deb).and_return("package++\t1.0")
+      resource = stub 'resource', :[] => "package++"
+      provider = provider_class.new(resource)
+      provider.expects(:dpkg_deb).returns "package++\t1.0"
       expect(provider.latest).to eq("1.0")
     end
   end
 
   it "uses 'dpkg -r' to uninstall" do
-    expect(provider).to receive(:dpkg).with("-r", resource_name)
+    provider.expects(:dpkg).with("-r", resource_name)
     provider.uninstall
   end
 
   it "uses 'dpkg --purge' to purge" do
-    expect(provider).to receive(:dpkg).with("--purge", resource_name)
+    provider.expects(:dpkg).with("--purge", resource_name)
     provider.purge
   end
-
-  context "package_not_installed?" do
-    it "returns true if package is not found" do
-      expect(provider).to receive(:dpkgquery).with("-W", "--showformat", "'${Status} ${Package} ${Version}\\n'", resource_name).and_raise(Puppet::ExecutionFailure.new("eh"))
-      expect(provider.package_not_installed?).to eq(true)
-    end
-
-    it "returns true if package is not installed" do
-      expect(provider).to receive(:dpkgquery).with("-W", "--showformat", "'${Status} ${Package} ${Version}\\n'", resource_name).and_return("unknown ok not-installed #{resource_name}")
-      expect(provider.package_not_installed?).to eq(true)
-    end
-
-    it "returns false if package is installed" do
-      expect(provider).to receive(:dpkgquery).with("-W", "--showformat", "'${Status} ${Package} ${Version}\\n'", resource_name).and_return("install ok installed resource_name 1.2.3")
-      expect(provider.package_not_installed?).to eq(false)
-    end
-  end
 end
-

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

@@ -1,37 +1,40 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
-describe Puppet::Type.type(:package).provider(:freebsd) do
+provider_class = Puppet::Type.type(:package).provider(:freebsd)
+
+describe provider_class do
   before :each do
     # Create a mock resource
-    @resource = double('resource')
+    @resource = stub 'resource'
 
     # A catch all; no parameters set
-    allow(@resource).to receive(:[]).and_return(nil)
+    @resource.stubs(:[]).returns(nil)
 
     # But set name and source
-    allow(@resource).to receive(:[]).with(:name).and_return("mypackage")
-    allow(@resource).to receive(:[]).with(:ensure).and_return(:installed)
+    @resource.stubs(:[]).with(:name).returns   "mypackage"
+    @resource.stubs(:[]).with(:ensure).returns :installed
 
-    @provider = subject()
+    @provider = provider_class.new
     @provider.resource = @resource
   end
 
   it "should have an install method" do
-    @provider = subject()
+    @provider = provider_class.new
     expect(@provider).to respond_to(:install)
   end
 
-  context "when installing" do
+  describe "when installing" do
     before :each do
-      allow(@resource).to receive(:should).with(:ensure).and_return(:installed)
+      @resource.stubs(:should).with(:ensure).returns(: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/'
-      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")
+      @resource.stubs(:[]).with(:source).returns(path)
+      Puppet::Util.expects(:withenv).once.with({:PKG_PATH => path}).yields
+      @provider.expects(:pkgadd).once.with("mypackage")
 
       expect { @provider.install }.to_not raise_error
     end
@@ -40,9 +43,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/"
-        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")
+        @resource.stubs(:[]).with(:source).returns(path)
+        Puppet::Util.expects(:withenv).once.with({:PACKAGESITE => path}).yields
+        @provider.expects(:pkgadd).once.with('-r', "mypackage")
 
         expect { @provider.install }.to_not raise_error
       end