puppet 4.0.0 → 4.5.0

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

@@ -0,0 +1,130 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+
+provider_class = Puppet::Type.type(:service).provider(:bsd)
+
+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.conf.d')
+    @provider = provider_class.new
+    @provider.stubs(:initscript)
+  end
+
+  describe "#instances" do
+    it "should have an instances method" do
+      expect(described_class).to respond_to :instances
+    end
+
+    it "should use defpath" do
+      expect(described_class.instances).to be_all { |provider| provider.get(:path) == described_class.defpath }
+    end
+  end
+
+  describe "#disable" do
+    it "should have a disable method" do
+      expect(@provider).to respond_to(:disable)
+    end
+
+    it "should remove a service file to disable" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      Puppet::FileSystem.stubs(:exist?).with('/etc/rc.conf.d/sshd').returns(true)
+      Puppet::FileSystem.expects(:exist?).with('/etc/rc.conf.d/sshd').returns(true)
+      File.stubs(:delete).with('/etc/rc.conf.d/sshd')
+      provider.disable
+    end
+
+    it "should not remove a service file if it doesn't exist" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      File.stubs(:exist?).with('/etc/rc.conf.d/sshd').returns(false)
+      Puppet::FileSystem.expects(:exist?).with('/etc/rc.conf.d/sshd').returns(false)
+      provider.disable
+    end
+  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'
+      File.stubs(:open).with('/etc/rc.conf.d/sshd', File::WRONLY | File::APPEND | File::CREAT, 0644).yields(fh)
+      fh.expects(:<<).with("sshd_enable=\"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'
+      File.stubs(:open).with('/etc/rc.conf.d/sshd', File::WRONLY | File::APPEND | File::CREAT, 0644).yields(fh)
+      fh.expects(:<<).with("sshd_enable=\"YES\"\n")
+      provider.enable
+    end
+  end
+
+  describe "#enabled?" do
+    it "should have an enabled? method" do
+      expect(@provider).to respond_to(:enabled?)
+    end
+
+    it "should return false if the service file does not exist" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      Puppet::FileSystem.stubs(:exist?).with('/etc/rc.conf.d/sshd').returns(false)
+      # File.stubs(:read).with('/etc/rc.conf.d/sshd').returns("sshd_enable=\"NO\"\n")
+      expect(provider.enabled?).to eq(:false)
+    end
+
+    it "should return true if the service file exists" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      Puppet::FileSystem.stubs(:exist?).with('/etc/rc.conf.d/sshd').returns(true)
+      # File.stubs(:read).with('/etc/rc.conf.d/sshd').returns("sshd_enable=\"YES\"\n")
+      expect(provider.enabled?).to eq(:true)
+    end
+  end
+
+  describe "#startcmd" do
+    it "should have a startcmd method" do
+      expect(@provider).to respond_to(:startcmd)
+    end
+
+    it "should use the supplied start command if specified" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :start => '/bin/foo'))
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.start
+    end
+
+    it "should start the serviced directly otherwise" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      provider.expects(:execute).with(['/etc/rc.d/sshd', :onestart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:search).with('sshd').returns('/etc/rc.d/sshd')
+      provider.start
+    end
+  end
+
+  describe "#stopcmd" do
+    it "should have a stopcmd method" do
+      expect(@provider).to respond_to(:stopcmd)
+    end
+
+    it "should use the supplied stop command if specified" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :stop => '/bin/foo'))
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.stop
+    end
+
+    it "should stop the serviced directly otherwise" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      provider.expects(:execute).with(['/etc/rc.d/sshd', :onestop], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:search).with('sshd').returns('/etc/rc.d/sshd')
+      provider.stop
+    end
+  end
+end

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

@@ -27,11 +27,23 @@ describe provider_class do
 
     @provider.stubs(:command).with(:update_rc).returns "update_rc"
     @provider.stubs(:command).with(:invoke_rc).returns "invoke_rc"
+    @provider.stubs(:command).with(:service).returns "service"
 
     @provider.stubs(:update_rc)
     @provider.stubs(:invoke_rc)
   end
 
+  operatingsystem = [ 'Debian', 'CumulusLinux' ]
+  operatingsystem.each do |os|
+    it "should be the default provider on #{os}" do
+      Facter.expects(:value).with(:operatingsystem).at_least_once.returns(os)
+      if os == 'Debian'
+        Facter.expects(:value).with(:operatingsystemmajrelease).returns('7')
+      end
+      expect(provider_class.default?).to be_truthy
+    end
+  end
+
   it "should have an enabled? method" do
     expect(@provider).to respond_to(:enabled?)
   end
