puppet 2.7.14 → 2.7.16

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

@@ -0,0 +1,237 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+describe Puppet::Type.type(:service).provider(:gentoo) do
+
+  before :each do
+    Puppet::Type.type(:service).stubs(:defaultprovider).returns described_class
+    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'
+
+    # 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
+    # tests so make sure it is considered present.
+    File.stubs(:stat).with('/etc/init.d/sshd')
+  end
+
+  let :initscripts do
+    [
+      'alsasound',
+      'bootmisc',
+      'functions.sh',
+      'hwclock',
+      'reboot.sh',
+      'rsyncd',
+      'shutdown.sh',
+      'sshd',
+      'vixie-cron',
+      'wpa_supplicant',
+      'xdm-setup'
+    ]
+  end
+
+  let :helperscripts do
+    [
+      'functions.sh',
+      'reboot.sh',
+      'shutdown.sh'
+    ]
+  end
+
+  describe ".instances" do
+
+    it "should have an instances method" do
+      described_class.should respond_to :instances
+    end
+
+    it "should get a list of services from /etc/init.d but exclude helper scripts" do
+      FileTest.expects(:directory?).with('/etc/init.d').returns true
+      Dir.expects(:entries).with('/etc/init.d').returns initscripts
+      (initscripts - helperscripts).each do |script|
+        FileTest.expects(:executable?).with("/etc/init.d/#{script}").returns true
+      end
+      helperscripts.each do |script|
+        FileTest.expects(:executable?).with("/etc/init.d/#{script}").never
+      end
+      described_class.instances.map(&:name).should == [
+        'alsasound',
+        'bootmisc',
+        'hwclock',
+        'rsyncd',
+        'sshd',
+        'vixie-cron',
+        'wpa_supplicant',
+        'xdm-setup'
+      ]
+    end
+  end
+
+  describe "#start" do
+    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, :squelch => true)
+      provider.start
+    end
+    it "should start the service with <initscript> start otherwise" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      provider.expects(:execute).with(['/etc/init.d/sshd',:start], :failonfail => true, :squelch => true)
+      provider.expects(:search).with('sshd').returns('/etc/init.d/sshd')
+      provider.start
+    end
+  end
+
+  describe "#stop" do
+    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, :squelch => true)
+      provider.stop
+    end
+    it "should stop the service with <initscript> stop otherwise" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      provider.expects(:execute).with(['/etc/init.d/sshd',:stop], :failonfail => true, :squelch => true)
+      provider.expects(:search).with('sshd').returns('/etc/init.d/sshd')
+      provider.stop
+    end
+  end
+
+  describe "#enabled?" do
+
+    before :each do
+      described_class.any_instance.stubs(:update).with(:show).returns File.read(my_fixture('rc_update_show'))
+    end
+
+    it "should run rc-update show to get a list of enabled services" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      provider.expects(:update).with(:show).returns "\n"
+      provider.enabled?
+    end
+
+    ['hostname', 'net.lo', 'procfs'].each do |service|
+      it "should consider service #{service} in runlevel boot as enabled" do
+        provider = described_class.new(Puppet::Type.type(:service).new(:name => service))
+        provider.enabled?.should == :true
+      end
+    end
+
+    ['alsasound', 'xdm', 'netmount'].each do |service|
+      it "should consider service #{service} in runlevel default as enabled" do
+        provider = described_class.new(Puppet::Type.type(:service).new(:name => service))
+        provider.enabled?.should == :true
+      end
+    end
+
+    ['rsyncd', 'lighttpd', 'mysql'].each do |service|
+      it "should consider unused service #{service} as disabled" do
+        provider = described_class.new(Puppet::Type.type(:service).new(:name => service))
+        provider.enabled?.should == :false
+      end
+    end
+
+  end
+
+  describe "#enable" do
+    it "should run rc-update add to enable a service" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      provider.expects(:update).with(:add, 'sshd', :default)
+      provider.enable
+    end
+  end
+
+  describe "#disable" do
+    it "should run rc-update del to disable a service" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      provider.expects(:update).with(:del, 'sshd', :default)
+      provider.disable
+    end
+  end
+
+  describe "#status" do
+
+    describe "when a special status command is specified" do
+      it "should use the status command from the resource" 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, :squelch => true).never
+        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :squelch => true)
+        provider.status
+      end
+
+      it "should return :stopped when the status command returns with a non-zero exitcode" 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, :squelch => true).never
+        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :squelch => true)
+        $CHILD_STATUS.stubs(:exitstatus).returns 3
+        provider.status.should == :stopped
+      end
+
+      it "should return :running when the status command returns with a zero exitcode" 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, :squelch => true).never
+        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :squelch => true)
+        $CHILD_STATUS.stubs(:exitstatus).returns 0
+        provider.status.should == :running
+      end
+    end
+
+    describe "when hasstatus is false" do
+      it "should return running if a pid can be found" do
+        provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => false))
+        provider.expects(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :squelch => true).never
+        provider.expects(:getpid).returns 1000
+        provider.status.should == :running
+      end
+
+      it "should return stopped if no pid can be found" do
+        provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => false))
+        provider.expects(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :squelch => true).never
+        provider.expects(:getpid).returns nil
+        provider.status.should == :stopped
+      end
+    end
+
+    describe "when hasstatus is true" do
+      it "should return running if <initscript> status exits with a zero exitcode" do
+        provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => true))
+        provider.expects(:search).with('sshd').returns('/etc/init.d/sshd')
+        provider.expects(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :squelch => true)
+        $CHILD_STATUS.stubs(:exitstatus).returns 0
+        provider.status.should == :running
+      end
+
+      it "should return stopped if <initscript> status exits with a non-zero exitcode" do
+        provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => true))
+        provider.expects(:search).with('sshd').returns('/etc/init.d/sshd')
+        provider.expects(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :squelch => true)
+        $CHILD_STATUS.stubs(:exitstatus).returns 3
+        provider.status.should == :stopped
+      end
+    end
+  end
+
+  describe "#restart" do
+    it "should use the supplied restart command if specified" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :restart => '/bin/foo'))
+      provider.expects(:execute).with(['/etc/init.d/sshd',:restart], :failonfail => true, :squelch => true).never
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :squelch => true)
+      provider.restart
+    end
+
+    it "should restart the service with <initscript> restart if hasrestart is true" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => true))
+      provider.expects(:search).with('sshd').returns('/etc/init.d/sshd')
+      provider.expects(:execute).with(['/etc/init.d/sshd',:restart], :failonfail => true, :squelch => true)
+      provider.restart
+    end
+
+    it "should restart the service with <initscript> stop/start if hasrestart is false" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => false))
+      provider.expects(:search).with('sshd').returns('/etc/init.d/sshd')
+      provider.expects(:execute).with(['/etc/init.d/sshd',:restart], :failonfail => true, :squelch => true).never
+      provider.expects(:execute).with(['/etc/init.d/sshd',:stop], :failonfail => true, :squelch => true)
+      provider.expects(:execute).with(['/etc/init.d/sshd',:start], :failonfail => true, :squelch => true)
+      provider.restart
+    end
+  end
+
+end

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

