puppet 2.7.18 → 2.7.19

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

@@ -71,6 +71,7 @@ describe provider_class do
 
         name == provider.resource[:name]
       end
+      provider.expects(:execpipe).with(%w{/bin/pkg_info -I bash}).yields('')
 
       provider.install
       ENV.should_not be_key 'PKG_PATH'

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

@@ -14,12 +14,12 @@ describe Puppet::Type.type(:package).provider(:pkgdmg) do
     end
 
     it "no source is specified" do
-      expect { provider.install }.should raise_error(Puppet::Error, /must specify a package source/)
+      expect { provider.install }.to raise_error(Puppet::Error, /must specify a package source/)
     end
 
     it "the source does not end in .dmg or .pkg" do
       resource[:source] = "bar"
-      expect { provider.install }.should raise_error(Puppet::Error, /must specify a source string ending in .*dmg.*pkg/)
+      expect { provider.install }.to raise_error(Puppet::Error, /must specify a source string ending in .*dmg.*pkg/)
     end
   end
 
@@ -40,7 +40,7 @@ describe Puppet::Type.type(:package).provider(:pkgdmg) do
 
     it "should fail when a disk image with no system entities is mounted" do
       described_class.stubs(:hdiutil).returns(empty_hdiutil_plist)
-      expect { provider.install }.should raise_error(Puppet::Error, /No disk entities/)
+      expect { provider.install }.to raise_error(Puppet::Error, /No disk entities/)
     end
 
     it "should call hdiutil to mount and eject the disk image" do

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

@@ -1539,7 +1539,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
     end
 
     it 'should set the arguments' do
-      resource.provider.expects(:arguments=).with([@arguments])
+      resource.provider.expects(:arguments=).with(@arguments)
 
       resource.provider.create
     end

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

@@ -0,0 +1,209 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+describe Puppet::Type.type(:service).provider(:openrc) do
+
+  before :each do
+    Puppet::Type.type(:service).stubs(:defaultprovider).returns described_class
+    ['/sbin/rc-service', '/bin/rc-status', '/sbin/rc-update'].each do |command|
+      described_class.stubs(:which).with(command).returns(command)
+    end
+  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 rc-service --list" do
+      described_class.expects(:rcservice).with('-C','--list').returns File.read(my_fixture('rcservice_list'))
+      described_class.instances.map(&:name).should == [
+        'alsasound',
+        'consolefont',
+        'lvm-monitoring',
+        'pydoc-2.7',
+        'pydoc-3.2',
+        'wpa_supplicant',
+        'xdm',
+        '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 rc-service start otherwise" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      provider.expects(:execute).with(['/sbin/rc-service','sshd',:start], :failonfail => true, :squelch => true)
+      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 rc-service stop otherwise" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      provider.expects(:execute).with(['/sbin/rc-service','sshd',:stop], :failonfail => true, :squelch => true)
+      provider.stop
+    end
+  end
+
+  describe "#enabled?" do
+
+    before :each do
+      described_class.any_instance.stubs(:rcstatus).with('-C','-a').returns File.read(my_fixture('rcstatus'))
+    end
+
+    it "should run rc-status to get a list of enabled services" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      provider.expects(:rcstatus).with('-C','-a').returns "\n"
+      provider.enabled?
+    end
+
+    ['hwclock', 'modules', 'urandom'].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
+
+    ['netmount', 'xdm', 'local', 'foo_with_very_very_long_servicename_no_still_not_the_end_wait_for_it_almost_there_almost_there_now_finally_the_end'].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
+
+    ['net.eth0', 'pcscd'].each do |service|
+      it "should consider service #{service} in dynamic runlevel: hotplugged as disabled" do
+        provider = described_class.new(Puppet::Type.type(:service).new(:name => service))
+        provider.enabled?.should == :false
+      end
+    end
+
+    ['sysfs', 'udev-mount'].each do |service|
+      it "should consider service #{service} in dynamic runlevel: needed as disabled" do
+        provider = described_class.new(Puppet::Type.type(:service).new(:name => service))
+        provider.enabled?.should == :false
+      end
+    end
+
+    ['sshd'].each do |service|
+      it "should consider service #{service} in dynamic runlevel: manual 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(:rcupdate).with('-C', :add, 'sshd')
+      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(:rcupdate).with('-C', :del, 'sshd')
+      provider.disable
+    end
+  end
+
+  describe "#status" do
+
+    describe "when a special status command if 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(['/sbin/rc-service','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 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(['/sbin/rc-service','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 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(['/sbin/rc-service','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(['/sbin/rc-service','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(['/sbin/rc-service','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 rc-service status exits with a zero exitcode" do
+        provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => true))
+        provider.expects(:execute).with(['/sbin/rc-service','sshd',:status], :failonfail => false, :squelch => true)
+        $CHILD_STATUS.stubs(:exitstatus).returns 0
+        provider.status.should == :running
+      end
+
+      it "should return stopped if rc-service status exits with a non-zero exitcode" do
+        provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => true))
+        provider.expects(:execute).with(['/sbin/rc-service','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(['/sbin/rc-service','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 rc-service restart if hasrestart is true" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => true))
+      provider.expects(:execute).with(['/sbin/rc-service','sshd',:restart], :failonfail => true, :squelch => true)
+      provider.restart
+    end
+
+    it "should restart the service with rc-service stop/start if hasrestart is false" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => false))
+      provider.expects(:execute).with(['/sbin/rc-service','sshd',:restart], :failonfail => true, :squelch => true).never
+      provider.expects(:execute).with(['/sbin/rc-service','sshd',:stop], :failonfail => true, :squelch => true)
+      provider.expects(:execute).with(['/sbin/rc-service','sshd',:start], :failonfail => true, :squelch => true)
+      provider.restart
+    end
+  end
+
+end

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