@@ -73,6 +85,7 @@ describe provider_class do
   describe "when checking whether it is enabled" do
     it "should call Kernel.system() with the appropriate parameters" do
       @provider.expects(:system).with("/usr/sbin/invoke-rc.d", "--quiet", "--query", @resource[:name], "start").once
+      $CHILD_STATUS.stubs(:exitstatus).returns(0)
       @provider.enabled?
     end
 
@@ -111,6 +124,14 @@ describe provider_class do
       it_should_behave_like "manually queries service status", 105
     end
 
+    context "when invoke-rc.d exits with 101 status" do
+      it_should_behave_like "manually queries service status", 101
+    end
+
+    context "when invoke-rc.d exits with 105 status" do
+      it_should_behave_like "manually queries service status", 105
+    end
+
     # pick a range of non-[104.106] numbers, strings and booleans to test with.
     [-100, -1, 0, 1, 100, "foo", "", :true, :false].each do |exitstatus|
       it "should return false when invoke-rc.d exits with #{exitstatus} status" do
@@ -121,4 +142,12 @@ describe provider_class do
     end
   end
 
+  describe "when checking service status" do
+    it "should use the service command" 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(["service", @resource[:name], "status"])
+    end
+  end
 end

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

@@ -7,6 +7,7 @@ describe provider_class do
   before :each do
     @provider = provider_class.new
     @provider.stubs(:initscript)
+    Facter.stubs(:value).with(:osfamily).returns 'FreeBSD'
   end
 
   it "should correctly parse rcvar for FreeBSD < 7" do
@@ -43,6 +44,22 @@ OUTPUT
     expect(@provider.rcvar).to eq(['# ntpd', 'ntpd=YES'])
   end
 
+  it 'should parse service names with a description' do
+    @provider.stubs(:execute).returns <<OUTPUT
+# local_unbound : local caching forwarding resolver
+local_unbound_enable="YES"
+OUTPUT
+    expect(@provider.service_name).to eq('local_unbound')
+  end
+
+  it 'should parse service names without a description' do
+    @provider.stubs(:execute).returns <<OUTPUT
+# local_unbound
+local_unbound="YES"
+OUTPUT
+    expect(@provider.service_name).to eq('local_unbound')
+  end
+
   it "should find the right rcvar_value for FreeBSD < 7" do
     @provider.stubs(:rcvar).returns(['# ntpd', 'ntpd_enable=YES'])
 

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

@@ -9,6 +9,7 @@ describe Puppet::Type.type(:service).provider(:gentoo) do
     FileTest.stubs(:file?).with('/sbin/rc-update').returns true
     FileTest.stubs(:executable?).with('/sbin/rc-update').returns true
     Facter.stubs(:value).with(:operatingsystem).returns 'Gentoo'
+    Facter.stubs(:value).with(:osfamily).returns 'Gentoo'
 
     # The initprovider (parent of the gentoo provider) does a stat call
     # before it even tries to execute an initscript. We use sshd in all the
@@ -158,6 +159,7 @@ describe Puppet::Type.type(:service).provider(:gentoo) do
         provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
         provider.expects(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).never
         provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        $CHILD_STATUS.stubs(:exitstatus).returns 0
         provider.status
       end
 

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

@@ -39,7 +39,7 @@ describe Puppet::Type.type(:service).provider(:init) do
     before :each do
       described_class.stubs(:defpath).returns('tmp')
 
-      @services = ['one', 'two', 'three', 'four']
+      @services = ['one', 'two', 'three', 'four', 'umountfs']
       Dir.stubs(:entries).with('tmp').returns @services
       FileTest.expects(:directory?).with('tmp').returns(true)
       FileTest.stubs(:executable?).returns(true)
@@ -59,6 +59,16 @@ describe Puppet::Type.type(:service).provider(:init) do
       expect(described_class.get_services(described_class.defpath, exclude).map(&:name)).to eq(@services - [exclude])
     end
 
