puppet 0.25.5 → 2.6.0

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

@@ -1,89 +0,0 @@
-#!/usr/bin/env ruby
-#
-# Unit testing for the debian service provider
-#
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-provider_class = Puppet::Type.type(:service).provider(:debian)
-
-describe provider_class do
-
-    before(:each) do
-        # Create a mock resource
-        @resource = stub 'resource'
-
-        @provider = provider_class.new
-
-        # A catch all; no parameters set
-        @resource.stubs(:[]).returns(nil)
-
-        # But set name, source and path
-        @resource.stubs(:[]).with(:name).returns "myservice"
-        @resource.stubs(:[]).with(:ensure).returns :enabled
-        @resource.stubs(:ref).returns "Service[myservice]"
-
-        @provider.resource = @resource
-
-        @provider.stubs(:command).with(:update_rc).returns "update_rc"
-        @provider.stubs(:command).with(:invoke_rc).returns "invoke_rc"
-
-        @provider.stubs(:update_rc)
-        @provider.stubs(:invoke_rc)
-    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
-
-    describe "when enabling" do
-        it "should call update-rc.d twice" do
-            @provider.expects(:update_rc).twice
-            @provider.enable
-        end
-    end
-
-    describe "when disabling" do
-        it "should call update-rc.d twice" do
-            @provider.expects(:update_rc).twice
-            @provider.disable
-        end
-    end
-    
-    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
-            @provider.enabled?
-        end
-        
-        it "should return true when invoke-rc.d exits with 104 status" do
-            @provider.stubs(:system)
-            $?.stubs(:exitstatus).returns(104)
-            @provider.enabled?.should == :true
-        end
-        
-        it "should return true when invoke-rc.d exits with 106 status" do
-            @provider.stubs(:system)
-            $?.stubs(:exitstatus).returns(106)
-            @provider.enabled?.should == :true
-        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
-                @provider.stubs(:system)
-                $?.stubs(:exitstatus).returns(exitstatus)
-                @provider.enabled?.should == :false
-            end
-        end
-    end
-
- end

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

