puppet 3.1.1 → 3.2.0.rc1

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

@@ -7,8 +7,8 @@ describe Puppet::Type.type(:service).provider(:launchd) do
   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) }
-  subject { Puppet::Type.type(:service).provider(:launchd).new(resource) }
+  let(:resource) { Puppet::Type.type(:service).new(:name => joblabel, :provider => :launchd) }
+  subject { resource.provider }
 
   describe "the type interface" do
     %w{ start stop enabled? enable disable status}.each do |method|

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

@@ -0,0 +1,109 @@
+#! /usr/bin/env ruby
+#
+# Unit testing for the OpenWrt service Provider
+#
+require 'spec_helper'
+
+describe Puppet::Type.type(:service).provider(:openwrt), :as_platform => :posix do
+
+  let(:resource) do
+    resource = stub 'resource'
+    resource.stubs(:[]).returns(nil)
+    resource.stubs(:[]).with(:name).returns "myservice"
+    resource.stubs(:[]).with(:path).returns ["/etc/init.d"]
+
+    resource
+  end
+
+  let(:provider) do
+    provider = described_class.new
+    provider.stubs(:get).with(:hasstatus).returns false
+
+    provider
+  end
+
+
+  before :each do
+    resource.stubs(:provider).returns provider
+    provider.resource = resource
+
+    FileTest.stubs(:file?).with('/etc/rc.common').returns true
+    FileTest.stubs(:executable?).with('/etc/rc.common').returns true
+
+    # All OpenWrt tests operate on the init script directly. It must exist.
+    File.stubs(:directory?).with('/etc/init.d').returns true
+
+    File.stubs(:stat).with('/etc/init.d/myservice')
+    FileTest.stubs(:file?).with('/etc/init.d/myservice').returns true
+    FileTest.stubs(:executable?).with('/etc/init.d/myservice').returns true
+  end
+
+  operatingsystem = 'openwrt'
+  it "should be the default provider on #{operatingsystem}" do
+    Facter.expects(:value).with(:operatingsystem).returns(operatingsystem)
+    described_class.default?.should be_true
+  end
+
+  # test self.instances
+  describe "when getting all service instances" do
+
+    let(:services) {['dnsmasq', 'dropbear', 'firewall', 'led', 'puppet', 'uhttpd' ]}
+
+    before :each do
+      Dir.stubs(:entries).returns services
+      FileTest.stubs(:directory?).returns(true)
+      FileTest.stubs(:executable?).returns(true)
+    end
+    it "should return instances for all services" do
+      services.each do |inst|
+        described_class.expects(:new).with{|hash| hash[:name] == inst && hash[:path] == '/etc/init.d'}.returns("#{inst}_instance")
+      end
+      results = services.collect {|x| "#{x}_instance"}
+      described_class.instances.should == results
+    end
+  end
+
+  it "should have an enabled? method" do
+    provider.should respond_to(:enabled?)
+  end
+
+  it "should have an enable method" do
+    provider.should respond_to(:enable)
+  end
+
+  it "should have a disable method" do
+    provider.should respond_to(:disable)
+  end
+
+  [:start, :stop, :restart].each do |method|
+    it "should have a #{method} method" do
+      provider.should respond_to(method)
+    end
+    describe "when running #{method}" do
+
+      it "should use any provided explicit command" do
+        resource.stubs(:[]).with(method).returns "/user/specified/command"
+        provider.expects(:execute).with { |command, *args| command == ["/user/specified/command"] }
+        provider.send(method)
+      end
+
+      it "should execute the init script with #{method} when no explicit command is provided" do
+        resource.stubs(:[]).with("has#{method}".intern).returns :true
+        provider.expects(:execute).with { |command, *args| command ==  ['/etc/init.d/myservice', method ]}
+        provider.send(method)
+      end
+    end
+  end
+
+  describe "when checking status" do
+    it "should consider the service :running if it has a pid" do
+      provider.expects(:getpid).returns "1234"
+      provider.status.should == :running
+    end
+    it "should consider the service :stopped if it doesn't have a pid" do
+      provider.expects(:getpid).returns nil
+      provider.status.should == :stopped
+    end
+  end
+
+end

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