+    it "should omit Yocto services on cisco-wrlinux" do
+      Facter.stubs(:value).with(:osfamily).returns 'cisco-wrlinux'
+      exclude = 'umountfs'
+      expect(described_class.get_services(described_class.defpath).map(&:name)).to eq(@services - [exclude])
+    end
+
+    it "should not omit Yocto services on non cisco-wrlinux platforms" do
+      expect(described_class.get_services(described_class.defpath).map(&:name)).to eq(@services)
+    end
+
     it "should use defpath" do
       expect(described_class.instances).to be_all { |provider| provider.get(:path) == described_class.defpath }
     end
@@ -147,10 +157,14 @@ describe Puppet::Type.type(:service).provider(:init) do
         expect(provider).to respond_to(method)
       end
       describe "when running #{method}" do
+        before :each do
+          $CHILD_STATUS.stubs(:exitstatus).returns(0)
+        end
 
         it "should use any provided explicit command" do
           resource[method] = "/user/specified/command"
           provider.expects(:execute).with { |command, *args| command == ["/user/specified/command"] }
+
           provider.send(method)
         end
 
@@ -158,6 +172,7 @@ describe Puppet::Type.type(:service).provider(:init) do
           resource[:hasrestart] = :true
           resource[:hasstatus] = :true
           provider.expects(:execute).with { |command, *args| command ==  ["/service/path/myservice",method]}
+
           provider.send(method)
         end
       end
@@ -170,6 +185,7 @@ describe Puppet::Type.type(:service).provider(:init) do
         end
         it "should execute the command" do
           provider.expects(:texecute).with(:status, ['/service/path/myservice', :status], false).returns("")
+          $CHILD_STATUS.stubs(:exitstatus).returns(0)
           provider.status
         end
         it "should consider the process running if the command returns 0" do
@@ -213,5 +229,23 @@ describe Puppet::Type.type(:service).provider(:init) do
         provider.restart
       end
     end
+
+    describe "when starting a service on Solaris" do
+      it "should use ctrun" do
+        Facter.stubs(:value).with(:osfamily).returns 'Solaris'
+        provider.expects(:execute).with('/usr/bin/ctrun -l none /service/path/myservice start', {:failonfail => true, :override_locale => false, :squelch => false, :combine => true}).returns("")
+        $CHILD_STATUS.stubs(:exitstatus).returns(0)
+        provider.start
+      end
+    end
+
+    describe "when starting a service on RedHat" do
+      it "should not use ctrun" do
+        Facter.stubs(:value).with(:osfamily).returns 'RedHat'
+        provider.expects(:execute).with(['/service/path/myservice', :start], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true}).returns("")
+        $CHILD_STATUS.stubs(:exitstatus).returns(0)
+        provider.start
+      end
+    end
   end
 end

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

@@ -4,10 +4,12 @@
 require 'spec_helper'
 
 describe Puppet::Type.type(:service).provider(:launchd) do
+  let (:plistlib) { Puppet::Util::Plist }
   let (:joblabel) { "com.foo.food" }
   let (:provider) { subject.class }
-  let (:launchd_overrides) { '/var/db/launchd.db/com.apple.launchd/overrides.plist' }
   let(:resource) { Puppet::Type.type(:service).new(:name => joblabel, :provider => :launchd) }
+  let (:launchd_overrides_6_9) { '/var/db/launchd.db/com.apple.launchd/overrides.plist' }
+  let (:launchd_overrides_10_) { '/var/db/com.apple.xpc.launchd/disabled.plist' }
   subject { resource.provider }
 
   describe "the type interface" do
@@ -37,6 +39,56 @@ describe Puppet::Type.type(:service).provider(:launchd) do
     end
   end
 
