puppet 4.0.0 → 4.5.0

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

@@ -28,12 +28,13 @@ 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', '-o', 'state,fmri').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)
+      expect(instances.size).to eq(3)
       expect(instances[0]).to eq({:name => 'svc:/system/svc/restarter:default', :ensure => :running })
       expect(instances[1]).to eq({:name => 'svc:/network/cswrsyncd:default', :ensure => :maintenance })
+      expect(instances[2]).to eq({:name => 'svc:/network/dns/client:default', :ensure => :degraded })
     end
   end
 
@@ -86,6 +87,10 @@ describe provider_class, :if => Puppet.features.posix? do
       @provider.stubs(:svcs).returns("maintenance\t-")
       expect(@provider.status).to eq(:maintenance)
     end
+    it "should return degraded if in degraded in svcs output" do
+      @provider.stubs(:svcs).returns("degraded\t-")
+      expect(@provider.status).to eq(:degraded)
+    end
     it "should return target state if transitioning in svcs output" do
       @provider.stubs(:svcs).returns("online\tdisabled")
       expect(@provider.status).to eq(:stopped)
@@ -99,21 +104,38 @@ 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 execute external command 'svcadm clear /system/myservice' if in degraded" do
+      @provider.stubs(:status).returns :degraded
+      @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 +148,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 +162,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
@@ -99,6 +113,7 @@ _EOF_
   describe "when checking if it is enabled" do
     it "should execute the lsitab command" do
       @provider.expects(:execute).with(['/usr/sbin/lsitab', 'myservice'], {:combine => true, :failonfail => false})
+      $CHILD_STATUS.stubs(:exitstatus).returns(0)
       @provider.enabled?
     end
 
@@ -159,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,15 +18,15 @@ 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)
-      expect(described_class.default?).to be_truthy
+      Facter.stubs(:value).with(:osfamily).returns(osfamily)
+      expect(described_class).to be_default
     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")
-    expect(described_class.default?).to be_truthy
+    Facter.stubs(:value).with(:osfamily).returns(:redhat)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("7")
+    expect(described_class).to be_default
   end
 
   [ 4, 5, 6 ].each do |ver|
@@ -35,39 +34,89 @@ describe Puppet::Type.type(:service).provider(:systemd) do
       # In Ruby 1.8.7, the order of hash elements differs from 1.9+ and
       # 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)
+      # expects() here.
+      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
+      expect(described_class).not_to be_default
     end
   end
 
-  [ 17, 18, 19, 20, 21 ].each do |ver|
+  [ 17, 18, 19, 20, 21, 22, 23 ].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}")
-      expect(described_class.default?).to be_truthy
+      Facter.stubs(:value).with(:osfamily).returns(:redhat)
+      Facter.stubs(:value).with(:operatingsystem).returns(:fedora)
+      Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
+      expect(described_class).to be_default
     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")
-    expect(described_class.default?).to be_truthy
+    Facter.stubs(:value).with(:osfamily).returns(:suse)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("12")
+    expect(described_class).to be_default
   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")
-    expect(described_class.default?).to be_truthy
+    Facter.stubs(:value).with(:osfamily).returns(:suse)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("13")
+    expect(described_class).to be_default
+  end
+
+  # 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).to be_default
+  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).to be_default
+  end
+
+  it "should not be the default provider on debian7" do
+    Facter.stubs(:value).with(:osfamily).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystem).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("7")
+    expect(described_class).not_to be_default
   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(:operatingsystemmajrelease).at_least_once.returns("11")
