diff --git a/lib/puppet/provider/package/up2date.rb b/lib/puppet/provider/package/up2date.rb
index 7c3ad5cd1..ed358105c 100644
--- a/lib/puppet/provider/package/up2date.rb
+++ b/lib/puppet/provider/package/up2date.rb
@@ -1,40 +1,41 @@
 Puppet::Type.type(:package).provide :up2date, :parent => :rpm, :source => :rpm do
   desc "Support for Red Hat's proprietary `up2date` package update
     mechanism."
 
   commands :up2date => "/usr/sbin/up2date-nox"
 
-  defaultfor :osfamily => :redhat, :lsbdistrelease => ["2.1", "3", "4"]
+  defaultfor :operatingsystem => [:redhat, :oel, :ovm],
+    :lsbdistrelease => ["2.1", "3", "4"]
 
-  confine    :osfamily => :redhat
+  confine    :operatingsystem => [:redhat, :oel, :ovm]
 
   # Install a package using 'up2date'.
   def install
     up2date "-u", @resource[:name]
 
     unless self.query
       raise Puppet::ExecutionFailure.new(
         "Could not find package #{self.name}"
       )
     end
   end
 
   # What's the latest package version available?
   def latest
     #up2date can only get a list of *all* available packages?
     output = up2date "--showall"
 
     if output =~ /^#{Regexp.escape @resource[:name]}-(\d+.*)\.\w+/
       return $1
     else
       # up2date didn't find updates, pretend the current
       # version is the latest
       return @property_hash[:ensure]
     end
   end
 
   def update
     # Install in up2date can be used for update, too
     self.install
   end
 end
diff --git a/lib/puppet/provider/service/redhat.rb b/lib/puppet/provider/service/redhat.rb
index df59d368e..b600e1b2e 100755
--- a/lib/puppet/provider/service/redhat.rb
+++ b/lib/puppet/provider/service/redhat.rb
@@ -1,75 +1,75 @@
 # Manage Red Hat services.  Start/stop uses /sbin/service and enable/disable uses chkconfig
 
 Puppet::Type.type(:service).provide :redhat, :parent => :init, :source => :init do
   desc "Red Hat's (and probably many others') form of `init`-style service
     management. Uses `chkconfig` for service enabling and disabling.
 
   "
 
   commands :chkconfig => "/sbin/chkconfig", :service => "/sbin/service"
 
-  defaultfor :osfamily => [:redhat, :suse]
+  defaultfor :operatingsystem => [:redhat, :fedora, :suse, :centos, :sles, :oel, :ovm]
 
   def self.instances
     # this exclude list is all from /sbin/service (5.x), but I did not exclude kudzu
     self.get_services(['/etc/init.d'], ['functions', 'halt', 'killall', 'single', 'linuxconf'])
   end
 
   def self.defpath
     superclass.defpath
   end
 
   # Remove the symlinks
   def disable
       output = chkconfig(@resource[:name], :off)
   rescue Puppet::ExecutionFailure
       raise Puppet::Error, "Could not disable #{self.name}: #{output}"
   end
 
   def enabled?
     begin
       output = chkconfig(@resource[:name])
     rescue Puppet::ExecutionFailure
       return :false
     end
 
     # If it's disabled on SuSE, then it will print output showing "off"
     # at the end
     if output =~ /.* off$/
       return :false
     end
 
     :true
   end
 
   # Don't support them specifying runlevels; always use the runlevels
   # in the init scripts.
   def enable
       output = chkconfig(@resource[:name], :on)
   rescue Puppet::ExecutionFailure => detail
       raise Puppet::Error, "Could not enable #{self.name}: #{detail}"
   end
 
   def initscript
     raise Puppet::Error, "Do not directly call the init script for '#{@resource[:name]}'; use 'service' instead"
   end
 
   # use hasstatus=>true when its set for the provider.
   def statuscmd
     ((@resource.provider.get(:hasstatus) == true) || (@resource[:hasstatus] == :true)) && [command(:service), @resource[:name], "status"]
   end
 
   def restartcmd
     (@resource[:hasrestart] == :true) && [command(:service), @resource[:name], "restart"]
   end
 
   def startcmd
     [command(:service), @resource[:name], "start"]
   end
 
   def stopcmd
     [command(:service), @resource[:name], "stop"]
   end
 
 end
 
diff --git a/lib/puppet/provider/service/systemd.rb b/lib/puppet/provider/service/systemd.rb
index 33ff52d9c..c67a437c5 100755
--- a/lib/puppet/provider/service/systemd.rb
+++ b/lib/puppet/provider/service/systemd.rb
@@ -1,64 +1,64 @@
 # Manage systemd services using /bin/systemctl
 
 Puppet::Type.type(:service).provide :systemd, :parent => :base do
   desc "Manages `systemd` services using `/bin/systemctl`."
 
   commands :systemctl => "/bin/systemctl"
 