@@ -1,121 +0,0 @@
-#!/usr/bin/env ruby
-#
-# Unit testing for the Init service Provider
-#
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-provider_class = Puppet::Type.type(:service).provider(:init)
-
-describe provider_class do
-
-    before :each do
-        @resource = stub 'resource'
-        @resource.stubs(:[]).returns(nil)
-        @resource.stubs(:[]).with(:name).returns "myservice"
-#        @resource.stubs(:[]).with(:ensure).returns :enabled
-        @resource.stubs(:[]).with(:path).returns ["/service/path","/alt/service/path"]
-#        @resource.stubs(:ref).returns "Service[myservice]"
-        File.stubs(:directory?).returns(true)
-        
-        @provider = provider_class.new
-        @provider.resource = @resource
-    end
-
-
-    describe "when searching for the init script" do
-        it "should discard paths that do not exist" do
-            File.stubs(:exist?).returns(false)
-            File.stubs(:directory?).returns(false)
-            @provider.paths.should be_empty
-        end
-
-        it "should discard paths that are not directories" do
-            File.stubs(:exist?).returns(true)
-            File.stubs(:directory?).returns(false)
-            @provider.paths.should be_empty
-        end
-
-        it "should be able to find the init script in the service path" do
-            File.expects(:stat).with("/service/path/myservice").returns true
-            @provider.initscript.should == "/service/path/myservice"
-        end
-        it "should be able to find the init script in the service path" do
-            File.expects(:stat).with("/alt/service/path/myservice").returns true
-            @provider.initscript.should == "/alt/service/path/myservice"
-        end
-        it "should fail if the service isn't there" do
-            lambda { @provider.initscript }.should raise_error(Puppet::Error, "Could not find init script for 'myservice'")
-        end
-    end
-    
-    describe "if the init script is present" do
-        before :each do
-            File.stubs(:stat).with("/service/path/myservice").returns true
-        end
-        
-        [:start, :stop, :status, :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 pass #{method} to the init script when no explicit command is provided" do
-                    @resource.stubs(:[]).with("has#{method}".intern).returns :true
-                    @provider.expects(:execute).with { |command, *args| command ==  ["/service/path/myservice",method]}
-                    @provider.send(method)
-                end            
-            end
-        end
-
-        describe "when checking status" do
-            describe "when hasstatus is :true" do
-                before :each do
-                    @resource.stubs(:[]).with(:hasstatus).returns :true
-                end
-                it "should execute the command" do
-                    @provider.expects(:texecute).with(:status, ['/service/path/myservice', :status], false).returns("")
-                    @provider.status
-                end
-                it "should consider the process running if the command returns 0" do
-                    @provider.expects(:texecute).with(:status, ['/service/path/myservice', :status], false).returns("")
-                    $?.stubs(:exitstatus).returns(0)
-                    @provider.status.should == :running
-                end
-                [-10,-1,1,10].each { |ec|
-                    it "should consider the process stopped if the command returns something non-0" do
-                        @provider.expects(:texecute).with(:status, ['/service/path/myservice', :status], false).returns("")
-                        $?.stubs(:exitstatus).returns(ec)
-                        @provider.status.should == :stopped
-                    end
-                }
-            end
-            describe "when hasstatus is not :true" 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
-
-        describe "when restarting and hasrestart is not :true" do
-            it "should stop and restart the process" do
-                @provider.expects(:texecute).with(:stop, ['/service/path/myservice', :stop ], true).returns("")
-                @provider.expects(:texecute).with(:start,['/service/path/myservice', :start], true).returns("")
-                $?.stubs(:exitstatus).returns(0)
-                @provider.restart
-            end
-        end
-
-    end
-end

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

@@ -1,200 +0,0 @@
-#!/usr/bin/env ruby
-#
-# Unit testing for the launchd service provider
-#
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-require 'puppet'
-
-provider_class = Puppet::Type.type(:service).provider(:launchd)
-
-describe provider_class do
-
-    before :each do
-        # Create a mock resource
-        @resource = stub 'resource'
-
-        @provider = provider_class.new
-        @joblabel = "com.foo.food"
-        @jobplist = {}
-
-        # A catch all; no parameters set
-        @resource.stubs(:[]).returns(nil)
-
-        # But set name, ensure and enable
-        @resource.stubs(:[]).with(:name).returns @joblabel
-        @resource.stubs(:[]).with(:ensure).returns :enabled
-        @resource.stubs(:[]).with(:enable).returns :true
-        @resource.stubs(:ref).returns "Service[#{@joblabel}]"
-
-        # stub out the provider methods that actually touch the filesystem
-        # or execute commands
-        @provider.stubs(:plist_from_label).returns([@joblabel, @jobplist])
-        @provider.stubs(:execute).returns("")
-        @provider.stubs(:resource).returns @resource
-        
-        # We stub this out for the normal case as 10.6 is "special".
-        provider_class.stubs(:get_macosx_version_major).returns("10.5")
-        
-    end
-
-    it "should have a start method for #{@provider.object_id}" do
-        @provider.should respond_to(:start)
-    end
-
-    it "should have a stop method" do
-        @provider.should respond_to(:stop)
-    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
-
-    it "should have a status method" do
-        @provider.should respond_to(:status)
-    end
-
-
-    describe "when checking status" do
-        it "should call the external command 'launchctl list' once" do
-            @provider.expects(:launchctl).with(:list).returns("rotating-strawberry-madonnas")
-            @provider.status
-        end
-        it "should return stopped if not listed in launchctl list output" do
-            @provider.stubs(:launchctl).with(:list).returns("rotating-strawberry-madonnas")
-            @provider.status.should == :stopped
-        end
-        it "should return running if listed in launchctl list output" do
-            @provider.stubs(:launchctl).with(:list).returns(@joblabel)
-            @provider.status.should == :running
-        end
-    end
-    
-    describe "when checking whether the service is enabled" do
-        it "should return true if the job plist says disabled is false" do
-            @provider.stubs(:plist_from_label).returns(["foo", {"Disabled" => false}])
-            @provider.enabled?.should == :true
-        end
-        it "should return true if the job plist has no disabled key" do
-            @provider.stubs(:plist_from_label).returns(["foo", {}])
-            @provider.enabled?.should == :true
-        end
-        it "should return false if the job plist says disabled is true" do
-            @provider.stubs(:plist_from_label).returns(["foo", {"Disabled" => true}])
-            @provider.enabled?.should == :false
-        end
-    end
-    
-    describe "when checking whether the service is enabled on OS X 10.6" do
-        it "should return true if the job plist says disabled is true and the global overrides says disabled is false" do
-            provider_class.stubs(:get_macosx_version_major).returns("10.6")
-            @provider.stubs(:plist_from_label).returns(["foo", {"Disabled" => true}])
-            Plist.stubs(:parse_xml).returns({@resource[:name] => {"Disabled" => false}})
-            @provider.enabled?.should == :true
-        end
-        it "should return false if the job plist says disabled is false and the global overrides says disabled is true" do
-            provider_class.stubs(:get_macosx_version_major).returns("10.6")
-            @provider.stubs(:plist_from_label).returns(["foo", {"Disabled" => false}])
-            Plist.stubs(:parse_xml).returns({@resource[:name] => {"Disabled" => true}})
-            @provider.enabled?.should == :false
-        end
-        it "should return true if the job plist and the global overrides have no disabled keys" do
-            provider_class.stubs(:get_macosx_version_major).returns("10.6")
-            @provider.stubs(:plist_from_label).returns(["foo", {}])
-            Plist.stubs(:parse_xml).returns({})
-            @provider.enabled?.should == :true
-        end
-    end
-
-    describe "when starting the service" do
-        it "should look for the relevant plist once" do
-            @provider.expects(:plist_from_label).once
-            @provider.start
-        end
-        it "should execute 'launchctl load' once without writing to the plist if the job is enabled" do
-            @provider.stubs(:enabled?).returns :true
-            @provider.expects(:execute).with([:launchctl, :load, @resource[:name]]).once
-            @provider.start
-        end
-        it "should execute 'launchctl load' with writing to the plist once if the job is disabled" do
-            @provider.stubs(:enabled?).returns :false
-            @provider.expects(:execute).with([:launchctl, :load, "-w", @resource[:name]]).once
-            @provider.start
-        end
-        it "should disable the job once if the job is disabled and should be disabled at boot" do
-            @provider.stubs(:enabled?).returns :false
-            @resource.stubs(:[]).with(:enable).returns :false
-            @provider.expects(:disable).once
-            @provider.start
-        end
-    end
-
-    describe "when stopping the service" do
-        it "should look for the relevant plist once" do
-            @provider.expects(:plist_from_label).once
-            @provider.stop
-        end
-        it "should execute 'launchctl unload' once without writing to the plist if the job is disabled" do
-            @provider.stubs(:enabled?).returns :false
-            @provider.expects(:execute).with([:launchctl, :unload, @resource[:name]]).once
-            @provider.stop
-        end
-        it "should execute 'launchctl unload' with writing to the plist once if the job is enabled" do
-            @provider.stubs(:enabled?).returns :true
-            @provider.expects(:execute).with([:launchctl, :unload, "-w", @resource[:name]]).once
-            @provider.stop
-        end
-        it "should enable the job once if the job is enabled and should be enabled at boot" do
-            @provider.stubs(:enabled?).returns :true
-            @resource.stubs(:[]).with(:enable).returns :true
-            @provider.expects(:enable).once
-            @provider.stop
-        end
-    end
-
-    describe "when enabling the service" do
-        it "should look for the relevant plist once" do
-            @provider.expects(:plist_from_label).once
-            @provider.stop
-        end
-        it "should check if the job is enabled once" do
-            @provider.expects(:enabled?).once
-            @provider.stop
-        end
-    end
-
-    describe "when disabling the service" do
-        it "should look for the relevant plist once" do
-            @provider.expects(:plist_from_label).once
-            @provider.stop
-        end
-    end
-    
-    describe "when enabling the service on OS X 10.6" do
-        it "should write to the global launchd overrides file once" do
-            provider_class.stubs(:get_macosx_version_major).returns("10.6")
-            Plist.stubs(:parse_xml).returns({})
-            Plist::Emit.expects(:save_plist).once
-            @provider.enable
-        end
-    end
-    
-    describe "when disabling the service on OS X 10.6" do
-        it "should write to the global launchd overrides file once" do
-            provider_class.stubs(:get_macosx_version_major).returns("10.6")
-            Plist.stubs(:parse_xml).returns({})
-            Plist::Emit.expects(:save_plist).once
-            @provider.enable
-        end
-    end
-
- end

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

@@ -1,96 +0,0 @@
-#!/usr/bin/env ruby
-#
-# Unit testing for the RedHat service Provider
-#
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-provider_class = Puppet::Type.type(:service).provider(:redhat)
-
-describe provider_class do
-
-    before :each do
-        @resource = stub 'resource'
-        @resource.stubs(:[]).returns(nil)
-        @resource.stubs(:[]).with(:name).returns "myservice"
-
-        @provider = provider_class.new
-        @provider.resource = @resource
-        FileTest.stubs(:file?).with('/sbin/service').returns true
-        FileTest.stubs(:executable?).with('/sbin/service').returns true
-    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, :status, :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 service 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 ==  ['/sbin/service', 'myservice', method.to_s]}
-                @provider.send(method)
-            end            
-        end
-    end
-
-    describe "when checking status" do
-        describe "when hasstatus is :true" do
-            before :each do
-                @resource.stubs(:[]).with(:hasstatus).returns :true
-            end
-            it "should execute the service script with fail_on_failure false" do
-                @provider.expects(:texecute).with(:status, ['/sbin/service', 'myservice', 'status'], false)
-                @provider.status
-            end
-            it "should consider the process running if the command returns 0" do
-                @provider.expects(:texecute).with(:status, ['/sbin/service', 'myservice', 'status'], false)
-                $?.stubs(:exitstatus).returns(0)
-                @provider.status.should == :running
-            end
-            [-10,-1,1,10].each { |ec|
-                it "should consider the process stopped if the command returns something non-0" do
-                    @provider.expects(:texecute).with(:status, ['/sbin/service', 'myservice', 'status'], false)
-                    $?.stubs(:exitstatus).returns(ec)
-                    @provider.status.should == :stopped
-                end
-            }
-        end
-        describe "when hasstatus is not :true" 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
-
-    describe "when restarting and hasrestart is not :true" do
-        it "should stop and restart the process with the server script" do
-            @provider.expects(:texecute).with(:stop,  ['/sbin/service', 'myservice', 'stop'],  true)
-            @provider.expects(:texecute).with(:start, ['/sbin/service', 'myservice', 'start'], true)
-            @provider.restart
-        end
-    end
-end