@@ -8,16 +8,19 @@ require 'spec_helper'
 require 'win32/service' if Puppet.features.microsoft_windows?
 
 describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.microsoft_windows? do
+  let(:name)     { 'nonexistentservice' }
+  let(:resource) { Puppet::Type.type(:service).new(:name => name, :provider => :windows) }
+  let(:provider) { resource.provider }
+  let(:config)   { Struct::ServiceConfigInfo.new }
+  let(:status)   { Struct::ServiceStatus.new }
 
   before :each do
-    @resource = Puppet::Type.type(:service).new(:name => 'snmptrap', :provider => :windows)
+    # make sure we never actually execute anything (there are two execute methods)
+    provider.class.expects(:execute).never
+    provider.expects(:execute).never
 
-    @config = Struct::ServiceConfigInfo.new
-
-    @status = Struct::ServiceStatus.new
-
-    Win32::Service.stubs(:config_info).with(@resource[:name]).returns(@config)
-    Win32::Service.stubs(:status).with(@resource[:name]).returns(@status)
+    Win32::Service.stubs(:config_info).with(name).returns(config)
+    Win32::Service.stubs(:status).with(name).returns(status)
   end
 
   describe ".instances" do
@@ -30,102 +33,98 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
   end
 
   describe "#start" do
-    it "should call out to the Win32::Service API to start the service" do
-      @config.start_type = Win32::Service.get_start_type(Win32::Service::SERVICE_AUTO_START)
+    before :each do
+      config.start_type = Win32::Service.get_start_type(Win32::Service::SERVICE_AUTO_START)
+    end
 
-      Win32::Service.expects(:start).with( @resource[:name] )
+    it "should start the service" do
+      provider.expects(:net).with(:start, name)
 
-      @resource.provider.start
+      provider.start
     end
 
-    it "should handle when Win32::Service.start raises a Win32::Service::Error" do
-      @config.start_type = Win32::Service.get_start_type(Win32::Service::SERVICE_AUTO_START)
-
-      Win32::Service.expects(:start).with( @resource[:name] ).raises(
-        Win32::Service::Error.new("The service cannot be started, either because it is disabled or because it has no enabled devices associated with it.")
-      )
+    it "should raise an error if the start command fails" do
+      provider.expects(:net).with(:start, name).raises(Puppet::ExecutionFailure, "The service name is invalid.")
 
