puppet 4.2.3-x64-mingw32 → 4.3.0-x64-mingw32

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

@@ -22,7 +22,7 @@ describe provider_class do
   end
 
   before do
-    provider.stubs(:yum).returns 'yum'
+    provider_class.stubs(:command).with(:cmd).returns('/usr/bin/yum')
     provider.stubs(:rpm).returns 'rpm'
     provider.stubs(:get).with(:version).returns '1'
     provider.stubs(:get).with(:release).returns '1'
@@ -186,7 +186,7 @@ describe provider_class do
 
     it 'should call yum install for :installed' do
       resource.stubs(:should).with(:ensure).returns :installed
-      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :install, name)
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/yum', '-d', '0', '-e', '0', '-y', :install, 'mypackage'])
       provider.install
     end
 
@@ -197,7 +197,7 @@ describe provider_class do
 
       it 'should catch yum install failures when status code is wrong' do
         resource.stubs(:should).with(:ensure).returns :installed
-        provider.expects(:yum).with('-e', '0', '-y', :install, name).returns("No package #{name} available.")
+        Puppet::Util::Execution.expects(:execute).with(['/usr/bin/yum', '-e', '0', '-y', :install, name]).returns("No package #{name} available.")
         expect {
           provider.install
         }.to raise_error(Puppet::Error, "Could not find package #{name}")
@@ -212,7 +212,7 @@ describe provider_class do
     it 'should be able to set version' do
       version = '1.2'
       resource[:ensure] = version
-      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :install, "#{name}-#{version}")
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/yum', '-d', '0', '-e', '0', '-y', :install, "#{name}-#{version}"])
       provider.stubs(:query).returns :ensure => version
       provider.install
     end
@@ -220,6 +220,7 @@ describe provider_class do
     it 'should handle partial versions specified' do
       version = '1.3.4'
       resource[:ensure] = version
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/yum', '-d', '0', '-e', '0', '-y', :install, 'mypackage-1.3.4'])
       provider.stubs(:query).returns :ensure => '1.3.4-1.el6'
       provider.install
     end
@@ -228,7 +229,7 @@ describe provider_class do
       current_version = '1.2'
       version = '1.0'
       resource[:ensure] = '1.0'
-      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :downgrade, "#{name}-#{version}")
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/yum', '-d', '0', '-e', '0', '-y', :downgrade, "#{name}-#{version}"])
       provider.stubs(:query).returns(:ensure => current_version).then.returns(:ensure => version)
       provider.install
     end
@@ -237,22 +238,22 @@ describe provider_class do
       resource[:ensure] = :installed
       resource[:install_options] = ['-t', {'-x' => 'expackage'}]
 
-      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', ['-t', '-x=expackage'], :install, name)
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/yum', '-d', '0', '-e', '0', '-y', ['-t', '-x=expackage'], :install, name])
       provider.install
     end
 
     it 'allow virtual packages' do
       resource[:ensure] = :installed
       resource[:allow_virtual] = true
-      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :list, name).never
-      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :install, name)
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/yum', '-d', '0', '-e', '0', '-y', :list, name]).never
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/yum', '-d', '0', '-e', '0', '-y', :install, name])
       provider.install
     end
   end
 
   describe 'when uninstalling' do
     it 'should use erase to purge' do
-      provider.expects(:yum).with('-y', :erase, name)
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/yum', '-y', :erase, name])
       provider.purge
     end
   end
@@ -397,10 +398,6 @@ describe provider_class do
   end
 
   describe "executing yum check-update" do
-    before do
-      described_class.stubs(:command).with(:yum).returns '/usr/bin/yum'
-    end
-
     it "passes repos to enable to 'yum check-update'" do
       Puppet::Util::Execution.expects(:execute).with do |args, *rest|
         expect(args).to eq %w[/usr/bin/yum check-update --enablerepo=updates --enablerepo=centosplus]
@@ -497,6 +494,17 @@ describe provider_class do
         expect(output).not_to include("1:1.0.0-14.git20150121.b4ea599c.el7")
       end
     end
