chef 10.12.0 → 10.14.0.beta.1

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

@@ -0,0 +1,140 @@
+#
+# Author:: Toomas Pelberg (<toomasp@gmx.net>)
+# Copyright:: Copyright (c) 2010 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+describe Chef::Provider::Service::Solaris do
+  before(:each) do
+    @node =Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    @new_resource = Chef::Resource::Service.new('chef')
+
+    @current_resource = Chef::Resource::Service.new('chef')
+
+    @provider = Chef::Provider::Service::Solaris.new(@new_resource, @run_context)
+    Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+
+    @stdin = StringIO.new
+    @stdout = StringIO.new
+    @stderr = StringIO.new
+    @pid = 2342
+    @stdout_string = "state disabled"
+    @stdout.stub!(:gets).and_return(@stdout_string)
+  end
+
+  it "should raise an error if /bin/svcs does not exist" do
+    File.should_receive(:exists?).with("/bin/svcs").and_return(false)
+    lambda { @provider.load_current_resource }.should raise_error(Chef::Exceptions::Service)
+  end 
+
+  describe "on a host with /bin/svcs" do
+
+    before do
+      File.stub!(:exists?).with('/bin/svcs').and_return(true)
+    end
+
+    describe "when discovering the current service state" do
+      it "should create a current resource with the name of the new resource" do
+        @provider.stub!(:popen4).with("/bin/svcs -l chef").and_return(@status)
+        Chef::Resource::Service.should_receive(:new).and_return(@current_resource)
+        @provider.load_current_resource
+      end
+
+
+      it "should return the current resource" do
+        @provider.stub!(:popen4).with("/bin/svcs -l chef").and_return(@status)
+        @provider.load_current_resource.should eql(@current_resource)
+      end 
+
+      it "should popen4 '/bin/svcs -l service_name'" do
+        @provider.should_receive(:popen4).with("/bin/svcs -l chef").and_return(@status)
+        @provider.load_current_resource
+      end
+
+      it "should mark service as not running" do
+        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        @current_resource.should_receive(:running).with(false)
+        @provider.load_current_resource
+      end
+
+      it "should mark service as running" do
+        @stdout.stub!(:each).and_yield("state online")
+        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        @current_resource.should_receive(:running).with(true)
+        @provider.load_current_resource
+      end
+    end
+
+    describe "when enabling the service" do
+      before(:each) do
+        #@provider = Chef::Provider::Service::Solaris.new(@node, @new_resource)
+        @provider.current_resource = @current_resource
+        @current_resource.enabled(true)
+      end
+
+      it "should call svcadm enable chef" do
+        @provider.should_receive(:run_command).with({:command => "/usr/sbin/svcadm enable chef"})
+        @provider.should_receive(:service_status).and_return(@current_resource)
+        @provider.enable_service.should be_true
+      end
+
+      it "should call svcadm enable chef for start_service" do
+        @provider.should_receive(:run_command).with({:command => "/usr/sbin/svcadm enable chef"})
+        @provider.should_receive(:service_status).and_return(@current_resource)
+        @provider.start_service.should be_true
+      end
+
+    end
+
+
+    describe "when disabling the service" do
+      before(:each) do
+        @provider.current_resource = @current_resource
+        @current_resource.enabled(false)
+      end
+
+      it "should call svcadm disable chef" do
+        @provider.should_receive(:run_command).with({:command => "/usr/sbin/svcadm disable chef"})
+        @provider.should_receive(:service_status).and_return(@current_resource)
+        @provider.disable_service.should be_false
+      end
+
+      it "should call svcadm disable chef for stop_service" do
+        @provider.should_receive(:run_command).with({:command => "/usr/sbin/svcadm disable chef"})
+        @provider.should_receive(:service_status).and_return(@current_resource)
+        @provider.stop_service.should be_false
+      end
+
+    end
+
+    describe "when reloading the service" do
+      before(:each) do
+        @status = mock("Process::Status", :exitstatus => 0)
+        @provider.current_resource = @current_resource
+      end
+
+      it "should call svcadm refresh chef" do
+        @provider.should_receive(:run_command).with({:command => "/usr/sbin/svcadm refresh chef"}).and_return(@status)
+        @provider.reload_service.should be_true
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,239 @@
+#
+# Author:: Stephen Haynes (<sh@nomitor.com>)
+# Copyright:: Copyright (c) 2011 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+describe Chef::Provider::Service::Systemd do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Service.new('rsyslog.service')
+    @provider = Chef::Provider::Service::Systemd.new(@new_resource, @run_context)
+  end
+
+  describe "load_current_resource" do
+    before(:each) do
+      @current_resource = Chef::Resource::Service.new('rsyslog.service')
+      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+
+      @provider.stub!(:is_active?).and_return(false)
+      @provider.stub!(:is_enabled?).and_return(false)
+    end
+
+    it "should create a current resource with the name of the new resource" do
+      Chef::Resource::Service.should_receive(:new).and_return(@current_resource)
+      @provider.load_current_resource
+    end
+
+    it "should set the current resources service name to the new resources service name" do
+      @current_resource.should_receive(:service_name).with(@new_resource.service_name)
+      @provider.load_current_resource
+    end
+
+    it "should check if the service is running" do
+      @provider.should_receive(:is_active?)
+      @provider.load_current_resource
+    end
+
+    it "should set running to true if the service is running" do
+      @provider.stub!(:is_active?).and_return(true)
+      @current_resource.should_receive(:running).with(true)
+      @provider.load_current_resource
+    end
+
+    it "should set running to false if the service is not running" do
+      @provider.stub!(:is_active?).and_return(false)
+      @current_resource.should_receive(:running).with(false)
+      @provider.load_current_resource
+    end
+
+    describe "when a status command has been specified" do
+      before do
+        @new_resource.stub!(:status_command).and_return("/bin/chefhasmonkeypants status")
+      end
+
+      it "should run the services status command if one has been specified" do
+        @provider.stub!(:run_command_with_systems_locale).with({:command => "/bin/chefhasmonkeypants status"}).and_return(0)
+        @current_resource.should_receive(:running).with(true)
+        @provider.load_current_resource
+      end
+
+      it "should run the services status command if one has been specified and properly set status check state" do
+        @provider.stub!(:run_command_with_systems_locale).with({:command => "/bin/chefhasmonkeypants status"}).and_return(0)
+        @provider.load_current_resource
+        @provider.instance_variable_get("@status_check_success").should be_true
+      end
+      
+      it "should set running to false if it catches a Chef::Exceptions::Exec when using a status command" do
+        @provider.stub!(:run_command_with_systems_locale).and_raise(Chef::Exceptions::Exec)
+        @current_resource.should_receive(:running).with(false)
+        @provider.load_current_resource
+      end
+    
+      it "should update state to indicate status check failed when an exception is thrown using a status command" do
+        @provider.stub!(:run_command_with_systems_locale).and_raise(Chef::Exceptions::Exec)
+        @provider.load_current_resource
+        @provider.instance_variable_get("@status_check_success").should be_false
+      end
+    end 
+
+    it "should check if the service is enabled" do
+      @provider.should_receive(:is_enabled?)
+      @provider.load_current_resource
+    end
+
+    it "should set enabled to true if the service is enabled" do
+      @provider.stub!(:is_enabled?).and_return(true)
+      @current_resource.should_receive(:enabled).with(true)
+      @provider.load_current_resource
+    end
+
+    it "should set enabled to false if the service is not enabled" do
+      @provider.stub!(:is_enabled?).and_return(false)
+      @current_resource.should_receive(:enabled).with(false)
+      @provider.load_current_resource
+    end
+
+    it "should return the current resource" do
+      @provider.load_current_resource.should eql(@current_resource)
+    end
+  end
+
+  describe "start and stop service" do
+    before(:each) do
+      @current_resource = Chef::Resource::Service.new('rsyslog.service')
+      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      @provider.current_resource = @current_resource
+    end
+
+    it "should call the start command if one is specified" do
+      @new_resource.stub!(:start_command).and_return("/sbin/rsyslog startyousillysally")
+      @provider.should_receive(:shell_out!).with("/sbin/rsyslog startyousillysally")
+      @provider.start_service
+    end
+
+    it "should call '/bin/systemctl start service_name' if no start command is specified" do
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/bin/systemctl start #{@new_resource.service_name}"}).and_return(0)
+      @provider.start_service
+    end
+
+    it "should not call '/bin/systemctl start service_name' if it is already running" do
+      @current_resource.stub!(:running).and_return(true)
+      @provider.should_not_receive(:run_command_with_systems_locale).with({:command => "/bin/systemctl start #{@new_resource.service_name}"}).and_return(0)
+      @provider.start_service
+    end
+
+    it "should call the restart command if one is specified" do
+      @current_resource.stub!(:running).and_return(true)
+      @new_resource.stub!(:restart_command).and_return("/sbin/rsyslog restartyousillysally")
+      @provider.should_receive(:shell_out!).with("/sbin/rsyslog restartyousillysally")
+      @provider.restart_service
+    end
+
+    it "should call '/bin/systemctl restart service_name' if no restart command is specified" do
+      @current_resource.stub!(:running).and_return(true)
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/bin/systemctl restart #{@new_resource.service_name}"}).and_return(0)
+      @provider.restart_service
+    end
+
+    it "should call the reload command if one is specified" do
+      @current_resource.stub!(:running).and_return(true)
+      @new_resource.stub!(:reload_command).and_return("/sbin/rsyslog reloadyousillysally")
+      @provider.should_receive(:shell_out!).with("/sbin/rsyslog reloadyousillysally")
+      @provider.reload_service
+    end
+
+    it "should call '/bin/systemctl reload service_name' if no reload command is specified" do
+      @current_resource.stub!(:running).and_return(true)
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/bin/systemctl reload #{@new_resource.service_name}"}).and_return(0)
+      @provider.reload_service
+    end
+
+    it "should call the stop command if one is specified" do
+      @current_resource.stub!(:running).and_return(true)
+      @new_resource.stub!(:stop_command).and_return("/sbin/rsyslog stopyousillysally")
+      @provider.should_receive(:shell_out!).with("/sbin/rsyslog stopyousillysally")
+      @provider.stop_service
+    end
+
+    it "should call '/bin/systemctl stop service_name' if no stop command is specified" do
+      @current_resource.stub!(:running).and_return(true)
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/bin/systemctl stop #{@new_resource.service_name}"}).and_return(0)
+      @provider.stop_service
+    end
+
+    it "should not call '/bin/systemctl stop service_name' if it is already stopped" do
+      @current_resource.stub!(:running).and_return(false)
+      @provider.should_not_receive(:run_command_with_systems_locale).with({:command => "/bin/systemctl stop #{@new_resource.service_name}"}).and_return(0)
+      @provider.stop_service
+    end
+  end
+
+  describe "enable and disable service" do
+    before(:each) do
+      @current_resource = Chef::Resource::Service.new('rsyslog.service')
+      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      @provider.current_resource = @current_resource
+    end
+
+    it "should call '/bin/systemctl enable service_name' to enable the service" do
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/bin/systemctl enable #{@new_resource.service_name}"}).and_return(0)
+      @provider.enable_service
+    end
+
+    it "should call '/bin/systemctl disable service_name' to disable the service" do
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/bin/systemctl disable #{@new_resource.service_name}"}).and_return(0)
+      @provider.disable_service
+    end
+  end
+
+  describe "is_active?" do
+    before(:each) do
+      @current_resource = Chef::Resource::Service.new('rsyslog.service')
+      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+    end
+
+    it "should return true if '/bin/systemctl is-active service_name' returns 0" do
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => '/bin/systemctl is-active rsyslog.service', :ignore_failure => true}).and_return(0)
+      @provider.is_active?.should be_true
+    end
+
+    it "should return false if '/bin/systemctl is-active service_name' returns anything except 0" do
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => '/bin/systemctl is-active rsyslog.service', :ignore_failure => true}).and_return(1)
+      @provider.is_active?.should be_false
+    end
+  end
+
+  describe "is_enabled?" do
+    before(:each) do
+      @current_resource = Chef::Resource::Service.new('rsyslog.service')
+      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+    end
+
+    it "should return true if '/bin/systemctl is-enabled service_name' returns 0" do
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => '/bin/systemctl is-enabled rsyslog.service', :ignore_failure => true}).and_return(0)
+      @provider.is_enabled?.should be_true
+    end
+
+    it "should return false if '/bin/systemctl is-enabled service_name' returns anything except 0" do
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => '/bin/systemctl is-enabled rsyslog.service', :ignore_failure => true}).and_return(1)
+      @provider.is_enabled?.should be_false
+    end
+  end
+end

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