@@ -21,77 +21,153 @@ describe provider_class do
     @provider.stubs(:command).with(:startsrc).returns "/usr/bin/startsrc"
     @provider.stubs(:command).with(:lssrc).returns "/usr/bin/lssrc"
     @provider.stubs(:command).with(:refresh).returns "/usr/bin/refresh"
+    @provider.stubs(:command).with(:lsitab).returns "/usr/sbin/lsitab"
+    @provider.stubs(:command).with(:mkitab).returns "/usr/sbin/mkitab"
+    @provider.stubs(:command).with(:rmitab).returns "/usr/sbin/rmitab"
+    @provider.stubs(:command).with(:chitab).returns "/usr/sbin/chitab"
 
     @provider.stubs(:stopsrc)
     @provider.stubs(:startsrc)
     @provider.stubs(:lssrc)
     @provider.stubs(:refresh)
+    @provider.stubs(:lsitab)
+    @provider.stubs(:mkitab)
+    @provider.stubs(:rmitab)
+    @provider.stubs(:chitab)
   end
 
-  [:start, :stop, :status, :restart].each do |method|
-    it "should have a #{method} method" do
-      @provider.should respond_to(method)
+  describe ".instances" do
+    it "should has a .instances method" do
+      provider_class.should respond_to :instances
     end
+
+    it "should get a list of running services" 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.1:::/usr/sbin/inetd:0:0:/dev/console:/dev/console:/dev/console:-O:-Q:-K:0:0:20:0:0:-d:20:tcpip:
+myservice.2:::/usr/sbin/inetd:0:0:/dev/console:/dev/console:/dev/console:-O:-Q:-K:0:0:20:0:0:-d:20:tcpip:
+myservice.3:::/usr/sbin/inetd:0:0:/dev/console:/dev/console:/dev/console:-O:-Q:-K:0:0:20:0:0:-d:20:tcpip:
+myservice.4:::/usr/sbin/inetd:0:0:/dev/console:/dev/console:/dev/console:-O:-Q:-K:0:0:20:0:0:-d:20:tcpip:
+_EOF_
+      provider_class.stubs(:lssrc).returns sample_output
+      provider_class.instances.map(&:name).should == [
+        'myservice.1',
+        'myservice.2',
+        'myservice.3',
+        'myservice.4'
+      ]
+    end
+
   end
 
-  it "should execute the startsrc command" do
-    @provider.expects(:execute).with(['/usr/bin/startsrc', '-s', "myservice"], {:override_locale => false, :squelch => true, :failonfail => true})
-    @provider.start
+  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 => true, :failonfail => true})
+      @provider.start
+    end
   end
 
-  it "should execute the stopsrc command" do
-    @provider.expects(:execute).with(['/usr/bin/stopsrc', '-s', "myservice"], {:override_locale => false, :squelch => true, :failonfail => true})
-    @provider.stop
+  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 => true, :failonfail => true})
+      @provider.stop
+    end
   end
 
-  it "should execute status and return running if the subsystem is active" do
-    sample_output = <<_EOF_
-Subsystem         Group            PID          Status
-myservice         tcpip            1234         active
-_EOF_
+  describe "should have a set of methods" do
+    [:enabled?, :enable, :disable, :start, :stop, :status, :restart].each do |method|
+      it "should have a #{method} method" do
+        @provider.should respond_to(method)
+      end
+    end
+  end
 
-    @provider.expects(:execute).with(['/usr/bin/lssrc', '-s', "myservice"]).returns sample_output
-    @provider.status.should == :running
+  describe "when enabling" do
+    it "should execute the mkitab command" do
+      @provider.expects(:mkitab).with("myservice:2:once:/usr/bin/startsrc -s myservice").once
+      @provider.enable
+    end
   end
 
