puppet 6.12.0-x64-mingw32 → 6.17.0-x64-mingw32

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

@@ -33,13 +33,18 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
     let(:user1) { double(:account => 'user1', :domain => '.', :sid => 'user1sid') }
     let(:user2) { double(:account => 'user2', :domain => '.', :sid => 'user2sid') }
     let(:user3) { double(:account => 'user3', :domain => '.', :sid => 'user3sid') }
+    let(:user_without_domain) { double(:account => 'user_without_domain', :domain => nil, :sid => 'user_without_domain_sid') }
+
     let(:invalid_user) { SecureRandom.uuid }
+    let(:invalid_user_principal) { double(:account => "#{invalid_user}", :domain => nil, :sid => "#{invalid_user}") }
 
     before :each do
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user1').and_return(user1)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2').and_return(user2)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user3').and_return(user3)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user1', any_args).and_return(user1)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2', any_args).and_return(user2)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user3', any_args).and_return(user3)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user_without_domain', any_args).and_return(user_without_domain)
       allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with(invalid_user).and_return(nil)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with(invalid_user, true).and_return(invalid_user_principal)
     end
 
     describe "#members_insync?" do
@@ -199,7 +204,15 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
           ]
           expect(provider.members_insync?(current, ['user2','user1'])).to be_truthy
         end
+
+      it "should return true even if a current user is unresolvable if should is included" do
+        current = [
+            "#{invalid_user}",
+            'user2',
+          ]
+          expect(provider.members_insync?(current, ['user2'])).to be_truthy
       end
+     end
     end
 
     describe "#members_to_s" do
@@ -222,8 +235,8 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
         expect(provider.members_to_s(['user1', 'user2'])).to eq('.\user1,.\user2')
       end
 
-      it "should return the username when it cannot be resolved to a SID (for the sake of resource_harness error messages)" do
-        expect(provider.members_to_s([invalid_user])).to eq("#{invalid_user}")
+      it "should return a user string without domain if domain is not set" do
+        expect(provider.members_to_s(['user_without_domain'])).to eq('user_without_domain')
       end
 
       it "should return the username when it cannot be resolved to a SID (for the sake of resource_harness error messages)" do
@@ -237,10 +250,14 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
     let(:user2) { double(:account => 'user2', :domain => '.', :sid => 'user2sid') }
     let(:user3) { double(:account => 'user3', :domain => '.', :sid => 'user3sid') }
 
+    let(:invalid_user) { SecureRandom.uuid }
+    let(:invalid_user_principal) { double(:account => "#{invalid_user}", :domain => nil, :sid => "#{invalid_user}") }
+
     before :each do
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user1').and_return(user1)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2').and_return(user2)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user3').and_return(user3)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user1', any_args).and_return(user1)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2', any_args).and_return(user2)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user3', any_args).and_return(user3)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with(invalid_user, true).and_return(invalid_user_principal)
 
       resource[:auth_membership] = true
     end
@@ -261,6 +278,22 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
       expect(provider.members).to match_array(expected_members)
     end
 
+    it "should be able to handle unresolvable SID in list of members" do
+      allow(provider.group).to receive(:members).and_return([
+        'user1',
+        "#{invalid_user}",
+        'user3',
+      ])
+
+      expected_member_sids = [user1.sid, invalid_user_principal.sid, user3.sid]
+      expected_members = ['user1', "#{invalid_user}", 'user3']
+      allow(provider).to receive(:members_to_s)
+        .with(expected_member_sids)
+        .and_return(expected_members.join(','))
+
+      expect(provider.members).to match_array(expected_members)
+    end
+
     it "should be able to set group members" do
       allow(provider.group).to receive(:members).and_return(['user1', 'user2'])
 
@@ -272,8 +305,8 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
 
       allow(provider.group).to receive(:member_sids).and_return(member_sids[0..1])
 