@@ -46,9 +46,9 @@ describe provider_class do
       results = (@services-exclude).collect {|x| "#{x}_instance"}
       @class.get_services(@class.defpath, exclude).should == results
     end
-    it "should omit a single service from the exclude list", :'fails_on_ruby_1.9.2' => true do
+    it "should omit a single service from the exclude list" do
       exclude = 'two'
-      (@services-exclude.to_a).each do |inst|
+      (@services-[exclude]).each do |inst|
         @class.expects(:new).with{|hash| hash[:name] == inst}.returns("#{inst}_instance")
       end
       results = @services.reject{|x| x==exclude }.collect {|x| "#{x}_instance"}

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

@@ -24,8 +24,8 @@ describe provider_class, :as_platform => :posix do
   # test self.instances
   describe "when getting all service instances" do
     before :each do
-      @services = ['one', 'two', 'three', 'four', 'kudzu', 'functions', 'halt', 'killall', 'single', 'linuxconf']
-      @not_services = ['functions', 'halt', 'killall', 'single', 'linuxconf']
+      @services = ['one', 'two', 'three', 'four', 'kudzu', 'functions', 'halt', 'killall', 'single', 'linuxconf', 'boot', 'reboot']
+      @not_services = ['functions', 'halt', 'killall', 'single', 'linuxconf', 'reboot', 'boot']
       Dir.stubs(:entries).returns @services
       FileTest.stubs(:directory?).returns(true)
       FileTest.stubs(:executable?).returns(true)

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