+  [[10, '10.6'], [13, '10.9']].each do |kernel, version|
+    describe "when checking whether the service is enabled on OS X #{version}" do
+      it "should return true if the job plist says disabled is true and the global overrides says disabled is false" do
+        provider.expects(:get_os_version).returns(kernel).at_least_once
+        subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => true}])
+        plistlib.expects(:read_plist_file).with(launchd_overrides_6_9).returns({joblabel => {"Disabled" => false}})
+        FileTest.expects(:file?).with(launchd_overrides_6_9).returns(true)
+        expect(subject.enabled?).to eq(:true)
+      end
+      it "should return false if the job plist says disabled is false and the global overrides says disabled is true" do
+        provider.expects(:get_os_version).returns(kernel).at_least_once
+        subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => false}])
+        plistlib.expects(:read_plist_file).with(launchd_overrides_6_9).returns({joblabel => {"Disabled" => true}})
+        FileTest.expects(:file?).with(launchd_overrides_6_9).returns(true)
+        expect(subject.enabled?).to eq(:false)
+      end
+      it "should return true if the job plist and the global overrides have no disabled keys" do
+        provider.expects(:get_os_version).returns(kernel).at_least_once
+        subject.expects(:plist_from_label).returns([joblabel, {}])
+        plistlib.expects(:read_plist_file).with(launchd_overrides_6_9).returns({})
+        FileTest.expects(:file?).with(launchd_overrides_6_9).returns(true)
+        expect(subject.enabled?).to eq(:true)
+      end
+    end
+  end
+
+  describe "when checking whether the service is enabled on OS X 10.10" do
+    it "should return true if the job plist says disabled is true and the global overrides says disabled is false" do
+      provider.expects(:get_os_version).returns(14).at_least_once
+      subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => true}])
+      plistlib.expects(:read_plist_file).with(launchd_overrides_10_).returns({joblabel => false})
+      FileTest.expects(:file?).with(launchd_overrides_10_).returns(true)
+      expect(subject.enabled?).to eq(:true)
+    end
+    it "should return false if the job plist says disabled is false and the global overrides says disabled is true" do
+      provider.expects(:get_os_version).returns(14).at_least_once
+      subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => false}])
+      plistlib.expects(:read_plist_file).with(launchd_overrides_10_).returns({joblabel => true})
+      FileTest.expects(:file?).with(launchd_overrides_10_).returns(true)
+      expect(subject.enabled?).to eq(:false)
+    end
+    it "should return true if the job plist and the global overrides have no disabled keys" do
+      provider.expects(:get_os_version).returns(14).at_least_once
+      subject.expects(:plist_from_label).returns([joblabel, {}])
+      plistlib.expects(:read_plist_file).with(launchd_overrides_10_).returns({})
+      FileTest.expects(:file?).with(launchd_overrides_10_).returns(true)
+      expect(subject.enabled?).to eq(:true)
+    end
+  end
+
   describe "when starting the service" do
     it "should call any explicit 'start' command" do
       resource[:start] = "/bin/false"
@@ -47,13 +99,13 @@ describe Puppet::Type.type(:service).provider(:launchd) do
     it "should look for the relevant plist once" do
       subject.expects(:plist_from_label).returns([joblabel, {}]).once
       subject.expects(:enabled?).returns :true
-      subject.expects(:execute).with([:launchctl, :load, joblabel])
+      subject.expects(:execute).with([:launchctl, :load, "-w", joblabel])
       subject.start
     end
     it "should execute 'launchctl load' once without writing to the plist if the job is enabled" do
       subject.expects(:plist_from_label).returns([joblabel, {}])
       subject.expects(:enabled?).returns :true
-      subject.expects(:execute).with([:launchctl, :load, joblabel]).once
+      subject.expects(:execute).with([:launchctl, :load, "-w", joblabel]).once
       subject.start
     end
     it "should execute 'launchctl load' with writing to the plist once if the job is disabled" do
@@ -147,21 +199,45 @@ describe Puppet::Type.type(:service).provider(:launchd) do
     end
   end
 
-  describe "when enabling the service" do
+  [[10, "10.6"], [13, "10.9"]].each do |kernel, version|
+    describe "when enabling the service on OS X #{version}" do
+      it "should write to the global launchd overrides file once" do
+        resource[:enable] = true
+        provider.expects(:get_os_version).returns(kernel).at_least_once
+        plistlib.expects(:read_plist_file).with(launchd_overrides_6_9).returns({})
+        plistlib.expects(:write_plist_file).with(has_entry(resource[:name], {'Disabled' => false}), launchd_overrides_6_9).once
+        subject.enable
+      end
+    end
+
+    describe "when disabling the service on OS X #{version}" do
+      it "should write to the global launchd overrides file once" do
+        resource[:enable] = false
+        provider.expects(:get_os_version).returns(kernel).at_least_once
+        plistlib.expects(:read_plist_file).with(launchd_overrides_6_9).returns({})
+        plistlib.expects(:write_plist_file).with(has_entry(resource[:name], {'Disabled' => true}), launchd_overrides_6_9).once
+        subject.disable
+      end
+    end
+  end
+
+  describe "when enabling the service on OS X 10.10" do
     it "should write to the global launchd overrides file once" do
       resource[:enable] = true