-      expect(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2').and_return(member_sids[1])
-      expect(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user3').and_return(member_sids[2])
+      expect(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2', any_args).and_return(member_sids[1])
+      expect(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user3', any_args).and_return(member_sids[2])
 
       expect(provider.group).to receive(:remove_member_sids).with(member_sids[0])
       expect(provider.group).to receive(:add_member_sids).with(member_sids[2])

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

@@ -22,16 +22,26 @@ describe Puppet::Type.type(:package).provider(:aix) do
 
   context "when installing" do
     it "should install a package" do
+      allow(@provider).to receive(:query).and_return({:name => 'mypackage', :ensure => 'present', :status => :committed})
       expect(@provider).to receive(:installp).with('-acgwXY', '-d', 'mysource', 'mypackage')
       @provider.install
     end
 
     it "should install a specific package version" do
       allow(@resource).to receive(:should).with(:ensure).and_return("1.2.3.4")
+      allow(@provider).to receive(:query).and_return({:name => 'mypackage', :ensure => '1.2.3.4', :status => :committed})
       expect(@provider).to receive(:installp).with('-acgwXY', '-d', 'mysource', 'mypackage 1.2.3.4')
       @provider.install
     end
 
+    [:broken, :inconsistent].each do |state|
+      it "should fail if the installation resulted in a '#{state}' state" do
+        allow(@provider).to receive(:query).and_return({:name => 'mypackage', :ensure => 'present', :status => state})
+        expect(@provider).to receive(:installp).with('-acgwXY', '-d', 'mysource', 'mypackage')
+        expect { @provider.install }.to raise_error(Puppet::Error, "Package 'mypackage' is in a #{state} state and requires manual intervention")
+      end
+    end
+
     it "should fail if the specified version is superseded" do
       @resource[:ensure] = '1.2.3.3'
       allow(@provider).to receive(:installp).and_return(<<-OUTPUT)
@@ -126,4 +136,23 @@ END
     expect(described_class).to receive(:execute).and_return('mypackage:mypackage.rte:1.8.6.4::I:T:::::N:A Super Cool Package::::0::\n')
     described_class.prefetch({ 'mypackage' => latest, 'otherpackage' => absent })
   end
+
+  context "when querying instances" do
+    before(:each) do
+      allow(described_class).to receive(:execute).and_return(<<-END.chomp)
+sysmgt.cim.providers:sysmgt.cim.providers.metrics:2.12.1.1: : :B: :Metrics Providers for AIX OS: : : : : : :1:0:/:
+sysmgt.cim.providers:sysmgt.cim.providers.osbase:2.12.1.1: : :C: :Base Providers for AIX OS: : : : : : :1:0:/:
+openssl.base:openssl.base:1.0.2.1800: : :?: :Open Secure Socket Layer: : : : : : :0:0:/:
+END
+    end
+
+    it "should treat installed packages in broken and inconsistent state as absent" do
+      installed_packages = described_class.instances.map { |package| package.properties }
+      expected_packages = [{:name => 'sysmgt.cim.providers.metrics', :ensure => :absent, :status => :broken, :provider => :aix},
+                           {:name => 'sysmgt.cim.providers.osbase', :ensure => '2.12.1.1', :status => :committed, :provider => :aix},
+                           {:name => 'openssl.base', :ensure => :absent, :status => :inconsistent, :provider => :aix}]
+
+      expect(installed_packages).to eql(expected_packages)
+    end
+  end
 end

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

@@ -32,12 +32,14 @@ describe Puppet::Type.type(:package).provider(:apt) do
 
   it "should use 'apt-get remove' to uninstall" do
     expect(provider).to receive(:aptget).with("-y", "-q", :remove, name)
+    expect(provider).to receive(:properties).and_return({:mark => :none})
     provider.uninstall
   end
 
   it "should use 'apt-get purge' and 'dpkg purge' to purge" do
     expect(provider).to receive(:aptget).with("-y", "-q", :remove, "--purge", name)
     expect(provider).to receive(:dpkg).with("--purge", name)
+    expect(provider).to receive(:properties).and_return({:mark => :none})
     provider.purge
   end
 
@@ -88,14 +90,14 @@ Version table:
     it "should preseed if a responsefile is provided" do
       resource[:responsefile] = "/my/file"
       expect(provider).to receive(:run_preseed)
-
+      expect(provider).to receive(:properties).and_return({:mark => :none})
       allow(provider).to receive(:aptget)
       provider.install
     end
 
     it "should check for a cdrom" do
       expect(provider).to receive(:checkforcdrom)
-
+      expect(provider).to receive(:properties).and_return({:mark => :none})
       allow(provider).to receive(:aptget)
       provider.install
     end
@@ -106,6 +108,7 @@ Version table:
         expect(command[-1]).to eq(name)
         expect(command[-2]).to eq(:install)
       end
+      expect(provider).to receive(:properties).and_return({:mark => :none})
 
       provider.install
     end
@@ -115,6 +118,37 @@ Version table:
       expect(provider).to receive(:aptget) do |*command|
         expect(command[-1]).to eq("#{name}=1.0")
       end
+      expect(provider).to receive(:properties).and_return({:mark => :none})
+
+      provider.install
+    end
+
+    it "should select latest available version if range is specified" do
+      resource[:ensure] = '>60.0'
+      expect(provider).to receive(:aptget) do |*command|
+        expect(command[-1]).to eq("#{name}=72.0.1+build1-0ubuntu0.19.04.1")
+      end
+      expect(provider).to receive(:aptcache).with(:madison, name).and_return(<<-HERE)
+   #{name} | 72.0.1+build1-0ubuntu0.19.04.1 | http://ro.archive.ubuntu.com/ubuntu disco-updates/main amd64 Packages
+   #{name} | 72.0.1+build1-0ubuntu0.19.04.1 | http://security.ubuntu.com/ubuntu disco-security/main amd64 Packages
+   #{name} | 66.0.3+build1-0ubuntu1 | http://ro.archive.ubuntu.com/ubuntu disco/main amd64 Packages
+    HERE
+      expect(provider).to receive(:properties).and_return({:mark => :none})
+
+      provider.install
+    end
+
+    it "should pass through ensure is no version can be selected" do
+      resource[:ensure] = '>74.0'
+      expect(provider).to receive(:aptget) do |*command|
+        expect(command[-1]).to eq("#{name}=>74.0")
+      end
+      expect(provider).to receive(:aptcache).with(:madison, name).and_return(<<-HERE)
+   #{name} | 72.0.1+build1-0ubuntu0.19.04.1 | http://ro.archive.ubuntu.com/ubuntu disco-updates/main amd64 Packages
+   #{name} | 72.0.1+build1-0ubuntu0.19.04.1 | http://security.ubuntu.com/ubuntu disco-security/main amd64 Packages
+   #{name} | 66.0.3+build1-0ubuntu1 | http://ro.archive.ubuntu.com/ubuntu disco/main amd64 Packages
+    HERE
+      expect(provider).to receive(:properties).and_return({:mark => :none})
 
       provider.install
     end
@@ -124,6 +158,7 @@ Version table:
       expect(provider).to receive(:aptget) do |*command|
         expect(command).to include("--force-yes")
       end
+      expect(provider).to receive(:properties).and_return({:mark => :none})
 
       provider.install
     end
@@ -132,6 +167,7 @@ Version table:
       expect(provider).to receive(:aptget) do |*command|
         expect(command).to include("-q")
       end
+      expect(provider).to receive(:properties).and_return({:mark => :none})
 
       provider.install
     end
@@ -140,6 +176,7 @@ Version table:
       expect(provider).to receive(:aptget) do |*command|
         expect(command).to include("-y")
       end
+      expect(provider).to receive(:properties).and_return({:mark => :none})
 
       provider.install
     end
@@ -149,6 +186,7 @@ Version table:
       expect(provider).to receive(:aptget) do |*command|
         expect(command).to include("DPkg::Options::=--force-confold")
       end
+      expect(provider).to receive(:properties).and_return({:mark => :none})
 
       provider.install
     end
@@ -158,6 +196,7 @@ Version table:
       expect(provider).to receive(:aptget) do |*command|
         expect(command).to include("DPkg::Options::=--force-confnew")
       end
+      expect(provider).to receive(:properties).and_return({:mark => :none})
 
       provider.install
     end
@@ -165,6 +204,7 @@ Version table:
     it 'should support string install options' do
       resource[:install_options] = ['--foo', '--bar']
       expect(provider).to receive(:aptget).with('-q', '-y', '-o', 'DPkg::Options::=--force-confold', '--foo', '--bar', :install, name)
+      expect(provider).to receive(:properties).and_return({:mark => :none})
 
       provider.install
     end
@@ -172,6 +212,7 @@ Version table:
     it 'should support hash install options' do
       resource[:install_options] = ['--foo', { '--bar' => 'baz', '--baz' => 'foo' }]
       expect(provider).to receive(:aptget).with('-q', '-y', '-o', 'DPkg::Options::=--force-confold', '--foo', '--bar=baz', '--baz=foo', :install, name)
+      expect(provider).to receive(:properties).and_return({:mark => :none})
 
       provider.install
     end

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

@@ -33,6 +33,7 @@ describe Puppet::Type.type(:package).provider(:aptitude) do
     expect(pkg.provider).to receive(:aptitude).
       with('-y', '-o', 'DPkg::Options::=--force-confold', :install, 'faff').
       and_return(0)
+    expect(pkg.provider).to receive(:properties).and_return({:mark => :none})
 
     pkg.provider.install
   end

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

@@ -18,7 +18,7 @@ describe Puppet::Type.type(:package).provider(:dnfmodule) do
     {:failonfail => true, :combine => true, :custom_environment => {}}
   end
 
-  let(:packages) { File.read(my_fixture("dnf-module-list-installed.txt")) }
+  let(:packages) { File.read(my_fixture("dnf-module-list.txt")) }
   let(:dnf_path) { '/usr/bin/dnf' }
 
   before(:each) { allow(Puppet::Util).to receive(:which).with('/usr/bin/dnf').and_return(dnf_path) }
@@ -81,7 +81,7 @@ describe Puppet::Type.type(:package).provider(:dnfmodule) do
     end
   end
 
-  describe "when installing a module" do
+  describe "when ensuring a module" do
     let(:name) { 'baz' }
 
     let(:resource) do
@@ -123,6 +123,23 @@ describe Puppet::Type.type(:package).provider(:dnfmodule) do
         provider.install
       end
 
+      it "should just enable the module if it has no default profile" do
+        dnf_exception = Puppet::ExecutionFailure.new("Error: Problems in request:\nmissing groups or modules: #{resource[:name]}")
+        allow(provider).to receive(:execute).with(array_including('install')).and_raise(dnf_exception)
+        resource[:ensure] = :present
+        expect(provider).to receive(:execute).with(array_including('install')).ordered
+        expect(provider).to receive(:execute).with(array_including('enable')).ordered
+        provider.install
+      end
+
+      it "should just enable the module if enable_only = true" do
+        resource[:ensure] = :present
+        resource[:enable_only] = true
+        expect(provider).to receive(:execute).with(array_including('enable'))
+        expect(provider).not_to receive(:execute).with(array_including('install'))
+        provider.install
+      end
+
       it "should install the default stream and flavor" do
         resource[:ensure] = :present
         expect(provider).to receive(:execute).with(array_including('baz'))
@@ -161,26 +178,70 @@ describe Puppet::Type.type(:package).provider(:dnfmodule) do
         provider.install
       end
     end
+
+    context "with an installed flavor" do
+      before do
+        provider.instance_variable_get('@property_hash')[:flavor] = 'minimal'
+      end
+
+      it "should remove existing packages and reset the module stream before installing another flavor" do
+        resource[:flavor] = 'common'
+        expect(provider).to receive(:execute).thrice.with(array_including(/remove|reset|install/))
+        provider.flavor = resource[:flavor]
+      end
+
+      it "should not do anything if the flavor doesn't change" do
+        resource[:flavor] = 'minimal'
+        expect(provider).not_to receive(:execute)
+        provider.flavor = resource[:flavor]
+      end
+
+      it "should return the existing flavor" do
+        expect(provider.flavor).to eq('minimal')
+      end
+    end
+
+    context "when disabling a module" do
+
+      it "executed the disable command" do
+        resource[:ensure] = :disabled
+        expect(provider).to receive(:execute).with(array_including('disable'))
+        provider.disable
+      end
+
+      it "does not try to disable if package is already disabled" do
+        allow(described_class).to receive(:command).with(:dnf).and_return(dnf_path)
+        allow(Puppet::Util::Execution).to receive(:execute)
+          .with("/usr/bin/dnf module list -d 0 -e 1")
+          .and_return("baz 1.2 [d][x] common [d], complete  Package Description")
+        resource[:ensure] = :disabled
+        expect(provider).to be_insync(:disabled)
+      end
+    end
   end
 
-  context "parsing the output of module list --installed" do
+  context "parsing the output of module list" do
     before { allow(described_class).to receive(:command).with(:dnf).and_return(dnf_path) }
 
-    it "returns an array of installed modules" do
+    it "returns an array of enabled modules" do
       allow(Puppet::Util::Execution).to receive(:execute)
-        .with("/usr/bin/dnf module list --installed -d 0 -e 1")
+        .with("/usr/bin/dnf module list -d 0 -e 1")
         .and_return(packages)
 
-      installed_packages = described_class.instances.map { |package| package.properties }
-      expected_packages = [{name: "gimp", ensure: "2.8", flavor: "devel", :provider => :dnfmodule},
-                           {name: "mariadb", ensure: "10.3", flavor: "client", :provider => :dnfmodule},
-                           {name: "nodejs", ensure: "10", flavor: "minimal", :provider => :dnfmodule},
-                           {name: "perl", ensure: "5.26", flavor: "minimal", :provider => :dnfmodule},
-                           {name: "postgresql", ensure: "10", flavor: "server", :provider => :dnfmodule},
-                           {name: "rust-toolset", ensure: "rhel8", flavor: "common", :provider => :dnfmodule},
-                           {name: "subversion", ensure: "1.10", flavor: "server", :provider => :dnfmodule}]
-
-      expect(installed_packages).to eql(expected_packages)
+      enabled_packages = described_class.instances.map { |package| package.properties }
+      expected_packages = [{name: "389-ds", ensure: "1.4", flavor: :absent, provider: :dnfmodule},
+                           {name: "gimp", ensure: "2.8", flavor: "devel", provider: :dnfmodule},
+                           {name: "mariadb", ensure: "10.3", flavor: "client", provider: :dnfmodule},
+                           {name: "nodejs", ensure: "10", flavor: "minimal", provider: :dnfmodule},
+                           {name: "perl", ensure: "5.26", flavor: "minimal", provider: :dnfmodule},
+                           {name: "postgresql", ensure: "10", flavor: "server", provider: :dnfmodule},
+                           {name: "ruby", ensure: "2.5", flavor: :absent, provider: :dnfmodule},
+                           {name: "rust-toolset", ensure: "rhel8", flavor: "common", provider: :dnfmodule},
+                           {name: "subversion", ensure: "1.10", flavor: "server", provider: :dnfmodule},
+                           {name: "swig", ensure: :disabled, flavor: :absent, provider: :dnfmodule},
+                           {name: "virt", ensure: :disabled, flavor: :absent, provider: :dnfmodule}]
+
+      expect(enabled_packages).to eql(expected_packages)
     end
   end
 end

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

@@ -156,7 +156,8 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
         it "considers the package held if its state is 'hold'" do
           dpkg_query_execution_with_multiple_args_returns(query_output.gsub("install","hold"),args_with_provides,virtual_packages_query_args)
           dpkg_query_execution_with_multiple_args_returns(dpkg_query_result.gsub("install","hold"), args, query_args)
-          expect(provider.query[:ensure]).to eq(:held)
+          expect(provider.query[:ensure]).to eq("2.7.13")
+          expect(provider.query[:mark]).to eq(:hold)
         end
 
         context "regex check for query search" do
@@ -225,10 +226,16 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
         not_installed_bash = bash_installed_output.gsub("installed", "not-installed")
         not_installed_bash.gsub!(bash_version, "")
         dpkg_query_execution_returns(not_installed_bash)
-
         expect(provider.query[:ensure]).to eq(:purged)
       end
 
+      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)
+      end
+
       it "considers the package absent if it is marked 'config-files'" do
         dpkg_query_execution_returns(bash_installed_output.gsub("installed","config-files"))
         expect(provider.query[:ensure]).to eq(:absent)
@@ -251,7 +258,9 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
 
       it "considers the package held if its state is 'hold'" do
         dpkg_query_execution_returns(bash_installed_output.gsub("install","hold"))
-        expect(provider.query[:ensure]).to eq(:held)
+        query=provider.query
+        expect(query[:ensure]).to eq("4.2-5ubuntu3")
+        expect(query[:mark]).to eq(:hold)
       end
 
       context "parsing tests" do
@@ -328,14 +337,15 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
 
     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")
-
       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)
 
@@ -344,6 +354,7 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
 
     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)
 
@@ -351,6 +362,7 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
     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.install
@@ -369,14 +381,24 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
       allow(provider).to receive(:execute)
       allow(provider).to receive(:package_not_installed?).and_return(true)
       expect(provider).to receive(:install).once
-      provider.hold
+      expect(provider).to receive(:hold)
+      provider.deprecated_hold
+    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)
-      provider.hold
+      expect(provider).to receive(:hold)
+      provider.deprecated_hold
     end
 
     it "executes dpkg --set-selections when holding" do