-  #defaultfor :osfamily => [:redhat, :suse]
+  #defaultfor :operatingsystem => [:redhat, :fedora, :suse, :centos, :sles, :oel, :ovm]
 
   def self.instances
     i = []
     output = `systemctl list-units --full --all --no-pager`
     output.scan(/^(\S+)\s+(loaded|error)\s+(active|inactive)\s+(active|waiting|running|plugged|mounted|dead|exited|listening|elapsed)\s*?(\S.*?)?$/i).each do |m|
       i << m[0]
     end
     return i
   rescue Puppet::ExecutionFailure
     return []
   end
 
   def disable
     output = systemctl(:disable, @resource[:name])
   rescue Puppet::ExecutionFailure
     raise Puppet::Error, "Could not disable #{self.name}: #{output}"
   end
 
   def enabled?
     begin
       systemctl("is-enabled", @resource[:name])
     rescue Puppet::ExecutionFailure
       return :false
     end
 
     :true
   end
 
   def status
     begin
       output = systemctl("is-active", @resource[:name])
     rescue Puppet::ExecutionFailure
       return :stopped
     end
     return :running
   end
 
   def enable
     output = systemctl("enable", @resource[:name])
   rescue Puppet::ExecutionFailure
     raise Puppet::Error, "Could not enable #{self.name}: #{output}"
   end
 
   def restartcmd
     [command(:systemctl), "restart", @resource[:name]]
   end
 
   def startcmd
     [command(:systemctl), "start", @resource[:name]]
   end
 
   def stopcmd
     [command(:systemctl), "stop", @resource[:name]]
   end
 end
 
diff --git a/spec/unit/provider/package/up2date_spec.rb b/spec/unit/provider/package/up2date_spec.rb
deleted file mode 100644
index 17709b3c3..000000000
--- a/spec/unit/provider/package/up2date_spec.rb
+++ /dev/null
@@ -1,22 +0,0 @@
-# spec/unit/provider/package/up2date_spec.rb
-require 'spec_helper'
-
-describe 'up2date package provider' do
-
-  # This sets the class itself as the subject rather than
-  # an instance of the class.
-  subject do
-    Puppet::Type.type(:package).provider(:up2date)
-  end
-
-  osfamily = [ 'redhat' ]
-  releases = [ '2.1', '3', '4' ]
-
-  osfamily.product(releases).each do |osfamily, release|
-    it "should be the default provider on #{osfamily} #{release}" do
-      Facter.expects(:value).with(:osfamily).returns(osfamily)
-      Facter.expects(:value).with(:lsbdistrelease).returns(release)
-      subject.default?.should be_true
-    end
-  end
-end
diff --git a/spec/unit/provider/service/redhat_spec.rb b/spec/unit/provider/service/redhat_spec.rb
index 919541e93..aabcf8d0f 100755
--- a/spec/unit/provider/service/redhat_spec.rb
+++ b/spec/unit/provider/service/redhat_spec.rb
@@ -1,132 +1,123 @@
 #!/usr/bin/env rspec
 #
 # Unit testing for the RedHat service Provider
 #
 require 'spec_helper'
 
 provider_class = Puppet::Type.type(:service).provider(:redhat)
 
 describe provider_class do
 
   before :each do
     Puppet.features.stubs(:posix?).returns(true)
     Puppet.features.stubs(:microsoft_windows?).returns(false)
     @class = Puppet::Type.type(:service).provider(:redhat)
     @resource = stub 'resource'
     @resource.stubs(:[]).returns(nil)
     @resource.stubs(:[]).with(:name).returns "myservice"
     @provider = provider_class.new
     @resource.stubs(:provider).returns @provider
     @provider.resource = @resource
     @provider.stubs(:get).with(:hasstatus).returns false
     FileTest.stubs(:file?).with('/sbin/service').returns true
     FileTest.stubs(:executable?).with('/sbin/service').returns true
   end
 
-  osfamily = [ 'redhat', 'suse' ]
-
-  osfamily.each do |osfamily|
-    it "should be the default provider on #{osfamily}" do
-      Facter.expects(:value).with(:osfamily).returns(osfamily)
-      provider_class.default?.should be_true
-    end
-  end
-
   # test self.instances
   describe "when getting all service instances" do
     before :each do
       @services = ['one', 'two', 'three', 'four', 'kudzu', 'functions', 'halt', 'killall', 'single', 'linuxconf']
       @not_services = ['functions', 'halt', 'killall', 'single', 'linuxconf']
       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-@not_services).each do |inst|
         @class.expects(:new).with{|hash| hash[:name] == inst && hash[:path] == '/etc/init.d'}.returns("#{inst}_instance")
       end
       results = (@services-@not_services).collect {|x| "#{x}_instance"}
       @class.instances.should == results
     end
     it "should call service status when initialized from provider" do
       @resource.stubs(:[]).with(:status).returns nil
       @provider.stubs(:get).with(:hasstatus).returns true
       @provider.expects(:execute).with{|command, *args| command == ['/sbin/service', 'myservice', 'status']}
       @provider.send(:status)
     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, :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)
         $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, ['/sbin/service', 'myservice', 'status'], false)
           $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 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
diff --git a/spec/unit/provider/service/systemd_spec.rb b/spec/unit/provider/service/systemd_spec.rb
index 8480c0149..98b6855a6 100755
--- a/spec/unit/provider/service/systemd_spec.rb
+++ b/spec/unit/provider/service/systemd_spec.rb
@@ -1,33 +1,25 @@
 #!/usr/bin/env rspec
 #
 # Unit testing for the RedHat service Provider
 #
 require 'spec_helper'
 
 provider_class = Puppet::Type.type(:service).provider(:systemd)
 
 describe provider_class 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
   end
 
-  osfamily = [ 'redhat', 'suse' ]
-
-  osfamily.each do |osfamily|
-    it "should be the default provider on #{osfamily}" do
-      pending "This test is pending the change in RedHat-related Linuxes to systemd for service management"
-    end
-  end
-
   [: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