-      provider.expects(:read_plist).returns({})
-      Plist::Emit.expects(:save_plist).once
+      provider.expects(:get_os_version).returns(14).at_least_once
+      plistlib.expects(:read_plist_file).with(launchd_overrides_10_).returns({})
+      plistlib.expects(:write_plist_file).with(has_entry(resource[:name], false), launchd_overrides_10_).once
       subject.enable
     end
   end
 
-  describe "when disabling the service" do
+  describe "when disabling the service on OS X 10.10" do
     it "should write to the global launchd overrides file once" do
       resource[:enable] = false
-      provider.stubs(:read_plist).returns({})
-      Plist::Emit.expects(:save_plist).once
-      subject.enable
+      provider.expects(:get_os_version).returns(14).at_least_once
+      plistlib.expects(:read_plist_file).with(launchd_overrides_10_).returns({})
+      plistlib.expects(:write_plist_file).with(has_entry(resource[:name], true), launchd_overrides_10_).once
+      subject.disable
     end
   end
 
@@ -179,23 +255,15 @@ describe Puppet::Type.type(:service).provider(:launchd) do
         }
       end
       let(:busted_plist_path) { '/Library/LaunchAgents/org.busted.plist' }
+      let(:binary_plist_path) { '/Library/LaunchAgents/org.binary.plist' }
 
       it "[17624] should warn that the plist in question is being skipped" do
         provider.expects(:launchd_paths).returns(['/Library/LaunchAgents'])
         provider.expects(:return_globbed_list_of_file_paths).with('/Library/LaunchAgents').returns([busted_plist_path])
-        provider.expects(:read_plist).with(busted_plist_path).returns(plist_without_label)
+        plistlib.expects(:read_plist_file).with(busted_plist_path).returns(plist_without_label)
         Puppet.expects(:warning).with("The #{busted_plist_path} plist does not contain a 'label' key; Puppet is skipping it")
         provider.make_label_to_path_map
       end
-
-      it "[15929] should skip plists that plutil cannot read" do
-        provider.expects(:plutil).with('-convert', 'xml1', '-o', '/dev/stdout',
-          busted_plist_path).raises(Puppet::ExecutionFailure, 'boom')
-        Puppet.expects(:warning).with("Cannot read file #{busted_plist_path}; " +
-                                      "Puppet is skipping it. \n" +
-                                      "Details: boom")
-        provider.read_plist(busted_plist_path)
-      end
     end
     it "should return the cached value when available" do
       provider.instance_variable_set(:@label_to_path_map, {'xx'=>'yy'})
@@ -209,7 +277,7 @@ describe Puppet::Type.type(:service).provider(:launchd) do
         provider.instance_variable_set(:@label_to_path_map, nil)
         provider.expects(:launchd_paths).returns([launchd_dir])
         provider.expects(:return_globbed_list_of_file_paths).with(launchd_dir).returns([plist])
-        provider.expects(:read_plist).with(plist).returns({'Label'=>'foo.bar.service'})
+        plistlib.expects(:read_plist_file).with(plist).returns({'Label'=>'foo.bar.service'})
       end
       it "should read the plists and return their contents" do
         expect(provider.make_label_to_path_map).to eq({label=>plist})

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

@@ -10,6 +10,7 @@ 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 :openbsd
+    Facter.stubs(:value).with(:osfamily).returns 'OpenBSD'
     FileTest.stubs(:file?).with('/usr/sbin/rcctl').returns true
     FileTest.stubs(:executable?).with('/usr/sbin/rcctl').returns true
   end

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

@@ -146,6 +146,7 @@ describe Puppet::Type.type(:service).provider(:openrc) do
         provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
         provider.expects(:execute).with(['/sbin/rc-service','sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).never
         provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        $CHILD_STATUS.stubs(:exitstatus).returns 0
         provider.status
       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

@@ -20,9 +20,10 @@ describe provider_class, :if => Puppet.features.posix? do
     FileTest.stubs(:file?).with('/sbin/service').returns true
     FileTest.stubs(:executable?).with('/sbin/service').returns true
     Facter.stubs(:value).with(:operatingsystem).returns('CentOS')
+    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
@@ -31,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