+    describe "with security notifications" do
+      let(:check_update) { File.read(my_fixture('yum-check-update-security.txt')) }
+      let(:output) { described_class.parse_updates(check_update) }
+
+      it "ignores all entries including and after 'Security'" do
+        expect(output).not_to include("Security")
+      end
+      it "includes updates before 'Security'" do
+        expect(output).to include("yum-plugin-fastestmirror.noarch")
+      end
+    end
   end
 
   describe "parsing a line from yum check-update" do

data/spec/unit/provider/scheduled_task/win32_taskscheduler_spec.rb

@@ -600,6 +600,16 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
 
       expect(resource.provider.exists?).to eq(true)
     end
+
+    it "uses SystemRoot in the path of Task folder" do
+      Win32::TaskScheduler.unstub(:new)
+      exists_test_task = Win32::TaskScheduler.new
+      Dir.stubs(:foreach).with('D:/WinNT/Tasks').returns([])
+
+      Puppet::Util.withenv('SystemRoot' => 'D:/WinNT') do
+        exists_test_task.exists?('Test Task')
+      end
+    end
   end
 
   describe '#clear_task' do

data/spec/unit/provider/service/debian_spec.rb

@@ -141,4 +141,31 @@ describe provider_class do
     end
   end
 
+  describe "when checking service status" do
+    context "On systems which use the systemd-sysvinit compatibility layer" do
+      it "should call systemctl to determine running status in Debian" do
+        Facter.stubs(:value).with(:operatingsystem).returns('Debian')
+        Facter.stubs(:value).with(:operatingsystemmajrelease).returns('8')
+        @resource.stubs(:[]).with(:hasstatus).returns(:true)
+        expect(@provider.statuscmd).to eq(["systemctl", "is-active", @resource[:name]])
+      end
+
+      it "should call systemctl to determine running status in Ubuntu" do
+        Facter.stubs(:value).with(:operatingsystem).returns('Ubuntu')
+        Facter.stubs(:value).with(:operatingsystemmajrelease).returns('15.04')
+        @resource.stubs(:[]).with(:hasstatus).returns(:true)
+        expect(@provider.statuscmd).to eq(["systemctl", "is-active", @resource[:name]])
+      end
+    end
+
+    context "On systems which only use sysvinit" do
+      it "should use the service init script" do
+        Facter.stubs(:value).with(:operatingsystem).returns('Debian')
+        Facter.stubs(:value).with(:operatingsystemmajrelease).returns('7')
+        @resource.stubs(:[]).with(:hasstatus).returns(:true)
+        @provider.stubs(:initscript).returns("/etc/init.d/script")
+        expect(@provider.statuscmd).to eq(["/etc/init.d/script", :status])
+      end
+    end
+  end
 end

data/spec/unit/provider/service/rcng_spec.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+
+provider_class = Puppet::Type.type(:service).provider(:rcng)
+
+describe provider_class, :unless => Puppet.features.microsoft_windows? do
+  before :each do
+    Puppet::Type.type(:service).stubs(:defaultprovider).returns described_class
+    Facter.stubs(:value).with(:operatingsystem).returns :netbsd
+    Facter.stubs(:value).with(:osfamily).returns 'NetBSD'
+    described_class.stubs(:defpath).returns('/etc/rc.d')
+    @provider = provider_class.new
+    @provider.stubs(:initscript)
+  end
+
+  describe "#enable" do
+    it "should have an enable method" do
+      expect(@provider).to respond_to(:enable)
+    end
+
+    it "should set the proper contents to enable" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      Dir.stubs(:mkdir).with('/etc/rc.conf.d')
+      fh = stub 'fh'
+      Puppet::Util.expects(:replace_file).with('/etc/rc.conf.d/sshd', 0644).yields(fh)
+      fh.expects(:puts).with("sshd=${sshd:=YES}\n")
+      provider.enable
+    end
+
+    it "should set the proper contents to enable when disabled" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      Dir.stubs(:mkdir).with('/etc/rc.conf.d')
+      File.stubs(:read).with('/etc/rc.conf.d/sshd').returns("sshd_enable=\"NO\"\n")
+      fh = stub 'fh'
+      Puppet::Util.expects(:replace_file).with('/etc/rc.conf.d/sshd', 0644).yields(fh)
+      fh.expects(:puts).with("sshd=${sshd:=YES}\n")
+      provider.enable
+    end
+  end
+end