-  it "should execute status and return stopped if the subsystem is inoperative" do
-    sample_output = <<_EOF_
-Subsystem         Group            PID          Status
-myservice         tcpip                         inoperative
-_EOF_
+  describe "when disabling" do
+    it "should execute the rmitab command" do
+      @provider.expects(:rmitab).with("myservice")
+      @provider.disable
+    end
+  end
+
+  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})
+      @provider.enabled?
+    end
 
-    @provider.expects(:execute).with(['/usr/bin/lssrc', '-s', "myservice"]).returns sample_output
-    @provider.status.should == :stopped
+    it "should return false when lsitab returns non-zero" do
+      @provider.stubs(:execute)
+      $CHILD_STATUS.stubs(:exitstatus).returns(1)
+      @provider.enabled?.should == :false
+    end
+
+    it "should return true when lsitab returns zero" do
+      @provider.stubs(:execute)
+      $CHILD_STATUS.stubs(:exitstatus).returns(0)
+      @provider.enabled?.should == :true
+    end
   end
 
-  it "should execute status and return nil if the status is not known" do
-    sample_output = <<_EOF_
-Subsystem         Group            PID          Status
-myservice         tcpip                         randomdata
+
+  describe "when checking a subsystem's status" do
+    it "should execute status and return running if the subsystem is active" do
+      sample_output = <<_EOF_
+  Subsystem         Group            PID          Status
+  myservice         tcpip            1234         active
+_EOF_
+
+      @provider.expects(:execute).with(['/usr/bin/lssrc', '-s', "myservice"]).returns sample_output
+      @provider.status.should == :running
+    end
+
+    it "should execute status and return stopped if the subsystem is inoperative" do
+      sample_output = <<_EOF_
+  Subsystem         Group            PID          Status
+  myservice         tcpip                         inoperative
 _EOF_
 
-    @provider.expects(:execute).with(['/usr/bin/lssrc', '-s', "myservice"]).returns sample_output
-    @provider.status.should == nil
+      @provider.expects(:execute).with(['/usr/bin/lssrc', '-s', "myservice"]).returns sample_output
+      @provider.status.should == :stopped
+    end
+
+    it "should execute status and return nil if the status is not known" do
+      sample_output = <<_EOF_
+  Subsystem         Group            PID          Status
+  myservice         tcpip                         randomdata
+_EOF_
+
+      @provider.expects(:execute).with(['/usr/bin/lssrc', '-s', "myservice"]).returns sample_output
+      @provider.status.should == nil
+    end
   end
 
-  it "should execute restart which runs refresh" do
-    sample_output = <<_EOF_
+  describe "when restarting a service" do
+    it "should execute restart which runs refresh" 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:::/usr/sbin/inetd:0:0:/dev/console:/dev/console:/dev/console:-O:-Q:-K:0:0:20:0:0:-d:20:tcpip:
 _EOF_
-    @provider.expects(:execute).with(['/usr/bin/lssrc', '-Ss', "myservice"]).returns sample_output
-    @provider.expects(:execute).with(['/usr/bin/refresh', '-s', "myservice"])
-    @provider.restart
-  end
+      @provider.expects(:execute).with(['/usr/bin/lssrc', '-Ss', "myservice"]).returns sample_output
+      @provider.expects(:execute).with(['/usr/bin/refresh', '-s', "myservice"])
+      @provider.restart
+    end
 
-  it "should execute restart which runs stopsrc then startsrc" do
-    sample_output =  <<_EOF_
+    it "should execute restart which runs stopsrc then startsrc" 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 => true, :failonfail => true})
-    @provider.expects(:execute).with(['/usr/bin/startsrc', '-s', "myservice"], {:override_locale => false, :squelch => true, :failonfail => true})
-    @provider.restart
+      @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 => true, :failonfail => true})
+      @provider.expects(:execute).with(['/usr/bin/startsrc', '-s', "myservice"], {:override_locale => false, :squelch => true, :failonfail => true})
+      @provider.restart
+    end
   end
 end

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