@@ -0,0 +1,314 @@
+#
+# Author:: Bryan McLellan (btm@loftninjas.org)
+# Copyright:: Copyright (c) 2010 Bryan McLellan
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+describe Chef::Provider::Service::Upstart do
+  before(:each) do
+    @node =Chef::Node.new
+    @node[:name] = 'upstarter'
+    @node[:platform] = 'ubuntu'
+    @node[:platform_version] = '9.10'
+
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    @new_resource = Chef::Resource::Service.new("rsyslog")
+    @provider = Chef::Provider::Service::Upstart.new(@new_resource, @run_context)
+  end
+
+  describe "when first created" do
+    before do
+      @platform = nil
+    end
+
+    it "should return /etc/event.d as the upstart job directory when running on Ubuntu 9.04" do
+      @node[:platform_version] = '9.04'
+      #Chef::Platform.stub!(:find_platform_and_version).and_return([ "ubuntu", "9.04" ])
+      @provider = Chef::Provider::Service::Upstart.new(@new_resource, @run_context)
+      @provider.instance_variable_get(:@upstart_job_dir).should == "/etc/event.d"
+      @provider.instance_variable_get(:@upstart_conf_suffix).should == ""
+    end
+
+    it "should return /etc/init as the upstart job directory when running on Ubuntu 9.10" do
+      @node[:platform_version] = '9.10'
+      @provider = Chef::Provider::Service::Upstart.new(@new_resource, @run_context)
+      @provider.instance_variable_get(:@upstart_job_dir).should == "/etc/init"
+      @provider.instance_variable_get(:@upstart_conf_suffix).should == ".conf"
+    end
+
+    it "should return /etc/init as the upstart job directory by default" do
+      @node[:platform_version] = '9000'
+      @provider = Chef::Provider::Service::Upstart.new(@new_resource, @run_context)
+      @provider.instance_variable_get(:@upstart_job_dir).should == "/etc/init"
+      @provider.instance_variable_get(:@upstart_conf_suffix).should == ".conf"
+    end
+  end
+
+  describe "load_current_resource" do
+    before(:each) do
+      @node[:command] = {:ps => "ps -ax"}
+
+      @current_resource = Chef::Resource::Service.new("rsyslog")
+      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+
+      @status = mock("Status", :exitstatus => 0)
+      @provider.stub!(:popen4).and_return(@status)
+      @stdin = StringIO.new
+      @stdout = StringIO.new
+      @stderr = StringIO.new
+      @pid = mock("PID")
+      
+      ::File.stub!(:exists?).and_return(true)
+      ::File.stub!(:open).and_return(true)
+    end
+
+    it "should create a current resource with the name of the new resource" do
+      Chef::Resource::Service.should_receive(:new).and_return(@current_resource)
+      @provider.load_current_resource
+    end
+
+    it "should set the current resources service name to the new resources service name" do
+      @current_resource.should_receive(:service_name).with(@new_resource.service_name)
+      @provider.load_current_resource
+    end
+
+    it "should run '/sbin/status rsyslog'" do
+      @provider.should_receive(:popen4).with("/sbin/status rsyslog").and_return(@status)
+      @provider.load_current_resource
+    end
+
+    describe "when the status command uses the new format" do
+      before do
+      end
+
+      it "should set running to true if the the status command returns 0" do
+        @stdout = StringIO.new("rsyslog start/running")
+        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        @provider.load_current_resource
+        @current_resource.running.should be_true
+      end
+
+      it "should set running to false if the status command returns anything except 0" do
+        @stdout = StringIO.new("rsyslog stop/waiting")
+        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        @provider.load_current_resource
+        @current_resource.running.should be_false
+      end
+    end
+
+    describe "when the status command uses the old format" do
+      it "should set running to true if the the status command returns 0" do
+        @stdout = StringIO.new("rsyslog (start) running, process 32225")
+        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        @provider.load_current_resource
+        @current_resource.running.should be_true
+      end
+
+      it "should set running to false if the status command returns anything except 0" do
+        @stdout = StringIO.new("rsyslog (stop) waiting")
+        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        @provider.load_current_resource
+        @current_resource.running.should be_false
+      end
+    end
+
+    it "should set running to false if it catches a Chef::Exceptions::Exec" do
+      @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_raise(Chef::Exceptions::Exec)
+      @current_resource.should_receive(:running).with(false)
+      @provider.load_current_resource
+    end
+
+    it "should set enabled to true when it finds 'starts on'" do
+      @lines = mock("start on filesystem", :gets => "start on filesystem")
+      ::File.stub!(:open).and_yield(@lines)
+      @current_resource.should_receive(:running).with(false)
+      @provider.load_current_resource
+    end
+
+    it "should set enabled to false when it finds '#starts on'" do
+      @lines = mock("start on filesystem", :gets => "#start on filesystem")
+      ::File.stub!(:open).and_yield(@lines)
+      @current_resource.should_receive(:running).with(false)
+      @provider.load_current_resource
+    end
+
+    it "should assume disable when no job configuration file is found" do
+      ::File.stub!(:exists?).and_return(false)
+      @current_resource.should_receive(:running).with(false)
+      @provider.load_current_resource
+    end
+
+
+    it "should track state when the upstart configuration file fails to load" do
+      File.should_receive(:exists?).and_return false
+      @provider.load_current_resource
+      @provider.instance_variable_get("@config_file_found").should == false
+    end
+
+    describe "when a status command has been specified" do
+      before do
+        @new_resource.stub!(:status_command).and_return("/bin/chefhasmonkeypants status")
+      end
+
+      it "should run the services status command if one has been specified" do
+        @provider.stub!(:run_command_with_systems_locale).with({:command => "/bin/chefhasmonkeypants status"}).and_return(0)
+        @current_resource.should_receive(:running).with(true)
+        @provider.load_current_resource
+      end
+
+      it "should track state when the user-provided status command fails" do 
+        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_raise(Chef::Exceptions::Exec)
+        @provider.load_current_resource
+        @provider.instance_variable_get("@command_success").should == false
+      end
+
+      it "should set running to false if it catches a Chef::Exceptions::Exec when using a status command" do
+        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_raise(Chef::Exceptions::Exec)
+        @current_resource.should_receive(:running).with(false)
+        @provider.load_current_resource
+      end
+    end
+
+    it "should track state when we fail to obtain service status via upstart_state" do
+      @provider.should_receive(:upstart_state).and_raise Chef::Exceptions::Exec
+      @provider.load_current_resource
+      @provider.instance_variable_get("@command_success").should == false
+    end
+    
+    it "should return the current resource" do
+      @provider.load_current_resource.should eql(@current_resource)
+    end
+
+
+  end
+
+  describe "enable and disable service" do
+    before(:each) do
+      @current_resource = Chef::Resource::Service.new('rsyslog')
+      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      @provider.current_resource = @current_resource
+      Chef::Util::FileEdit.stub!(:new)
+    end
+
+    it "should enable the service if it is not enabled" do
+      @file = Object.new
+      Chef::Util::FileEdit.stub!(:new).and_return(@file)
+      @current_resource.stub!(:enabled).and_return(false)
+      @file.should_receive(:search_file_replace)
+      @file.should_receive(:write_file)
+      @provider.enable_service()
+    end
+
+    it "should disable the service if it is enabled" do
+      @file = Object.new
+      Chef::Util::FileEdit.stub!(:new).and_return(@file)
+      @current_resource.stub!(:enabled).and_return(true)
+      @file.should_receive(:search_file_replace)
+      @file.should_receive(:write_file)
+      @provider.disable_service()
+    end
+
+  end
+
+  describe "start and stop service" do
+    before(:each) do
+      @current_resource = Chef::Resource::Service.new('rsyslog')
+
+      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      @provider.current_resource = @current_resource
+    end
+
+    it "should call the start command if one is specified" do
+      @new_resource.stub!(:start_command).and_return("/sbin/rsyslog startyousillysally")
+      @provider.should_receive(:shell_out!).with("/sbin/rsyslog startyousillysally")
+      @provider.start_service()
+    end
+
+    it "should call '/sbin/start service_name' if no start command is specified" do
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/sbin/start #{@new_resource.service_name}"}).and_return(0)
+      @provider.start_service()
+    end
+
+    it "should not call '/sbin/start service_name' if it is already running" do
+      @current_resource.stub!(:running).and_return(true)
+      @provider.should_not_receive(:run_command_with_systems_locale).with({:command => "/sbin/start #{@new_resource.service_name}"}).and_return(0)
+      @provider.start_service()
+    end
+
+    it "should pass parameters to the start command if they are provided" do
+      @new_resource = Chef::Resource::Service.new("rsyslog")
+      @new_resource.parameters({ "OSD_ID" => "2" })
+      @provider = Chef::Provider::Service::Upstart.new(@new_resource, @run_context)
+      @provider.current_resource = @current_resource
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/sbin/start rsyslog OSD_ID=2"}).and_return(0)
+      @provider.start_service()
+    end
+
+    it "should call the restart command if one is specified" do
+      @current_resource.stub!(:running).and_return(true)
+      @new_resource.stub!(:restart_command).and_return("/sbin/rsyslog restartyousillysally")
+      @provider.should_receive(:shell_out!).with("/sbin/rsyslog restartyousillysally")
+      @provider.restart_service()
+    end
+
+    it "should call '/sbin/restart service_name' if no restart command is specified" do
+      @current_resource.stub!(:running).and_return(true)
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/sbin/restart #{@new_resource.service_name}"}).and_return(0)
+      @provider.restart_service()
+    end
+
+    it "should call '/sbin/start service_name' if restart_service is called for a stopped service" do
+      @current_resource.stub!(:running).and_return(false)
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/sbin/start #{@new_resource.service_name}"}).and_return(0)
+      @provider.restart_service()
+    end
+
+    it "should call the reload command if one is specified" do
+      @current_resource.stub!(:running).and_return(true)
+      @new_resource.stub!(:reload_command).and_return("/sbin/rsyslog reloadyousillysally")
+      @provider.should_receive(:shell_out!).with("/sbin/rsyslog reloadyousillysally")
+      @provider.reload_service()
+    end
+
+    it "should call '/sbin/reload service_name' if no reload command is specified" do
+      @current_resource.stub!(:running).and_return(true)
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/sbin/reload #{@new_resource.service_name}"}).and_return(0)
+      @provider.reload_service()
+    end
+
+    it "should call the stop command if one is specified" do
+      @current_resource.stub!(:running).and_return(true)
+      @new_resource.stub!(:stop_command).and_return("/sbin/rsyslog stopyousillysally")
+      @provider.should_receive(:shell_out!).with("/sbin/rsyslog stopyousillysally")
+      @provider.stop_service()
+    end
+
+    it "should call '/sbin/stop service_name' if no stop command is specified" do
+      @current_resource.stub!(:running).and_return(true)
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/sbin/stop #{@new_resource.service_name}"}).and_return(0)
+      @provider.stop_service()
+    end
+
+    it "should not call '/sbin/stop service_name' if it is already stopped" do
+      @current_resource.stub!(:running).and_return(false)
+      @provider.should_not_receive(:run_command_with_systems_locale).with({:command => "/sbin/stop #{@new_resource.service_name}"}).and_return(0)
+      @provider.stop_service()
+    end
+  end
+end