data/spec/unit/provider/service/redhat_spec.rb

@@ -23,7 +23,7 @@ describe provider_class, :if => Puppet.features.posix? do
     Facter.stubs(:value).with(:osfamily).returns 'RedHat'
   end
 
-  osfamily = [ 'RedHat', 'Suse' ]
+  osfamily = [ 'RedHat' ]
 
   osfamily.each do |osfamily|
     it "should be the default provider on #{osfamily}" do
@@ -32,6 +32,13 @@ describe provider_class, :if => Puppet.features.posix? do
     end
   end
 
+  it "should be the default provider on sles11" do
+    Facter.stubs(:value).with(:osfamily).returns(:suse)
+    Facter.stubs(:value).with(:operatingsystem).returns(:suse)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("11")
+    expect(described_class.default?).to be_truthy
+  end
+
   # test self.instances
   describe "when getting all service instances" do
     before :each do

data/spec/unit/provider/service/smf_spec.rb

@@ -28,7 +28,7 @@ describe provider_class, :if => Puppet.features.posix? do
     end
 
     it "should get a list of services (excluding legacy)" do
-      provider_class.expects(:svcs).with().returns File.read(my_fixture('svcs.out'))
+      provider_class.expects(:svcs).with('-H').returns File.read(my_fixture('svcs.out'))
       instances = provider_class.instances.map { |p| {:name => p.get(:name), :ensure => p.get(:ensure)} }
       # we dont manage legacy
       expect(instances.size).to eq(2)
@@ -99,21 +99,31 @@ describe provider_class, :if => Puppet.features.posix? do
   describe "when starting" do
     it "should enable the service if it is not enabled" do
       @provider.expects(:status).returns :stopped
-      @provider.expects(:texecute)
+      @provider.expects(:texecute).with(:start, ['/usr/sbin/svcadm', :enable, '-s', '/system/myservice'], true)
+      @provider.expects(:wait).with('online')
       @provider.start
     end
 
     it "should always execute external command 'svcadm enable /system/myservice'" do
-      @provider.stubs(:status).returns :running
-      @provider.expects(:texecute).with(:start, ["/usr/sbin/svcadm", :enable, "-s", "/system/myservice"], true)
+      @provider.expects(:status).returns :running
+      @provider.expects(:texecute).with(:start, ['/usr/sbin/svcadm', :enable, '-s', '/system/myservice'], true)
+      @provider.expects(:wait).with('online')
       @provider.start
     end
 
     it "should execute external command 'svcadm clear /system/myservice' if in maintenance" do
       @provider.stubs(:status).returns :maintenance
       @provider.expects(:texecute).with(:start, ["/usr/sbin/svcadm", :clear, "/system/myservice"], true)
+      @provider.expects(:wait).with('online')
       @provider.start
     end
+
+    it "should error if timeout occurs while starting the service" do
+      @provider.expects(:status).returns :stopped
+      @provider.expects(:texecute).with(:start, ["/usr/sbin/svcadm", :enable, "-s", "/system/myservice"], true)
+      Timeout.expects(:timeout).with(60).raises(Timeout::Error)
+      expect { @provider.start }.to raise_error Puppet::Error, ('Timed out waiting for /system/myservice to transition states')
+    end
   end
 
   describe "when starting a service with a manifest" do
@@ -126,6 +136,7 @@ describe provider_class, :if => Puppet.features.posix? do
     it "should import the manifest if service is missing" do
       @provider.expects(:svccfg).with(:import, "/tmp/myservice.xml")
       @provider.expects(:texecute).with(:start, ["/usr/sbin/svcadm", :enable, "-s", "/system/myservice"], true)