-    expect(described_class.default?).not_to be_truthy
+  it "should be the default provider on debian8" do
+    Facter.stubs(:value).with(:osfamily).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystem).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("8")
+    expect(described_class).to be_default
+  end
+
+  it "should not be the default provider on ubuntu14.04" do
+    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).not_to be_default
+  end
+
+  it "should be the default provider on ubuntu15.04" do
+    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).to be_default
+  end
+
+  it "should be the default provider on ubuntu15.10" do
+    Facter.stubs(:value).with(:osfamily).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystem).returns(:ubuntu)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("15.10")
+    expect(described_class).to be_default
+  end
+
+  it "should be the default provider on ubuntu16.04" do
+    Facter.stubs(:value).with(:osfamily).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystem).returns(:ubuntu)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("16.04")
+    expect(described_class).to be_default
   end
 
   [:enabled?, :enable, :disable, :start, :stop, :status, :restart].each do |method|
@@ -102,6 +151,7 @@ describe Puppet::Type.type(:service).provider(:systemd) do
 
     it "should start the service with systemctl start otherwise" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
+      provider.expects(:systemctl).with(:unmask, 'sshd.service')
       provider.expects(:execute).with(['/bin/systemctl','start','sshd.service'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.start
     end
@@ -124,21 +174,40 @@ describe Puppet::Type.type(:service).provider(:systemd) do
   describe "#enabled?" do
     it "should return :true if the service is enabled" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      provider.expects(:systemctl).with('is-enabled', 'sshd.service').returns 'enabled'
+      provider.expects(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).returns "enabled\n"
+      expect(provider.enabled?).to eq(:true)
+    end
+
+    it "should return :true if the service is static" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
+      provider.expects(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).returns "static\n"
       expect(provider.enabled?).to eq(:true)
     end
 
     it "should return :false if the service is disabled" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      provider.expects(:systemctl).with('is-enabled', 'sshd.service').raises Puppet::ExecutionFailure, "Execution of '/bin/systemctl is-enabled sshd.service' returned 1: disabled"
+      provider.expects(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).returns "disabled\n"
+      expect(provider.enabled?).to eq(:false)
+    end
+
+    it "should return :false if the service is masked and the resource is attempting to be disabled" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service', :enable => false))
+      provider.expects(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).returns "masked\n"
       expect(provider.enabled?).to eq(:false)
     end
+
+    it "should return :mask if the service is masked and the resource is attempting to be masked" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service', :enable => 'mask'))
+      provider.expects(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).returns "masked\n"
+      expect(provider.enabled?).to eq(:mask)
+    end
   end
 
   describe "#enable" do
     it "should run systemctl enable to enable a service" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      provider.expects(:systemctl).with('enable', 'sshd.service')
+      provider.expects(:systemctl).with(:unmask, 'sshd.service')
+      provider.expects(:systemctl).with(:enable, 'sshd.service')
       provider.enable
     end
   end
@@ -151,19 +220,41 @@ describe Puppet::Type.type(:service).provider(:systemd) do
     end
   end
 
+  describe "#mask" do
+    it "should run systemctl to disable and mask a service" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
+      # :disable is the only call in the provider that uses a symbol instead of
+      # a string.
+      # This should be made consistent in the future and all tests updated.
+      provider.expects(:systemctl).with(:disable, 'sshd.service')
+      provider.expects(:systemctl).with(:mask, 'sshd.service')
+      provider.mask
+    end
+  end
+
   # Note: systemd provider does not care about hasstatus or a custom status
   # command. I just assume that it does not make sense for systemd.
   describe "#status" do
-    it "should return running if active" do
+    it "should return running if if the command returns 0" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      provider.expects(:systemctl).with('is-active', 'sshd.service').returns 'active'
+      provider.expects(:execute).with(['/bin/systemctl','is-active','sshd.service'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).returns "active\n"
+      $CHILD_STATUS.stubs(:exitstatus).returns(0)
       expect(provider.status).to eq(:running)
     end
 
-    it "should return stopped if inactive" do
-      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      provider.expects(:systemctl).with('is-active', 'sshd.service').raises Puppet::ExecutionFailure, "Execution of '/bin/systemctl is-active sshd.service' returned 3: inactive"
-      expect(provider.status).to eq(:stopped)
+    [-10,-1,3,10].each { |ec|
+      it "should return stopped if the command returns something non-0" do
+        provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
+        provider.expects(:execute).with(['/bin/systemctl','is-active','sshd.service'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).returns "inactive\n"
+        $CHILD_STATUS.stubs(:exitstatus).returns(ec)
+        expect(provider.status).to eq(:stopped)
+      end
+    }
+
+    it "should use the supplied status command if specified" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service', :status => '/bin/foo'))
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+      provider.status
     end
   end
 
@@ -184,9 +275,50 @@ describe Puppet::Type.type(:service).provider(:systemd) do
     end
   end
 
-  it "(#16451) has command systemctl without being fully qualified" do
-    expect(described_class.instance_variable_get(:@commands)).
-      to include(:systemctl => 'systemctl')
+  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?).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?).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?).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
 end

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

@@ -24,6 +24,7 @@ describe Puppet::Type.type(:service).provider(:upstart) do
 
   it "should be the default provider on Ubuntu" do
     Facter.expects(:value).with(:operatingsystem).returns("Ubuntu")
+    Facter.expects(:value).with(:operatingsystemmajrelease).returns("12.04")
     expect(described_class.default?).to be_truthy
   end
 
@@ -157,6 +158,63 @@ describe Puppet::Type.type(:service).provider(:upstart) do
       end
     end
 
+    describe "when a special status command is specifed" do
+      it "should use the provided status command" do
+        resource = Puppet::Type.type(:service).new(:name => 'foo', :provider => :upstart, :status => '/bin/foo')
+        provider = provider_class.new(resource)
+        provider.stubs(:is_upstart?).returns(true)
+
+        provider.expects(:status_exec).with(['foo']).never
+        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        Process::Status.any_instance.stubs(:exitstatus).returns(0)
+        provider.status
+      end
+
+      it "should return :stopped when the provided status command return non-zero" do
+        resource = Puppet::Type.type(:service).new(:name => 'foo', :provider => :upstart, :status => '/bin/foo')
+        provider = provider_class.new(resource)
+        provider.stubs(:is_upstart?).returns(true)
+
+        provider.expects(:status_exec).with(['foo']).never
+        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        $CHILD_STATUS.stubs(:exitstatus).returns 1
+        expect(provider.status).to eq(:stopped)
+      end
+
+      it "should return :running when the provided status command return zero" do
+        resource = Puppet::Type.type(:service).new(:name => 'foo', :provider => :upstart, :status => '/bin/foo')
+        provider = provider_class.new(resource)
+        provider.stubs(:is_upstart?).returns(true)
+
+        provider.expects(:status_exec).with(['foo']).never
+        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        $CHILD_STATUS.stubs(:exitstatus).returns 0
+        expect(provider.status).to eq(:running)
+      end
+    end
+
+    describe "when :hasstatus is set to false" do
+      it "should return :stopped if the pid can not be found" do
+        resource = Puppet::Type.type(:service).new(:name => 'foo', :hasstatus => false, :provider => :upstart)
+        provider = provider_class.new(resource)
+        provider.stubs(:is_upstart?).returns(true)
+
+        provider.expects(:status_exec).with(['foo']).never
+        provider.expects(:getpid).returns nil
+        expect(provider.status).to eq(:stopped)
+      end
+
+      it "should return :running if the pid can be found" do
+        resource = Puppet::Type.type(:service).new(:name => 'foo', :hasstatus => false, :provider => :upstart)
+        provider = provider_class.new(resource)
+        provider.stubs(:is_upstart?).returns(true)
+
+        provider.expects(:status_exec).with(['foo']).never
+        provider.expects(:getpid).returns 2706
+        expect(provider.status).to eq(:running)
+      end
+    end
+
     it "should properly handle services with 'start' in their name" do
       resource = Puppet::Type.type(:service).new(:name => "foostartbar", :provider => :upstart)
       provider = provider_class.new(resource)

data/spec/unit/provider/ssh_authorized_key/parsed_spec.rb

@@ -261,7 +261,7 @@ describe provider_class, :unless => Puppet.features.microsoft_windows? do
         @resource = Puppet::Type.type(:ssh_authorized_key).new(:name => "foo", :target => "/tmp/.ssh_dir/place_to_put_authorized_keys")
         @provider = provider_class.new(@resource)
 
-        expect { @provider.flush }.to raise_error
+        expect { @provider.flush }.to raise_error(Puppet::Error, /Cannot write SSH authorized keys without user/)
       end
     end
 

data/spec/unit/provider/sshkey/parsed_spec.rb

@@ -41,31 +41,55 @@ describe "sshkey parsed provider" do
   end
 
   context "with the sample file" do
-    let :fixture do my_fixture('sample') end
-    before :each do subject.stubs(:default_target).returns(fixture) end
+    ['sample', 'sample_with_blank_lines'].each do |sample_file|
+      let :fixture do my_fixture(sample_file) end
+      before :each do subject.stubs(:default_target).returns(fixture) end
 
-    it "should parse to records on prefetch" do
-      expect(subject.target_records(fixture)).to be_empty
-      subject.prefetch
+      it "should parse to records on prefetch" do
+        expect(subject.target_records(fixture)).to be_empty
+        subject.prefetch
 
-      records = subject.target_records(fixture)
-      expect(records).to be_an Array
-      expect(records).to be_all {|x| expect(x).to be_an Hash }
-    end
+        records = subject.target_records(fixture)
+        expect(records).to be_an Array
+        expect(records).to be_all {|x| expect(x).to be_an Hash }
+      end
+
+      it "should reconstitute the file from records" do
+        subject.prefetch
+        records = subject.target_records(fixture)
+        text = subject.to_file(records).gsub(/^# HEADER.+\n/, '')
 
-    it "should reconstitute the file from records" do
-      subject.prefetch
-      records = subject.target_records(fixture)
+        oldlines = File.readlines(fixture).map(&:chomp)
+        newlines = text.chomp.split("\n")
+        expect(oldlines.length).to eq(newlines.length)
 
-      text = subject.to_file(records).gsub(/^# HEADER.+\n/, '')
+        oldlines.zip(newlines).each do |old, new|
+          expect(old.gsub(/\s+/, '')).to eq(new.gsub(/\s+/, ''))
+        end
+      end
+    end
+  end
 
-      oldlines = File.readlines(fixture).map(&:chomp)
-      newlines = text.chomp.split("\n")
-      expect(oldlines.length).to eq(newlines.length)
+  context 'default ssh_known_hosts target path' do
+    ['9.10', '9.11', '10.10'].each do |version|
+      it 'should be `/etc/ssh_known_hosts` when OSX version 10.10 or older`' do
+        Facter.expects(:value).with(:operatingsystem).returns('Darwin')
+        Facter.expects(:value).with(:macosx_productversion_major).returns(version)
+        expect(subject.default_target).to eq('/etc/ssh_known_hosts')
+      end
+    end
 
-      oldlines.zip(newlines).each do |old, new|
-        expect(old.gsub(/\s+/, '')).to eq(new.gsub(/\s+/, ''))
+    ['10.11', '10.13', '11.0', '11.11'].each do |version|
+      it 'should be `/etc/ssh/ssh_known_hosts` when OSX version 10.11 or newer`' do
+        Facter.expects(:value).with(:operatingsystem).returns('Darwin')
+        Facter.expects(:value).with(:macosx_productversion_major).returns(version)
+        expect(subject.default_target).to eq('/etc/ssh/ssh_known_hosts')
       end
     end
+
+    it 'should be `/etc/ssh/ssh_known_hosts` on other operating systems' do
+      Facter.expects(:value).with(:operatingsystem).returns('RedHat')
+      expect(subject.default_target).to eq('/etc/ssh/ssh_known_hosts')
+    end
   end
 end