@@ -1,34 +1,142 @@
 #! /usr/bin/env ruby
 #
-# Unit testing for the RedHat service Provider
+# Unit testing for the systemd service Provider
 #
 require 'spec_helper'
 
-provider_class = Puppet::Type.type(:service).provider(:systemd)
-
-describe provider_class do
+describe Puppet::Type.type(:service).provider(:systemd) do
   before :each do
-    @class = Puppet::Type.type(:service).provider(:redhat)
-    @resource = stub 'resource'
-    @resource.stubs(:[]).returns(nil)
-    @resource.stubs(:[]).with(:name).returns "myservice.service"
-    @provider = provider_class.new
-    @resource.stubs(:provider).returns @provider
-    @provider.resource = @resource
+    Puppet::Type.type(:service).stubs(:defaultprovider).returns described_class
+    described_class.stubs(:which).with('systemctl').returns '/bin/systemctl'
+  end
+
+  let :provider do
+    described_class.new(:name => 'sshd.service')
   end
 
   [:enabled?, :enable, :disable, :start, :stop, :status, :restart].each do |method|
     it "should have a #{method} method" do
-      @provider.should respond_to(method)
+      provider.should respond_to(method)
+    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 systemctl list-units" do
+      pending('A service that has been killed (ACTIVE=failed) is not recognized')
+      described_class.expects(:systemctl).with('list-units', '--full', '--all', '--no-pager').returns File.read(my_fixture('list_units'))
+      described_class.instances.map(&:name).should =~ %w{
+        auditd.service
+        crond.service
+        dbus.service
+        display-manager.service
+        ebtables.service
+        fedora-readonly.service
+        initrd-switch-root.service
+        ip6tables.service
+        puppet.service
+        sshd.service
+      }
+    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.service', :start => '/bin/foo'))
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.start
+    end
+
+    it "should start the service with systemctl start otherwise" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
+      provider.expects(:execute).with(['/bin/systemctl','start','sshd.service'], :failonfail => true, :override_locale => false, :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.service', :stop => '/bin/foo'))
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.stop
+    end
+
+    it "should stop the service with systemctl stop otherwise" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
+      provider.expects(:execute).with(['/bin/systemctl','stop','sshd.service'], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.stop
+    end
+  end
+
+  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.enabled?.should == :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.enabled?.should == :false
+    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.enable
+    end
+  end
+
+  describe "#disable" do
+    it "should run systemctl disable to disable a service" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
+      provider.expects(:systemctl).with(:disable, 'sshd.service')
+      provider.disable
     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
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
+      provider.expects(:systemctl).with('is-active', 'sshd.service').returns 'active'
+      provider.status.should == :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"
+      provider.status.should == :stopped
+    end
+  end
+
+  # Note: systemd provider does not care about hasrestart. I just assume it
+  # does not make sense for systemd
+  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(['/bin/systemctl','restart','sshd.service'], :failonfail => true, :override_locale => false, :squelch => true).never
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.restart
+    end
+
+    it "should restart the service with systemctl restart" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
+      provider.expects(:execute).with(['/bin/systemctl','restart','sshd.service'], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.restart
+    end
+  end
 
-  it 'should return resources from self.instances' do
-    provider_class.expects(:systemctl).with('list-units', '--full', '--all',  '--no-pager').returns(
-      "my_service loaded active running\nmy_other_service loaded active running"
-    )
-    provider_class.instances.map {|provider| provider.name}.should =~ ["my_service","my_other_service"]
+  it "(#16451) has command systemctl without being fully qualified" do
+    described_class.instance_variable_get(:@commands).
+      should include(:systemctl => 'systemctl')
   end
 
 end