@@ -3,7 +3,20 @@ require 'spec_helper'
 
 provider_class = Puppet::Type.type(:service).provider(:upstart)
 
-describe provider_class do
+describe provider_class, :unless => Puppet.features.microsoft_windows? do
+  let(:manual) { "\nmanual" }
+  let(:start_on_default_runlevels) {  "\nstart on runlevel [2,3,4,5]" }
+
+  def given_contents_of(file, content)
+    File.open(file, 'w') do |file|
+      file.write(content)
+    end
+  end
+
+  def then_contents_of(file)
+    File.open(file).read
+  end
+
   describe "#instances" do
     it "should be able to find all instances" do
       processes = ["rc stop/waiting", "ssh start/running, process 712"].join("\n")
@@ -49,17 +62,18 @@ describe provider_class do
       provider.expects(:status_exec).with(["foostartbar"]).returns("foostartbar stop/waiting")
       Process::Status.any_instance.stubs(:exitstatus).returns(0)
       provider.status.should == :stopped
-    end    
+    end
   end
+
   describe "inheritance" do
     let :resource do
       resource = Puppet::Type.type(:service).new(:name => "foo", :provider => :upstart)
     end
-    
+
     let :provider do
       provider = provider_class.new(resource)
     end
-    
+
     describe "when upstart job" do
       before(:each) do
         provider.stubs(:is_upstart?).returns(true)
@@ -73,7 +87,7 @@ describe provider_class do
         provider.statuscmd.should be_nil
       end
     end
-    
+
     describe "when init script" do
       before(:each) do
         provider.stubs(:is_upstart?).returns(false)
@@ -85,6 +99,401 @@ describe provider_class do
         end
       end
     end