+      @provider.expects(:wait).with('online')
       @provider.expects(:svcs).with('-H', '-o', 'state,nstate', "/system/myservice").returns("online\t-")
       @provider.start
     end
@@ -139,15 +150,29 @@ describe provider_class, :if => Puppet.features.posix? do
   describe "when stopping" do
     it "should execute external command 'svcadm disable /system/myservice'" do
       @provider.expects(:texecute).with(:stop, ["/usr/sbin/svcadm", :disable, "-s", "/system/myservice"], true)
+      @provider.expects(:wait).with('offline', 'disabled', 'uninitialized')
       @provider.stop
     end
+
+    it "should error if timeout occurs while stopping the service" do
+      @provider.expects(:texecute).with(:stop, ["/usr/sbin/svcadm", :disable, "-s", "/system/myservice"], true)
+      Timeout.expects(:timeout).with(60).raises(Timeout::Error)
+      expect { @provider.stop }.to raise_error Puppet::Error, ('Timed out waiting for /system/myservice to transition states')
+    end
   end
 
   describe "when restarting" do
     it "should call 'svcadm restart /system/myservice'" do
       @provider.expects(:texecute).with(:restart, ["/usr/sbin/svcadm", :restart, "/system/myservice"], true)
+      @provider.expects(:wait).with('online')
       @provider.restart
     end
-  end
 
+    it "should error if timeout occurs while restarting the service" do
+      @provider.expects(:texecute).with(:restart, ["/usr/sbin/svcadm", :restart, "/system/myservice"], true)
+      Timeout.expects(:timeout).with(60).raises(Timeout::Error)
+      expect { @provider.restart }.to raise_error Puppet::Error, ('Timed out waiting for /system/myservice to transition states')
+    end
+
+  end
 end

data/spec/unit/provider/service/src_spec.rb

@@ -37,7 +37,7 @@ describe provider_class do
   end
 
   describe ".instances" do
-    it "should has a .instances method" do
+    it "should have a .instances method" do
       expect(provider_class).to respond_to :instances
     end
 
@@ -63,15 +63,29 @@ _EOF_
   describe "when starting a service" do
     it "should execute the startsrc command" do
       @provider.expects(:execute).with(['/usr/bin/startsrc', '-s', "myservice"], {:override_locale => false, :squelch => false, :combine => true, :failonfail => true})
+      @provider.expects(:status).returns :running
       @provider.start
     end
+
+    it "should error if timeout occurs while stopping the service" do
+      @provider.expects(:execute).with(['/usr/bin/startsrc', '-s', "myservice"], {:override_locale => false, :squelch => false, :combine => true, :failonfail => true})
+      Timeout.expects(:timeout).with(60).raises(Timeout::Error)
+      expect { @provider.start }.to raise_error Puppet::Error, ('Timed out waiting for myservice to transition states')
+    end
   end
 
   describe "when stopping a service" do
     it "should execute the stopsrc command" do
       @provider.expects(:execute).with(['/usr/bin/stopsrc', '-s', "myservice"], {:override_locale => false, :squelch => false, :combine => true, :failonfail => true})
+      @provider.expects(:status).returns :stopped
       @provider.stop
     end
+
+    it "should error if timeout occurs while stopping the service" do
+      @provider.expects(:execute).with(['/usr/bin/stopsrc', '-s', "myservice"], {:override_locale => false, :squelch => false, :combine => true, :failonfail => true})
+      Timeout.expects(:timeout).with(60).raises(Timeout::Error)
+      expect { @provider.stop }.to raise_error Puppet::Error, ('Timed out waiting for myservice to transition states')
+    end
   end
 
   describe "should have a set of methods" do
@@ -160,14 +174,15 @@ _EOF_
       @provider.restart
     end
 
-    it "should execute restart which runs stopsrc then startsrc" do
+    it "should execute restart which runs stop then start" do
       sample_output =  <<_EOF_
 #subsysname:synonym:cmdargs:path:uid:auditid:standin:standout:standerr:action:multi:contact:svrkey:svrmtype:priority:signorm:sigforce:display:waittime:grpname:
 myservice::--no-daemonize:/usr/sbin/puppetd:0:0:/dev/null:/var/log/puppet.log:/var/log/puppet.log:-O:-Q:-S:0:0:20:15:9:-d:20::"
 _EOF_