-      expect { @resource.provider.start }.to raise_error(
-        Puppet::Error,
-        /Cannot start .*, error was: The service cannot be started, either/
-      )
+      expect {
+        provider.start
+      }.to raise_error(Puppet::Error, /Cannot start #{name}, error was: The service name is invalid./)
     end
 
     describe "when the service is disabled" do
       before :each do
-        @config.start_type = Win32::Service.get_start_type(Win32::Service::SERVICE_DISABLED)
-        Win32::Service.stubs(:start).with(@resource[:name])
+        config.start_type = Win32::Service.get_start_type(Win32::Service::SERVICE_DISABLED)
       end
 
       it "should refuse to start if not managing enable" do
-        expect { @resource.provider.start }.to raise_error(Puppet::Error, /Will not start disabled service/)
+        expect { provider.start }.to raise_error(Puppet::Error, /Will not start disabled service/)
       end
 
       it "should enable if managing enable and enable is true" do
-        @resource[:enable] = :true
+        resource[:enable] = :true
 
-        Win32::Service.expects(:configure).with('service_name' => @resource[:name], 'start_type' => Win32::Service::SERVICE_AUTO_START).returns(Win32::Service)
+        provider.expects(:net).with(:start, name)
+        Win32::Service.expects(:configure).with('service_name' => name, 'start_type' => Win32::Service::SERVICE_AUTO_START).returns(Win32::Service)
 
-        @resource.provider.start
+        provider.start
       end
 
       it "should manual start if managing enable and enable is false" do
-        @resource[:enable] = :false
+        resource[:enable] = :false
 
-        Win32::Service.expects(:configure).with('service_name' => @resource[:name], 'start_type' => Win32::Service::SERVICE_DEMAND_START).returns(Win32::Service)
+        provider.expects(:net).with(:start, name)
+        Win32::Service.expects(:configure).with('service_name' => name, 'start_type' => Win32::Service::SERVICE_DEMAND_START).returns(Win32::Service)
 
-        @resource.provider.start
+        provider.start
       end
     end
   end
 
   describe "#stop" do
-    it "should call out to the Win32::Service API to stop the service" do
-      Win32::Service.expects(:stop).with( @resource[:name] )
-      @resource.provider.stop
-      end
+    it "should stop a running service" do
+      provider.expects(:net).with(:stop, name)
+
+      provider.stop
+    end
 
-    it "should handle when Win32::Service.stop raises a Win32::Service::Error" do
-      Win32::Service.expects(:stop).with( @resource[:name] ).raises(
-        Win32::Service::Error.new("should not try to stop an already stopped service.")
-      )
+    it "should raise an error if the stop command fails" do
+      provider.expects(:net).with(:stop, name).raises(Puppet::ExecutionFailure, 'The service name is invalid.')
 
-      expect { @resource.provider.stop }.to raise_error(
-        Puppet::Error,
-        /Cannot stop .*, error was: should not try to stop an already stopped service/
-      )
+      expect {
+        provider.stop
+      }.to raise_error(Puppet::Error, /Cannot stop #{name}, error was: The service name is invalid./)
     end
   end
 
   describe "#status" do
     ['stopped', 'paused', 'stop pending', 'pause pending'].each do |state|
       it "should report a #{state} service as stopped" do
-        @status.current_state = state
+        status.current_state = state
 
-        @resource.provider.status.should == :stopped
+        provider.status.should == :stopped
       end
     end
 
     ["running", "continue pending", "start pending" ].each do |state|
       it "should report a #{state} service as running" do
-        @status.current_state = state
+        status.current_state = state
 
-        @resource.provider.status.should == :running
+        provider.status.should == :running
       end
     end
   end
 
   describe "#enabled?" do
     it "should report a service with a startup type of manual as manual" do
-      @config.start_type = Win32::Service.get_start_type(Win32::Service::SERVICE_DEMAND_START)
+      config.start_type = Win32::Service.get_start_type(Win32::Service::SERVICE_DEMAND_START)
 
-      @resource.provider.enabled?.should == :manual
+      provider.enabled?.should == :manual
     end
 
     it "should report a service with a startup type of disabled as false" do
-      @config.start_type = Win32::Service.get_start_type(Win32::Service::SERVICE_DISABLED)
+      config.start_type = Win32::Service.get_start_type(Win32::Service::SERVICE_DISABLED)
 
-      @resource.provider.enabled?.should == :false
+      provider.enabled?.should == :false
     end
 
     # We need to guard this section explicitly since rspec will always
@@ -134,9 +133,9 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
       [Win32::Service::SERVICE_AUTO_START, Win32::Service::SERVICE_BOOT_START, Win32::Service::SERVICE_SYSTEM_START].each do |start_type_const|
         start_type = Win32::Service.get_start_type(start_type_const)
         it "should report a service with a startup type of '#{start_type}' as true" do
-          @config.start_type = start_type
+          config.start_type = start_type
 
-          @resource.provider.enabled?.should == :true
+          provider.enabled?.should == :true
         end
       end
     end
@@ -144,23 +143,22 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
 
   describe "#enable" do
     it "should set service start type to Service_Auto_Start when enabled" do
-      Win32::Service.expects(:configure).with('service_name' => @resource[:name], 'start_type' => Win32::Service::SERVICE_AUTO_START).returns(Win32::Service)
-      @resource.provider.enable
+      Win32::Service.expects(:configure).with('service_name' => name, 'start_type' => Win32::Service::SERVICE_AUTO_START).returns(Win32::Service)
+      provider.enable
     end
   end
 
   describe "#disable" do
     it "should set service start type to Service_Disabled when disabled" do
-      Win32::Service.expects(:configure).with('service_name' => @resource[:name], 'start_type' => Win32::Service::SERVICE_DISABLED).returns(Win32::Service)
-      @resource.provider.disable
+      Win32::Service.expects(:configure).with('service_name' => name, 'start_type' => Win32::Service::SERVICE_DISABLED).returns(Win32::Service)
+      provider.disable
      end
   end
 
   describe "#manual_start" do
     it "should set service start type to Service_Demand_Start (manual) when manual" do
-      Win32::Service.expects(:configure).with('service_name' => @resource[:name], 'start_type' => Win32::Service::SERVICE_DEMAND_START).returns(Win32::Service)
-      @resource.provider.manual_start
+      Win32::Service.expects(:configure).with('service_name' => name, 'start_type' => Win32::Service::SERVICE_DEMAND_START).returns(Win32::Service)
+      provider.manual_start
     end
   end
-
 end