+  end
+
+  describe "should be enableable" do
+    let :resource do
+      Puppet::Type.type(:service).new(:name => "foo", :provider => :upstart)
+    end
+
+    let :provider do
+      provider_class.new(resource)
+    end
+
+    let :init_script do
+      PuppetSpec::Files.tmpfile("foo.conf")
+    end
+
+    let :over_script do
+      PuppetSpec::Files.tmpfile("foo.override")
+    end
+
+    let :disabled_content do
+      "\t #  \t start on\nother file stuff"
+    end
+
+    let :multiline_disabled do
+      "# \t  start on other file stuff (\n" +
+       "#   more stuff ( # )))))inline comment\n" +
+       "#   finishing up )\n" +
+       "#   and done )\n" +
+       "this line shouldn't be touched\n"
+    end
+
+    let :multiline_disabled_bad do
+      "# \t  start on other file stuff (\n" +
+       "#   more stuff ( # )))))inline comment\n" +
+       "#   finishing up )\n" +
+       "#   and done )\n" +
+       "#   this is a comment i want to be a comment\n" +
+       "this line shouldn't be touched\n"
+    end
+
+    let :multiline_enabled_bad do
+      " \t  start on other file stuff (\n" +
+       "   more stuff ( # )))))inline comment\n" +
+       "   finishing up )\n" +
+       "   and done )\n" +
+       "#   this is a comment i want to be a comment\n" +
+       "this line shouldn't be touched\n"
+    end
+
+    let :multiline_enabled do
+      " \t  start on other file stuff (\n" +
+       "   more stuff ( # )))))inline comment\n" +
+       "   finishing up )\n" +
+       "   and done )\n" +
+       "this line shouldn't be touched\n"
+    end
+
+    let :multiline_enabled_standalone do
+      " \t  start on other file stuff (\n" +
+       "   more stuff ( # )))))inline comment\n" +
+       "   finishing up )\n" +
+       "   and done )\n"
+    end
+
+    let :enabled_content do
+      "\t   \t start on\nother file stuff"
+    end
+
+    let :content do
+      "just some text"
+    end
+
+    describe "Upstart version < 0.6.7" do
+      before(:each) do
+        provider.stubs(:is_upstart?).returns(true)
+        provider.stubs(:upstart_version).returns("0.6.5")
+        provider.stubs(:search).returns(init_script)
+      end
+
+      [:enabled?,:enable,:disable].each do |enableable|
+        it "should respond to #{enableable}" do
+          provider.should respond_to(enableable)
+        end
+      end
+
+      describe "when enabling" do
+        it "should open and uncomment the '#start on' line" do
+          given_contents_of(init_script, disabled_content)
+
+          provider.enable
+
+          then_contents_of(init_script).should == enabled_content
+        end
+
+        it "should add a 'start on' line if none exists" do
+          given_contents_of(init_script, "this is a file")
+
+          provider.enable
+
+          then_contents_of(init_script).should == "this is a file" + start_on_default_runlevels
+        end
+
+        it "should handle multiline 'start on' stanzas" do
+          given_contents_of(init_script, multiline_disabled)
+
+          provider.enable
+
+          then_contents_of(init_script).should == multiline_enabled
+        end
+
+        it "should leave not 'start on' comments alone" do
+          given_contents_of(init_script, multiline_disabled_bad)
+
+          provider.enable
+
+          then_contents_of(init_script).should == multiline_enabled_bad
+        end
+      end
+
+      describe "when disabling" do
+        it "should open and comment the 'start on' line" do
+          given_contents_of(init_script, enabled_content)
+
+          provider.disable
+
+          then_contents_of(init_script).should == "#" + enabled_content
+        end
+
+        it "should handle multiline 'start on' stanzas" do
+          given_contents_of(init_script, multiline_enabled)
+
+          provider.disable
+
+          then_contents_of(init_script).should == multiline_disabled
+        end
+      end
+
+      describe "when checking whether it is enabled" do
+        it "should consider 'start on ...' to be enabled" do
+          given_contents_of(init_script, enabled_content)
+
+          provider.enabled?.should == :true
+        end
+
+        it "should consider '#start on ...' to be disabled" do
+          given_contents_of(init_script, disabled_content)
+
+          provider.enabled?.should == :false
+        end
+
+        it "should consider no start on line to be disabled" do
+          given_contents_of(init_script, content)
+
+          provider.enabled?.should == :false
+        end
+      end
+      end
+
+    describe "Upstart version < 0.9.0" do
+      before(:each) do
+        provider.stubs(:is_upstart?).returns(true)
+        provider.stubs(:upstart_version).returns("0.7.0")
+        provider.stubs(:search).returns(init_script)
+      end
+
+      [:enabled?,:enable,:disable].each do |enableable|
+        it "should respond to #{enableable}" do
+          provider.should respond_to(enableable)
+        end
+      end
+
+      describe "when enabling" do
+        it "should open and uncomment the '#start on' line" do
+          given_contents_of(init_script, disabled_content)
+
+          provider.enable
+
+          then_contents_of(init_script).should == enabled_content
+        end
+
+        it "should add a 'start on' line if none exists" do
+          given_contents_of(init_script, "this is a file")
+
+          provider.enable
+
+          then_contents_of(init_script).should == "this is a file" + start_on_default_runlevels
+        end
+
+        it "should handle multiline 'start on' stanzas" do
+          given_contents_of(init_script, multiline_disabled)
+
+          provider.enable
+
+          then_contents_of(init_script).should == multiline_enabled
+        end
+
+        it "should remove manual stanzas" do
+          given_contents_of(init_script, multiline_enabled + manual)
+
+          provider.enable
+
+          then_contents_of(init_script).should == multiline_enabled
+        end
+
+        it "should leave not 'start on' comments alone" do
+          given_contents_of(init_script, multiline_disabled_bad)
+
+          provider.enable
+
+          then_contents_of(init_script).should == multiline_enabled_bad
+        end
+      end
+
+      describe "when disabling" do
+        it "should add a manual stanza" do
+          given_contents_of(init_script, enabled_content)
+
+          provider.disable
+
+          then_contents_of(init_script).should == enabled_content + manual
+        end
+
+        it "should remove manual stanzas before adding new ones" do
+          given_contents_of(init_script, multiline_enabled + manual + "\n" + multiline_enabled)
+
+          provider.disable
+
+          then_contents_of(init_script).should == multiline_enabled + "\n" + multiline_enabled + manual
+        end
+
+        it "should handle multiline 'start on' stanzas" do
+          given_contents_of(init_script, multiline_enabled)
+
+          provider.disable
+
+          then_contents_of(init_script).should == multiline_enabled + manual
+        end
+      end
+
+      describe "when checking whether it is enabled" do
+        describe "with no manual stanza" do
+          it "should consider 'start on ...' to be enabled" do
+            given_contents_of(init_script, enabled_content)
+
+            provider.enabled?.should == :true
+          end
+
+          it "should consider '#start on ...' to be disabled" do
+            given_contents_of(init_script, disabled_content)
+
+            provider.enabled?.should == :false
+          end
+
+          it "should consider no start on line to be disabled" do
+            given_contents_of(init_script, content)
+
+            provider.enabled?.should == :false
+          end
+        end
+
+        describe "with manual stanza" do
+          it "should consider 'start on ...' to be disabled if there is a trailing manual stanza" do
+            given_contents_of(init_script, enabled_content + manual + "\nother stuff")
+
+            provider.enabled?.should == :false
+          end
+
+          it "should consider two start on lines with a manual in the middle to be enabled" do
+            given_contents_of(init_script, enabled_content + manual + "\n" + enabled_content)
+
+            provider.enabled?.should == :true
+          end
+        end
+      end
+    end
 