+
       @provider.expects(:execute).with(['/usr/bin/lssrc', '-Ss', "myservice"]).returns sample_output
-      @provider.expects(:execute).with(['/usr/bin/stopsrc', '-s', "myservice"], {:override_locale => false, :squelch => false, :combine => true, :failonfail => true})
-      @provider.expects(:execute).with(['/usr/bin/startsrc', '-s', "myservice"], {:override_locale => false, :squelch => false, :combine => true, :failonfail => true})
+      @provider.expects(:stop)
+      @provider.expects(:start)
       @provider.restart
     end
   end

data/spec/unit/provider/service/systemd_spec.rb

@@ -10,7 +10,6 @@ describe Puppet::Type.type(:service).provider(:systemd) do
     described_class.stubs(:which).with('systemctl').returns '/bin/systemctl'
   end
 
-
   let :provider do
     described_class.new(:name => 'sshd.service')
   end
@@ -19,14 +18,14 @@ describe Puppet::Type.type(:service).provider(:systemd) do
 
   osfamily.each do |osfamily|
     it "should be the default provider on #{osfamily}" do
-      Facter.expects(:value).with(:osfamily).returns(osfamily)
+      Facter.stubs(:value).with(:osfamily).returns(osfamily)
       expect(described_class.default?).to be_truthy
     end
   end
 
   it "should be the default provider on rhel7" do
-    Facter.expects(:value).with(:osfamily).at_least_once.returns(:redhat)
-    Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns("7")
+    Facter.stubs(:value).with(:osfamily).returns(:redhat)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("7")
     expect(described_class.default?).to be_truthy
   end
 
@@ -36,7 +35,7 @@ describe Puppet::Type.type(:service).provider(:systemd) do
       # caused short-circuiting of the logic used by default.all? in the
       # provider. As a workaround we need to use stubs() instead of
       # expects() here.
-      Facter.expects(:value).with(:osfamily).at_least_once.returns(:redhat)
+      Facter.stubs(:value).with(:osfamily).returns(:redhat)
       Facter.stubs(:value).with(:operatingsystem).returns(:redhat)
       Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
       expect(described_class.default?).not_to be_truthy
@@ -45,57 +44,64 @@ describe Puppet::Type.type(:service).provider(:systemd) do
 
   [ 17, 18, 19, 20, 21 ].each do |ver|
     it "should be the default provider on fedora#{ver}" do
-      Facter.expects(:value).with(:osfamily).at_least_once.returns(:redhat)
-      Facter.expects(:value).with(:operatingsystem).at_least_once.returns(:fedora)
-      Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns("#{ver}")
+      Facter.stubs(:value).with(:osfamily).returns(:redhat)
+      Facter.stubs(:value).with(:operatingsystem).returns(:fedora)
+      Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
       expect(described_class.default?).to be_truthy
     end
   end
 
   it "should be the default provider on sles12" do
-    Facter.expects(:value).with(:osfamily).at_least_once.returns(:suse)
-    Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns("12")
+    Facter.stubs(:value).with(:osfamily).returns(:suse)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("12")
     expect(described_class.default?).to be_truthy
   end
 
   it "should be the default provider on opensuse13" do
-    Facter.expects(:value).with(:osfamily).at_least_once.returns(:suse)
-    Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns("13")
+    Facter.stubs(:value).with(:osfamily).returns(:suse)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("13")
     expect(described_class.default?).to be_truthy
   end
 
