diff --git a/lib/puppet/provider/service/init.rb b/lib/puppet/provider/service/init.rb
index 2a54db24f..902cb18c6 100755
--- a/lib/puppet/provider/service/init.rb
+++ b/lib/puppet/provider/service/init.rb
@@ -1,136 +1,134 @@
 # The standard init-based service type.  Many other service types are
 # customizations of this module.
 Puppet::Type.type(:service).provide :init, :parent => :base do
   desc "Standard `init`-style service management."
 
-  class << self
-    attr_accessor :defpath
-  end
-
-  case Facter["operatingsystem"].value
-  when "FreeBSD"
-    @defpath = ["/etc/rc.d", "/usr/local/etc/rc.d"]
-  when "HP-UX"
-    @defpath = "/sbin/init.d"
-  when "Archlinux"
-    @defpath = "/etc/rc.d"
-  else
-    @defpath = "/etc/init.d"
+  def self.defpath
+    case Facter.value(:operatingsystem)
+    when "FreeBSD"
+      ["/etc/rc.d", "/usr/local/etc/rc.d"]
+    when "HP-UX"
+      "/sbin/init.d"
+    when "Archlinux"
+      "/etc/rc.d"
+    else
+      "/etc/init.d"
+    end
   end
 
   # We can't confine this here, because the init path can be overridden.
-  #confine :exists => @defpath
+  #confine :exists => defpath
 
   # List all services of this type.
   def self.instances
     get_services(self.defpath)
   end
 
   def self.get_services(defpath, exclude=[])
     defpath = [defpath] unless defpath.is_a? Array
     instances = []
     defpath.each do |path|
       unless FileTest.directory?(path)
         Puppet.debug "Service path #{path} does not exist"
         next
       end
 
       check = [:ensure]
 
       check << :enable if public_method_defined? :enabled?
 
       Dir.entries(path).each do |name|
         fullpath = File.join(path, name)
         next if name =~ /^\./
         next if exclude.include? name
         next if not FileTest.executable?(fullpath)
         instances << new(:name => name, :path => path, :hasstatus => true)
       end
     end
     instances
   end
 
   # Mark that our init script supports 'status' commands.
   def hasstatus=(value)
     case value
     when true, "true"; @parameters[:hasstatus] = true
     when false, "false"; @parameters[:hasstatus] = false
     else
       raise Puppet::Error, "Invalid 'hasstatus' value #{value.inspect}"
     end
   end
 
   # Where is our init script?
   def initscript
     @initscript ||= self.search(@resource[:name])
   end
 
   def paths
     @paths ||= @resource[:path].find_all do |path|
       if File.directory?(path)
         true
       else
         if File.exist?(path) and ! File.directory?(path)
           self.debug "Search path #{path} is not a directory"
         else
           self.debug "Search path #{path} does not exist"
         end
         false
       end
     end
   end
 
   def search(name)
     paths.each { |path|
       fqname = File.join(path,name)
       begin
         stat = File.stat(fqname)
       rescue
         # should probably rescue specific errors...
         self.debug("Could not find #{name} in #{path}")
         next
       end
 
       # if we've gotten this far, we found a valid script
       return fqname
     }
 
     paths.each { |path|
       fqname_sh = File.join(path,"#{name}.sh")
       begin
         stat = File.stat(fqname_sh)
       rescue
         # should probably rescue specific errors...
         self.debug("Could not find #{name}.sh in #{path}")
         next
       end
 
       # if we've gotten this far, we found a valid script
       return fqname_sh
     }
     raise Puppet::Error, "Could not find init script for '#{name}'"
   end
 
   # The start command is just the init scriptwith 'start'.
   def startcmd
     [initscript, :start]
   end
 
   # The stop command is just the init script with 'stop'.
   def stopcmd
     [initscript, :stop]
   end
 
   def restartcmd
     (@resource[:hasrestart] == :true) && [initscript, :restart]
   end
 
   # If it was specified that the init script has a 'status' command, then
   # we just return that; otherwise, we return false, which causes it to
   # fallback to other mechanisms.
   def statuscmd
     (@resource[:hasstatus] == :true) && [initscript, :status]
   end
 
 end
 
diff --git a/spec/integration/provider/service/init_spec.rb b/spec/integration/provider/service/init_spec.rb
index 483507d5f..877c01171 100755
--- a/spec/integration/provider/service/init_spec.rb
+++ b/spec/integration/provider/service/init_spec.rb
@@ -1,30 +1,46 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 provider = Puppet::Type.type(:service).provider(:init)
 
 describe provider, :'fails_on_ruby_1.9.2' => true do