+    describe "Upstart version > 0.9.0" do
+      before(:each) do
+        provider.stubs(:is_upstart?).returns(true)
+        provider.stubs(:upstart_version).returns("0.9.5")
+        provider.stubs(:search).returns(init_script)
+        provider.stubs(:overscript).returns(over_script)
+      end
+
+      [:enabled?,:enable,:disable].each do |enableable|
+        it "should respond to #{enableable}" do
+          provider.should respond_to(enableable)
+        end
+      end
+
+      describe "when enabling" do
+        it "should add a 'start on' line if none exists" do
+          given_contents_of(init_script, "this is a file")
+
+          provider.enable
+
+          then_contents_of(init_script).should == "this is a file"
+          then_contents_of(over_script).should == start_on_default_runlevels
+        end
+
+        it "should handle multiline 'start on' stanzas" do
+          given_contents_of(init_script, multiline_disabled)
+
+          provider.enable
+
+          then_contents_of(init_script).should == multiline_disabled
+          then_contents_of(over_script).should == start_on_default_runlevels
+        end
+
+        it "should remove any manual stanzas from the override file" do
+          given_contents_of(over_script, manual)
+          given_contents_of(init_script, enabled_content)
+
+          provider.enable
+
+          then_contents_of(init_script).should == enabled_content
+          then_contents_of(over_script).should == ""
+        end
+
+        it "should copy existing start on from conf file if conf file is disabled" do
+          given_contents_of(init_script, multiline_enabled_standalone + manual)
+
+          provider.enable
+
+          then_contents_of(init_script).should == multiline_enabled_standalone + manual
+          then_contents_of(over_script).should == multiline_enabled_standalone
+        end
+
+        it "should leave not 'start on' comments alone" do
+          given_contents_of(init_script, multiline_disabled_bad)
+          given_contents_of(over_script, "")
+
+          provider.enable
+
+          then_contents_of(init_script).should == multiline_disabled_bad
+          then_contents_of(over_script).should == start_on_default_runlevels
+        end
+      end
+
+      describe "when disabling" do
+        it "should add a manual stanza to the override file" do
+          given_contents_of(init_script, enabled_content)
+
+          provider.disable
+
+          then_contents_of(init_script).should == enabled_content
+          then_contents_of(over_script).should == manual
+        end
+
+        it "should handle multiline 'start on' stanzas" do
+          given_contents_of(init_script, multiline_enabled)
+
+          provider.disable
+
+          then_contents_of(init_script).should == multiline_enabled
+          then_contents_of(over_script).should == manual
+        end
+      end
+
+      describe "when checking whether it is enabled" do
+        describe "with no override file" do
+          it "should consider 'start on ...' to be enabled" do
+            given_contents_of(init_script, enabled_content)
+
+            provider.enabled?.should == :true
+          end
+
+          it "should consider '#start on ...' to be disabled" do
+            given_contents_of(init_script, disabled_content)
+
+            provider.enabled?.should == :false
+          end
+
+          it "should consider no start on line to be disabled" do
+            given_contents_of(init_script, content)
+
+            provider.enabled?.should == :false
+          end
+        end
+        describe "with override file" do
+          it "should consider 'start on ...' to be disabled if there is manual in override file" do
+            given_contents_of(init_script, enabled_content)
+            given_contents_of(over_script, manual + "\nother stuff")
+
+            provider.enabled?.should == :false
+          end
+
+          it "should consider '#start on ...' to be enabled if there is a start on in the override file" do
+            given_contents_of(init_script, disabled_content)
+            given_contents_of(over_script, "start on stuff")
+
+            provider.enabled?.should == :true
+          end
+        end
+      end
+    end
   end
 end