-  it "should not be the default provider on sles11" do
-    Facter.expects(:value).with(:osfamily).at_least_once.returns(:suse)
-    Facter.expects(:value).with(:operatingsystem).at_least_once.returns(:suse)
-    Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns("11")
-    expect(described_class.default?).not_to be_truthy
+  # tumbleweed is a rolling release with date-based major version numbers
+  it "should be the default provider on tumbleweed" do
+    Facter.stubs(:value).with(:osfamily).returns(:suse)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("20150829")
+    expect(described_class.default?).to be_truthy
+  end
+
+  # leap is the next generation suse release
+  it "should be the default provider on leap" do
+    Facter.stubs(:value).with(:osfamily).returns(:suse)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("42")
+    expect(described_class.default?).to be_truthy
   end
 
   it "should not be the default provider on debian7" do
-    Facter.expects(:value).with(:osfamily).at_least_once.returns(:debian)
-    Facter.expects(:value).with(:operatingsystem).at_least_once.returns(:debian)
-    Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns("7")
+    Facter.stubs(:value).with(:osfamily).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystem).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("7")
     expect(described_class.default?).not_to be_truthy
   end
 
   it "should be the default provider on debian8" do
-    Facter.expects(:value).with(:osfamily).at_least_once.returns(:debian)
-    Facter.expects(:value).with(:operatingsystem).at_least_once.returns(:debian)
-    Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns("8")
+    Facter.stubs(:value).with(:osfamily).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystem).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("8")
     expect(described_class.default?).to be_truthy
   end
 
   it "should not be the default provider on ubuntu14.04" do
-    Facter.expects(:value).with(:osfamily).at_least_once.returns(:debian)
-    Facter.expects(:value).with(:operatingsystem).at_least_once.returns(:ubuntu)
-    Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns("14.04")
+    Facter.stubs(:value).with(:osfamily).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystem).returns(:ubuntu)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("14.04")
     expect(described_class.default?).not_to be_truthy
   end
 
   it "should be the default provider on ubuntu15.04" do
-    Facter.expects(:value).with(:osfamily).at_least_once.returns(:debian)
-    Facter.expects(:value).with(:operatingsystem).at_least_once.returns(:ubuntu)
-    Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns("15.04")
+    Facter.stubs(:value).with(:osfamily).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystem).returns(:ubuntu)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("15.04")
     expect(described_class.default?).to be_truthy
   end
 
@@ -264,6 +270,49 @@ describe Puppet::Type.type(:service).provider(:systemd) do
     end
   end
 
+  describe "#debian_enabled?" do
+    [104, 106].each do |status|
+      it "should return true when invoke-rc.d returns #{status}" do
+        provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
+        provider.stubs(:system)
+        $CHILD_STATUS.expects(:exitstatus).returns(status)
+        expect(provider.debian_enabled?({:LoadState => "loaded", :UnitFileState => "UnitFileState"})).to eq(:true)
+      end
+    end
+
+    [101, 105].each do |status|
+      it "should return true when status is #{status} and there are at least 4 start links" do
+        provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
+        provider.stubs(:system)
+        provider.expects(:get_start_link_count).returns(4)
+        $CHILD_STATUS.expects(:exitstatus).twice.returns(status)
+        expect(provider.debian_enabled?({:LoadState => "loaded", :UnitFileState => "UnitFileState"})).to eq(:true)
+      end
+
+      it "should return false when status is #{status} and there are less than 4 start links" do
+        provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
+        provider.stubs(:system)
+        provider.expects(:get_start_link_count).returns(1)
+        $CHILD_STATUS.expects(:exitstatus).twice.returns(status)
+        expect(provider.debian_enabled?({:LoadState => "loaded", :UnitFileState => "UnitFileState"})).to eq(:false)
+      end
+    end
+  end
+
+  describe "#get_start_link_count" do
+    it "should strip the '.service' from the search if present in the resource name" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
+      Dir.expects(:glob).with("/etc/rc*.d/S??sshd").returns(['files'])
+      provider.get_start_link_count
+    end
+
+    it "should use the full service name if it does not include '.service'" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      Dir.expects(:glob).with("/etc/rc*.d/S??sshd").returns(['files'])
+      provider.get_start_link_count
+    end
+  end
+
   it "(#16451) has command systemctl without being fully qualified" do
     expect(described_class.instance_variable_get(:@commands)).to include(:systemctl => 'systemctl')
   end