chef 10.28.2-x86-mingw32

data/spec/unit/provider/route_spec.rb

@@ -0,0 +1,226 @@
+#
+# Author:: Bryan McLellan (btm@loftninjas.org)
+# Copyright:: Copyright (c) 2009 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::Route do
+  before do
+    @node = Chef::Node.new
+    @cookbook_collection = Chef::CookbookCollection.new([])
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, @cookbook_collection, @events)
+
+    @new_resource = Chef::Resource::Route.new('10.0.0.10')
+    @new_resource.gateway "10.0.0.9"
+    @current_resource = Chef::Resource::Route.new('10.0.0.10')
+    @current_resource.gateway "10.0.0.9"
+
+    @provider = Chef::Provider::Route.new(@new_resource, @run_context)
+    @provider.current_resource = @current_resource
+  end
+
+  describe Chef::Provider::Route, "hex2ip" do
+    it "should return nil if ip address is invalid" do
+      @provider.hex2ip('foo').should be_nil # does not even look like an ip
+      @provider.hex2ip('ABCDEFGH').should be_nil # 8 chars, but invalid
+    end
+
+    it "should return quad-dotted notation for a valid IP" do
+      @provider.hex2ip('01234567').should == '103.69.35.1'
+      @provider.hex2ip('0064a8c0').should == '192.168.100.0'
+      @provider.hex2ip('00FFFFFF').should == '255.255.255.0'
+    end
+  end
+
+
+  describe Chef::Provider::Route, "load_current_resource" do
+    context "on linux" do
+      before do
+        @node[:os] = 'linux'
+        routing_table = "Iface	Destination	Gateway 	Flags	RefCnt	Use	Metric	Mask		MTU	Window	IRTT\n" +
+                        "eth0	0064A8C0	0984A8C0	0003	0	0	0	00FFFFFF	0	0	0\n"
+        route_file = StringIO.new(routing_table)
+        File.stub!(:open).with("/proc/net/route", "r").and_return(route_file)
+      end
+
+      it "should set is_running to false when a route is not detected" do
+        resource = Chef::Resource::Route.new('10.10.10.0/24')
+        resource.stub!(:gateway).and_return("10.0.0.1")
+        resource.stub!(:device).and_return("eth0")
+        provider = Chef::Provider::Route.new(resource, @run_context)
+
+        provider.load_current_resource
+        provider.is_running.should be_false
+      end
+
+      it "should detect existing routes and set is_running attribute correctly" do
+        resource = Chef::Resource::Route.new('192.168.100.0/24')
+        resource.stub!(:gateway).and_return("192.168.132.9")
+        resource.stub!(:device).and_return("eth0")
+        provider = Chef::Provider::Route.new(resource, @run_context)
+
+        provider.load_current_resource
+        provider.is_running.should be_true
+      end
+
+      it "should use gateway value when matching routes" do
+        resource = Chef::Resource::Route.new('192.168.100.0/24')
+        resource.stub!(:gateway).and_return("10.10.10.10")
+        resource.stub!(:device).and_return("eth0")
+        provider = Chef::Provider::Route.new(resource, @run_context)
+
+        provider.load_current_resource
+        provider.is_running.should be_false
+      end
+    end
+  end
+
+  describe Chef::Provider::Route, "action_add" do
+    it "should add the route if it does not exist" do
+      @provider.stub!(:run_command).and_return(true)
+      @current_resource.stub!(:gateway).and_return(nil)
+      @provider.should_receive(:generate_command).once.with(:add)
+      @provider.should_receive(:generate_config)
+      @provider.run_action(:add)
+      @new_resource.should be_updated
+    end
+
+    it "should not add the route if it exists" do
+      @provider.stub!(:run_command).and_return(true)
+      @provider.stub!(:is_running).and_return(true)
+      @provider.should_not_receive(:generate_command).with(:add)
+      @provider.should_receive(:generate_config)
+      @provider.run_action(:add)
+      @new_resource.should_not be_updated
+    end
+  end
+
+  describe Chef::Provider::Route, "action_delete" do
+    it "should delete the route if it exists" do
+      @provider.stub!(:run_command).and_return(true)
+      @provider.should_receive(:generate_command).once.with(:delete)
+      @provider.stub!(:is_running).and_return(true)
+      @provider.run_action(:delete)
+      @new_resource.should be_updated
+    end
+
+    it "should not delete the route if it does not exist" do
+      @current_resource.stub!(:gateway).and_return(nil)
+      @provider.stub!(:run_command).and_return(true)
+      @provider.should_not_receive(:generate_command).with(:add)
+      @provider.run_action(:delete)
+      @new_resource.should_not be_updated
+    end
+  end
+
+  describe Chef::Provider::Route, "generate_command for action_add" do
+    it "should include a netmask when a one is specified" do
+      @new_resource.stub!(:netmask).and_return('255.255.0.0')
+      @provider.generate_command(:add).should match(/\/\d{1,2}\s/)
+    end
+
+    it "should not include a netmask when a one is specified" do
+      @new_resource.stub!(:netmask).and_return(nil)
+      @provider.generate_command(:add).should_not match(/\/\d{1,2}\s/)
+    end
+
+    it "should include ' via $gateway ' when a gateway is specified" do
+      @provider.generate_command(:add).should match(/\svia\s#{@new_resource.gateway}\s/)
+    end
+
+    it "should not include ' via $gateway ' when a gateway is not specified" do
+      @new_resource.stub!(:gateway).and_return(nil)
+      @provider.generate_command(:add).should_not match(/\svia\s#{@new_resource.gateway}\s/)
+    end
+  end
+
+  describe Chef::Provider::Route, "generate_command for action_delete" do
+    it "should include a netmask when a one is specified" do
+      @new_resource.stub!(:netmask).and_return('255.255.0.0')
+      @provider.generate_command(:delete).should match(/\/\d{1,2}\s/)
+    end
+
+    it "should not include a netmask when a one is specified" do
+      @new_resource.stub!(:netmask).and_return(nil)
+      @provider.generate_command(:delete).should_not match(/\/\d{1,2}\s/)
+    end
+
+    it "should include ' via $gateway ' when a gateway is specified" do
+      @provider.generate_command(:delete).should match(/\svia\s#{@new_resource.gateway}\s/)
+    end
+
+    it "should not include ' via $gateway ' when a gateway is not specified" do
+      @new_resource.stub!(:gateway).and_return(nil)
+      @provider.generate_command(:delete).should_not match(/\svia\s#{@new_resource.gateway}\s/)
+    end
+  end
+
+  describe Chef::Provider::Route, "config_file_contents for action_add" do
+    it "should include a netmask when a one is specified" do
+      @new_resource.stub!(:netmask).and_return('255.255.0.0')
+      @provider.config_file_contents(:add, { :target => @new_resource.target, :netmask => @new_resource.netmask}).should match(/\/\d{1,2}.*\n$/)
+    end
+
+    it "should not include a netmask when a one is specified" do
+      @provider.config_file_contents(:add, { :target => @new_resource.target}).should_not match(/\/\d{1,2}.*\n$/)
+    end
+
+    it "should include ' via $gateway ' when a gateway is specified" do
+      @provider.config_file_contents(:add, { :target => @new_resource.target, :gateway => @new_resource.gateway}).should match(/\svia\s#{@new_resource.gateway}\n/)
+    end
+
+    it "should not include ' via $gateway ' when a gateway is not specified" do
+      @provider.generate_command(:add).should_not match(/\svia\s#{@new_resource.gateway}\n/)
+    end
+  end
+
+  describe Chef::Provider::Route, "config_file_contents for action_delete" do
+    it "should return an empty string" do
+      @provider.config_file_contents(:delete).should match(/^$/)
+    end
+  end
+
+  describe Chef::Provider::Route, "generate_config method" do
+    %w[ centos redhat fedora ].each do |platform|
+      it "should write a route file on #{platform} platform" do
+        @node[:platform] = platform
+
+        route_file = StringIO.new
+        File.should_receive(:new).with("/etc/sysconfig/network-scripts/route-eth0", "w").and_return(route_file)
+        #Chef::Log.should_receive(:debug).with("route[10.0.0.10] writing route.eth0\n10.0.0.10 via 10.0.0.9\n")
+        @run_context.resource_collection << @new_resource
+        @provider.generate_config
+      end
+    end
+
+    it "should put all routes for a device in a route config file" do
+      @node[:platform] = 'centos'
+      route_file = StringIO.new
+      File.should_receive(:new).and_return(route_file)
+      @run_context.resource_collection << Chef::Resource::Route.new('192.168.1.0/24 via 192.168.0.1')
+      @run_context.resource_collection << Chef::Resource::Route.new('192.168.2.0/24 via 192.168.0.1')
+      @run_context.resource_collection << Chef::Resource::Route.new('192.168.3.0/24 via 192.168.0.1')
+
+      @provider.generate_config
+      route_file.string.split("\n").should have(3).items
+      route_file.string.should match(/^192.168.1.0\/24 via 192.168.0.1$/)
+      route_file.string.should match(/^192.168.2.0\/24 via 192.168.0.1$/)
+      route_file.string.should match(/^192.168.3.0\/24 via 192.168.0.1$/)
+    end
+  end
+end

data/spec/unit/provider/ruby_block_spec.rb

@@ -0,0 +1,38 @@
+#
+# Author:: AJ Christensen (<aj@opscode.com>)
+# Copyright:: Copyright (c) 2009 Opscode
+# 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::RubyBlock, "initialize" do
+  before(:each) do
+    $evil_global_evil_laugh = :wahwah
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::RubyBlock.new("bloc party")
+    @new_resource.block { $evil_global_evil_laugh = :mwahahaha}
+    @provider = Chef::Provider::RubyBlock.new(@new_resource, @run_context)
+  end
+
+  it "should call the block and flag the resource as updated" do
+    @provider.run_action(:create)
+    $evil_global_evil_laugh.should == :mwahahaha
+    @new_resource.should be_updated
+  end
+end
+

data/spec/unit/provider/script_spec.rb

@@ -0,0 +1,96 @@
+#
+# Author:: Adam Jacob (adam@opscode.com)
+# Copyright:: Copyright (c) 2009 Opscode
+# 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::Script, "action_run" do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Script.new('run some perl code')
+    @new_resource.code "$| = 1; print 'i like beans'"
+    @new_resource.interpreter 'perl'
+
+    @provider = Chef::Provider::Script.new(@new_resource, @run_context)
+
+    @script_file = StringIO.new
+    @script_file.stub!(:path).and_return('/tmp/the_script_file')
+
+    @provider.stub!(:shell_out!).and_return(true)
+  end
+
+  it "creates a temporary file to store the script" do
+    @provider.script_file.should be_an_instance_of(Tempfile)
+  end
+
+  it "unlinks the tempfile when finished" do
+    tempfile_path = @provider.script_file.path
+    @provider.unlink_script_file
+    File.exist?(tempfile_path).should be_false
+  end
+
+  it "sets the owner and group for the script file" do
+    @new_resource.user 'toor'
+    @new_resource.group 'wheel'
+    @provider.stub!(:script_file).and_return(@script_file)
+    FileUtils.should_receive(:chown).with('toor', 'wheel', "/tmp/the_script_file")
+    @provider.set_owner_and_group
+  end
+
+  context "with the script file set to the correct owner and group" do
+    before do
+      @provider.stub!(:set_owner_and_group)
+      @provider.stub!(:script_file).and_return(@script_file)
+    end
+    describe "when writing the script to the file" do
+      it "should put the contents of the script in the temp file" do
+        @provider.action_run
+        @script_file.rewind
+        @script_file.string.should == "$| = 1; print 'i like beans'\n"
+      end
+
+      it "closes before executing the script and unlinks it when finished" do
+        @provider.action_run
+        @script_file.should be_closed
+      end
+
+    end
+
+    describe "when running the script" do
+      it 'should set the command to "interpreter"  "tempfile"' do
+        @provider.action_run
+        @new_resource.command.should == '"perl"  "/tmp/the_script_file"'
+      end
+
+      describe "with flags set on the resource" do
+        before do
+          @new_resource.flags '-f'
+        end
+
+        it "should set the command to 'interpreter flags tempfile'" do
+          @provider.action_run
+          @new_resource.command.should == '"perl" -f "/tmp/the_script_file"'
+        end
+
+      end
+
+    end
+  end
+
+end

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

@@ -0,0 +1,330 @@
+#
+# Author:: Jan Zimmek (<jan.zimmek@web.de>)
+# Author:: AJ Christensen (<aj@hjksolutions.com>)
+# Copyright:: Copyright (c) 2008 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'
+require 'ostruct'
+
+
+# most of this code has been ripped from init_service_spec.rb
+# and is only slightly modified to match "arch" needs.
+
+describe Chef::Provider::Service::Arch, "load_current_resource" do
+  before(:each) do
+    @node = Chef::Node.new
+    @node[:command] = {:ps => "ps -ef"}
+
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    @new_resource = Chef::Resource::Service.new("chef")
+    @new_resource.pattern("chef")
+    @new_resource.supports({:status => false})
+
+
+    @provider = Chef::Provider::Service::Arch.new(@new_resource, @run_context)
+
+    ::File.stub!(:exists?).with("/etc/rc.conf").and_return(true)
+    ::File.stub!(:read).with("/etc/rc.conf").and_return("DAEMONS=(network apache sshd)")
+  end
+
+  describe "when first created" do
+    it "should set the current resources service name to the new resources service name" do
+      @provider.stub(:shell_out).and_return(OpenStruct.new(:exitstatus => 0, :stdout => ""))
+      @provider.load_current_resource
+      @provider.current_resource.service_name.should == 'chef'
+    end
+  end
+
+
+  describe "when the service supports status" do
+    before do
+      @new_resource.supports({:status => true})
+    end
+
+    it "should run '/etc/rc.d/service_name status'" do
+      @provider.should_receive(:shell_out).with("/etc/rc.d/chef status").and_return(OpenStruct.new(:exitstatus => 0))
+      @provider.load_current_resource
+    end
+  
+    it "should set running to true if the status command returns 0" do
+      @provider.stub!(:shell_out).with("/etc/rc.d/chef status").and_return(OpenStruct.new(:exitstatus => 0))
+      @provider.load_current_resource
+      @provider.current_resource.running.should be_true
+    end
+
+    it "should set running to false if the status command returns anything except 0" do
+      @provider.stub!(:shell_out).with("/etc/rc.d/chef status").and_return(OpenStruct.new(:exitstatus => 1))
+      @provider.load_current_resource
+      @provider.current_resource.running.should be_false
+    end
+
+    it "should set running to false if the status command raises" do
+      @provider.stub!(:shell_out).with("/etc/rc.d/chef status").and_raise(Mixlib::ShellOut::ShellCommandFailed)
+      @provider.load_current_resource
+      @provider.current_resource.running.should be_false
+    end
+
+  end
+
+
+  describe "when a status command has been specified" do
+    before do
+      @new_resource.status_command("/etc/rc.d/chefhasmonkeypants status")
+    end
+
+    it "should run the services status command if one has been specified" do
+      @provider.should_receive(:shell_out).with("/etc/rc.d/chefhasmonkeypants status").and_return(OpenStruct.new(:exitstatus => 0))
+      @provider.load_current_resource
+    end
+    
+  end
+
+  it "should raise error if the node has a nil ps attribute and no other means to get status" do
+    @node[:command] = {:ps => nil}
+    @provider.define_resource_requirements
+    @provider.action = :start
+    lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+  end
+
+  it "should raise error if the node has an empty ps attribute and no other means to get status" do
+    @node[:command] = {:ps => ""}
+    @provider.define_resource_requirements
+    @provider.action = :start
+    lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+  end
+
+
+  it "should fail if file /etc/rc.conf does not exist" do
+    ::File.stub!(:exists?).with("/etc/rc.conf").and_return(false)
+    lambda { @provider.load_current_resource }.should raise_error(Chef::Exceptions::Service)
+  end
+
+  it "should fail if file /etc/rc.conf does not contain DAEMONS array" do
+    ::File.stub!(:read).with("/etc/rc.conf").and_return("")
+    lambda { @provider.load_current_resource }.should raise_error(Chef::Exceptions::Service)
+  end
+
+  describe "when discovering service status with ps" do
+    before do
+      @stdout = StringIO.new(<<-DEFAULT_PS)
+aj        7842  5057  0 21:26 pts/2    00:00:06 vi init.rb
+aj        7903  5016  0 21:26 pts/5    00:00:00 /bin/bash
+aj        8119  6041  0 21:34 pts/3    00:00:03 vi init_service_spec.rb
+DEFAULT_PS
+      @status = mock("Status", :exitstatus => 0, :stdout => @stdout)
+      @provider.stub!(:shell_out!).and_return(@status)
+      
+      @node[:command] = {:ps => "ps -ef"}
+    end
+
+    it "determines the service is running when it appears in ps" do
+      @stdout = StringIO.new(<<-RUNNING_PS)
+aj        7842  5057  0 21:26 pts/2    00:00:06 chef
+aj        7842  5057  0 21:26 pts/2    00:00:06 poos
+RUNNING_PS
+      @status.stub!(:stdout).and_return(@stdout)
+      @provider.load_current_resource 
+      @provider.current_resource.running.should be_true
+    end
+
+    it "determines the service is not running when it does not appear in ps" do
+      @provider.stub!(:shell_out!).and_return(@status)
+      @provider.load_current_resource
+      @provider.current_resource.running.should be_false
+    end
+
+    it "should raise an exception if ps fails" do
+      @provider.stub!(:shell_out!).and_raise(Mixlib::ShellOut::ShellCommandFailed)
+      @provider.load_current_resource
+      @provider.action = :start
+      @provider.define_resource_requirements
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+    end
+  end
+
+  it "should return existing entries in DAEMONS array" do
+    ::File.stub!(:read).with("/etc/rc.conf").and_return("DAEMONS=(network !apache ssh)")
+    @provider.daemons.should == ['network', '!apache', 'ssh']
+  end
+  
+  context "when the current service status is known" do
+    before do
+      @current_resource = Chef::Resource::Service.new("chef")
+      @provider.current_resource = @current_resource
+    end
+    
+    describe Chef::Provider::Service::Arch, "enable_service" do
+      # before(:each) do
+      #   @new_resource = mock("Chef::Resource::Service",
+      #     :null_object => true,
+      #     :name => "chef",
+      #     :service_name => "chef",
+      #     :running => false
+      #   )
+      #   @new_resource.stub!(:start_command).and_return(false)
+      # 
+      #   @provider = Chef::Provider::Service::Arch.new(@node, @new_resource)
+      #   Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      # end
+
+      it "should add chef to DAEMONS array" do
+        ::File.stub!(:read).with("/etc/rc.conf").and_return("DAEMONS=(network)")
+        @provider.should_receive(:update_daemons).with(['network', 'chef'])
+        @provider.enable_service()
+      end
+    end
+
+    describe Chef::Provider::Service::Arch, "disable_service" do
+      # before(:each) do
+      #   @new_resource = mock("Chef::Resource::Service",
+      #     :null_object => true,
+      #     :name => "chef",
+      #     :service_name => "chef",
+      #     :running => false
+      #   )
+      #   @new_resource.stub!(:start_command).and_return(false)
+      # 
+      #   @provider = Chef::Provider::Service::Arch.new(@node, @new_resource)
+      #   Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      # end
+
+      it "should remove chef from DAEMONS array" do
+        ::File.stub!(:read).with("/etc/rc.conf").and_return("DAEMONS=(network chef)")
+        @provider.should_receive(:update_daemons).with(['network', '!chef'])
+        @provider.disable_service()
+      end
+    end
+
+
+    describe Chef::Provider::Service::Arch, "start_service" do
+      # before(:each) do
+      #   @new_resource = mock("Chef::Resource::Service",
+      #     :null_object => true,
+      #     :name => "chef",
+      #     :service_name => "chef",
+      #     :running => false
+      #   )
+      #   @new_resource.stub!(:start_command).and_return(false)
+      # 
+      #   @provider = Chef::Provider::Service::Arch.new(@node, @new_resource)
+      #   Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      # end
+  
+      it "should call the start command if one is specified" do
+        @new_resource.stub!(:start_command).and_return("/etc/rc.d/chef startyousillysally")
+        @provider.should_receive(:shell_out!).with("/etc/rc.d/chef startyousillysally")
+        @provider.start_service()
+      end
+
+      it "should call '/etc/rc.d/service_name start' if no start command is specified" do
+        @provider.should_receive(:shell_out!).with("/etc/rc.d/#{@new_resource.service_name} start")
+        @provider.start_service()
+      end 
+    end
+
+    describe Chef::Provider::Service::Arch, "stop_service" do
+      # before(:each) do
+      #   @new_resource = mock("Chef::Resource::Service",
+      #     :null_object => true,
+      #     :name => "chef",
+      #     :service_name => "chef",
+      #     :running => false
+      #   )
+      #   @new_resource.stub!(:stop_command).and_return(false)
+      # 
+      #   @provider = Chef::Provider::Service::Arch.new(@node, @new_resource)
+      #   Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      # end
+
+      it "should call the stop command if one is specified" do
+        @new_resource.stub!(:stop_command).and_return("/etc/rc.d/chef itoldyoutostop")
+        @provider.should_receive(:shell_out!).with("/etc/rc.d/chef itoldyoutostop")
+        @provider.stop_service()
+      end
+
+      it "should call '/etc/rc.d/service_name stop' if no stop command is specified" do
+        @provider.should_receive(:shell_out!).with("/etc/rc.d/#{@new_resource.service_name} stop")
+        @provider.stop_service()
+      end
+    end
+
+    describe Chef::Provider::Service::Arch, "restart_service" do
+      # before(:each) do
+      #   @new_resource = mock("Chef::Resource::Service",
+      #     :null_object => true,
+      #     :name => "chef",
+      #     :service_name => "chef",
+      #     :running => false
+      #   )
+      #   @new_resource.stub!(:restart_command).and_return(false)
+      #   @new_resource.stub!(:supports).and_return({:restart => false})
+      # 
+      #   @provider = Chef::Provider::Service::Arch.new(@node, @new_resource)
+      #   Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      # end
+
+      it "should call 'restart' on the service_name if the resource supports it" do
+        @new_resource.stub!(:supports).and_return({:restart => true})
+        @provider.should_receive(:shell_out!).with("/etc/rc.d/#{@new_resource.service_name} restart")
+        @provider.restart_service()
+      end
+
+      it "should call the restart_command if one has been specified" do
+        @new_resource.stub!(:restart_command).and_return("/etc/rc.d/chef restartinafire")
+        @provider.should_receive(:shell_out!).with("/etc/rc.d/#{@new_resource.service_name} restartinafire")
+        @provider.restart_service()
+      end
+
+      it "should just call stop, then start when the resource doesn't support restart and no restart_command is specified" do
+        @provider.should_receive(:stop_service)
+        @provider.should_receive(:sleep).with(1)
+        @provider.should_receive(:start_service)
+        @provider.restart_service()
+      end
+    end
+
+    describe Chef::Provider::Service::Arch, "reload_service" do
+      # before(:each) do
+      #   @new_resource = mock("Chef::Resource::Service",
+      #     :null_object => true,
+      #     :name => "chef",
+      #     :service_name => "chef",
+      #     :running => false
+      #   )
+      #   @new_resource.stub!(:reload_command).and_return(false)
+      #   @new_resource.stub!(:supports).and_return({:reload => false})
+      # 
+      #   @provider = Chef::Provider::Service::Arch.new(@node, @new_resource)
+      #   Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      # end
+
+      it "should call 'reload' on the service if it supports it" do
+        @new_resource.stub!(:supports).and_return({:reload => true})
+        @provider.should_receive(:shell_out!).with("/etc/rc.d/#{@new_resource.service_name} reload")
+        @provider.reload_service()
+      end
+
+      it "should should run the user specified reload command if one is specified and the service doesn't support reload" do
+        @new_resource.stub!(:reload_command).and_return("/etc/rc.d/chef lollerpants")
+        @provider.should_receive(:shell_out!).with("/etc/rc.d/#{@new_resource.service_name} lollerpants")
+        @provider.reload_service()
+      end
+    end
+  end
+end