-  describe "when running on FreeBSD", :if => (Facter.value(:operatingsystem) == "FreeBSD") do
+  describe "when running on FreeBSD" do
+    before :each do
+      Facter.stubs(:value).with(:operatingsystem).returns 'FreeBSD'
+    end
+
     it "should set its default path to include /etc/rc.d and /usr/local/etc/rc.d" do
       provider.defpath.should == ["/etc/rc.d", "/usr/local/etc/rc.d"]
     end
   end
 
-  describe "when running on HP-UX", :if => (Facter.value(:operatingsystem) == "HP-UX") do
+  describe "when running on HP-UX" do
+    before :each do
+      Facter.stubs(:value).with(:operatingsystem).returns 'HP-UX'
+    end
+
     it "should set its default path to include /sbin/init.d" do
       provider.defpath.should == "/sbin/init.d"
     end
   end
 
-  describe "when running on Archlinux", :if => (Facter.value(:operatingsystem) == "Archlinux") do
+  describe "when running on Archlinux" do
+    before :each do
+      Facter.stubs(:value).with(:operatingsystem).returns 'Archlinux'
+    end
+
     it "should set its default path to include /etc/rc.d" do
       provider.defpath.should == "/etc/rc.d"
     end
   end
 
-  describe "when not running on FreeBSD, HP-UX or Archlinux", :if => (! %w{HP-UX FreeBSD Archlinux}.include?(Facter.value(:operatingsystem))) do
+  describe "when not running on FreeBSD, HP-UX or Archlinux" do
+    before :each do
+      Facter.stubs(:value).with(:operatingsystem).returns 'RedHat'
+    end
+
     it "should set its default path to include /etc/init.d" do
       provider.defpath.should == "/etc/init.d"
     end
   end
 end
diff --git a/spec/unit/provider/service/init_spec.rb b/spec/unit/provider/service/init_spec.rb
index 8374594e7..173fb8515 100755
--- a/spec/unit/provider/service/init_spec.rb
+++ b/spec/unit/provider/service/init_spec.rb
@@ -1,170 +1,170 @@
 #!/usr/bin/env rspec
 #
 # Unit testing for the Init service Provider
 #
 
 require 'spec_helper'
 
 provider_class = Puppet::Type.type(:service).provider(:init)
 
 describe provider_class do
 
   before :each do
     @class = Puppet::Type.type(:service).provider(:init)
     @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 getting all service instances" do
     before :each do
       @services = ['one', 'two', 'three', 'four']
       Dir.stubs(:entries).returns @services
       FileTest.stubs(:directory?).returns(true)
       FileTest.stubs(:executable?).returns(true)
       @class.stubs(:defpath).returns('tmp')
     end
     it "should return instances for all services" do
       @services.each do |inst|
         @class.expects(:new).with{|hash| hash[:name] == inst}.returns("#{inst}_instance")
       end
       results = @services.collect {|x| "#{x}_instance"}
       @class.instances.should == results
     end
     it "should omit an array of services from exclude list" do
       exclude = ['two', 'four']
       (@services-exclude).each do |inst|
         @class.expects(:new).with{|hash| hash[:name] == inst}.returns("#{inst}_instance")
       end
       results = (@services-exclude).collect {|x| "#{x}_instance"}
       @class.get_services(@class.defpath, exclude).should == results
     end
-    it "should omit a single service from the exclude list", :'fails_on_ruby_1.9.2' => true do
+    it "should omit a single service from the exclude list" do
       exclude = 'two'
-      (@services-exclude.to_a).each do |inst|
+      (@services-[exclude]).each do |inst|
         @class.expects(:new).with{|hash| hash[:name] == inst}.returns("#{inst}_instance")
       end
       results = @services.reject{|x| x==exclude }.collect {|x| "#{x}_instance"}
       @class.get_services(@class.defpath, exclude).should == results
     end
     it "should use defpath" do
       @services.each do |inst|
         @class.expects(:new).with{|hash| hash[:path] == @class.defpath}.returns("#{inst}_instance")
       end
       results = @services.sort.collect {|x| "#{x}_instance"}
       @class.instances.sort.should == results
     end
     it "should set hasstatus to true for providers" do
       @services.each do |inst|
         @class.expects(:new).with{|hash| hash[:name] == inst && hash[:hasstatus] == true}.returns("#{inst}_instance")
       end
       results = @services.collect {|x| "#{x}_instance"}
       @class.instances.should == results
     end
   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.stubs(:stat).raises(Errno::ENOENT.new('No such file or directory'))
       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.stubs(:stat).raises(Errno::ENOENT.new('No such file or directory'))
       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("")
           $CHILD_STATUS.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("")
             $CHILD_STATUS.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("")
         $CHILD_STATUS.stubs(:exitstatus).returns(0)
         @provider.restart
       end
     end
 
   end
 end