puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

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

@@ -6,11 +6,16 @@
 require 'spec_helper'
 
 describe Puppet::Type.type(:service).provider(:init) do
+  before do
+    Puppet::Type.type(:service).defaultprovider = described_class
+  end
+
+  after do
+    Puppet::Type.type(:service).defaultprovider = nil
+  end
 
   let :provider do
-    provider = described_class.new(:name => 'myservice')
-    provider.resource = resource
-    provider
+    resource.provider
   end
 
   let :resource do
@@ -41,25 +46,25 @@ describe Puppet::Type.type(:service).provider(:init) do
     end
 
     it "should return instances for all services" do
-      described_class.instances.map(&:name).should == @services
+      expect(described_class.instances.map(&:name)).to eq(@services)
     end
 
     it "should omit an array of services from exclude list" do
       exclude = ['two', 'four']
-      described_class.get_services(described_class.defpath, exclude).map(&:name).should == (@services - exclude)
+      expect(described_class.get_services(described_class.defpath, exclude).map(&:name)).to eq(@services - exclude)
     end
 
     it "should omit a single service from the exclude list" do
       exclude = 'two'
-      described_class.get_services(described_class.defpath, exclude).map(&:name).should == @services - [exclude]
+      expect(described_class.get_services(described_class.defpath, exclude).map(&:name)).to eq(@services - [exclude])
     end
 
     it "should use defpath" do
-      described_class.instances.should be_all { |provider| provider.get(:path) == described_class.defpath }
+      expect(described_class.instances).to be_all { |provider| provider.get(:path) == described_class.defpath }
     end
 
     it "should set hasstatus to true for providers" do
-      described_class.instances.should be_all { |provider| provider.get(:hasstatus) == true }
+      expect(described_class.instances).to be_all { |provider| provider.get(:hasstatus) == true }
     end
 
     it "should discard upstart jobs", :if => Puppet.features.manages_symlinks? do
@@ -68,14 +73,14 @@ describe Puppet::Type.type(:service).provider(:init) do
       Puppet::FileSystem.expects(:symlink?).at_least_once.returns false
       Puppet::FileSystem.expects(:symlink?).with(Puppet::FileSystem.pathname(path)).returns(true)
       Puppet::FileSystem.expects(:readlink).with(Puppet::FileSystem.pathname(path)).returns("/lib/init/upstart-job")
-      described_class.instances.map(&:name).should == valid_services
+      expect(described_class.instances.map(&:name)).to eq(valid_services)
     end
 
     it "should discard non-initscript scripts" do
       valid_services = @services
       all_services = valid_services + excludes
       Dir.expects(:entries).with('tmp').returns all_services
-      described_class.instances.map(&:name).should =~ valid_services
+      expect(described_class.instances.map(&:name)).to match_array(valid_services)
     end
   end
 
@@ -85,7 +90,7 @@ describe Puppet::Type.type(:service).provider(:init) do
       Puppet::FileSystem.expects(:exist?).with(paths[0]).returns false
       File.expects(:directory?).with(paths[1]).returns true
 
-      provider.paths.should == [paths[1]]
+      expect(provider.paths).to eq([paths[1]])
     end
 
     it "should discard paths that are not directories" do
@@ -93,7 +98,7 @@ describe Puppet::Type.type(:service).provider(:init) do
         Puppet::FileSystem.expects(:exist?).with(path).returns true
         File.expects(:directory?).with(path).returns false
       end
-      provider.paths.should be_empty
+      expect(provider.paths).to be_empty
     end
   end
 
@@ -105,20 +110,20 @@ describe Puppet::Type.type(:service).provider(:init) do
     it "should be able to find the init script in the service path" do
       Puppet::FileSystem.expects(:exist?).with("#{paths[0]}/myservice").returns true
       Puppet::FileSystem.expects(:exist?).with("#{paths[1]}/myservice").never # first one wins
-      provider.initscript.should == "/service/path/myservice"
+      expect(provider.initscript).to eq("/service/path/myservice")
     end
 
     it "should be able to find the init script in an alternate service path" do
       Puppet::FileSystem.expects(:exist?).with("#{paths[0]}/myservice").returns false
       Puppet::FileSystem.expects(:exist?).with("#{paths[1]}/myservice").returns true
-      provider.initscript.should == "/alt/service/path/myservice"
+      expect(provider.initscript).to eq("/alt/service/path/myservice")
     end
 
     it "should be able to find the init script if it ends with .sh" do
       Puppet::FileSystem.expects(:exist?).with("#{paths[0]}/myservice").returns false
       Puppet::FileSystem.expects(:exist?).with("#{paths[1]}/myservice").returns false
       Puppet::FileSystem.expects(:exist?).with("#{paths[0]}/myservice.sh").returns true
-      provider.initscript.should == "/service/path/myservice.sh"
+      expect(provider.initscript).to eq("/service/path/myservice.sh")
     end
 
     it "should fail if the service isn't there" do
@@ -139,7 +144,7 @@ describe Puppet::Type.type(:service).provider(:init) do
 
     [:start, :stop, :status, :restart].each do |method|
       it "should have a #{method} method" do
-        provider.should respond_to(method)
+        expect(provider).to respond_to(method)
       end
       describe "when running #{method}" do
 
@@ -170,13 +175,13 @@ describe Puppet::Type.type(:service).provider(:init) do
         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
+          expect(provider.status).to eq(: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
+            expect(provider.status).to eq(:stopped)
           end
         }
       end
@@ -187,11 +192,11 @@ describe Puppet::Type.type(:service).provider(:init) do
 
         it "should consider the service :running if it has a pid" do
           provider.expects(:getpid).returns "1234"
-          provider.status.should == :running
+          expect(provider.status).to eq(: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
+          expect(provider.status).to eq(:stopped)
         end
       end
     end
@@ -208,23 +213,5 @@ describe Puppet::Type.type(:service).provider(:init) do
         provider.restart
       end
     end
-
-    describe "when starting a service on Solaris" do
-      it "should use ctrun" do
-        Facter.stubs(:value).with(:osfamily).returns 'Solaris'
-        provider.expects(:execute).with('/usr/bin/ctrun -l none /service/path/myservice start', {:failonfail => true, :override_locale => false, :squelch => false, :combine => true}).returns("")
-        $CHILD_STATUS.stubs(:exitstatus).returns(0)
-        provider.start
-      end
-    end
-
-    describe "when starting a service on RedHat" do
-      it "should not use ctrun" do
-        Facter.stubs(:value).with(:osfamily).returns 'RedHat'
-        provider.expects(:execute).with(['/service/path/myservice', :start], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true}).returns("")
-        $CHILD_STATUS.stubs(:exitstatus).returns(0)
-        provider.start
-      end
-    end
   end
 end

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

@@ -6,14 +6,13 @@ require 'spec_helper'
 describe Puppet::Type.type(:service).provider(:launchd) do
   let (:joblabel) { "com.foo.food" }
   let (:provider) { subject.class }
+  let (:launchd_overrides) { '/var/db/launchd.db/com.apple.launchd/overrides.plist' }
   let(:resource) { Puppet::Type.type(:service).new(:name => joblabel, :provider => :launchd) }
-  let (:launchd_overrides_6_9) { '/var/db/launchd.db/com.apple.launchd/overrides.plist' }
-  let (:launchd_overrides_10_) { '/var/db/com.apple.xpc.launchd/disabled.plist' }
   subject { resource.provider }
 
   describe "the type interface" do
     %w{ start stop enabled? enable disable status}.each do |method|
-      it { should respond_to method.to_sym }
+      it { is_expected.to respond_to method.to_sym }
     end
   end
 
@@ -26,88 +25,18 @@ describe Puppet::Type.type(:service).provider(:launchd) do
     it "should return stopped if not listed in launchctl list output" do
       provider.expects(:launchctl).with(:list).returns('com.bar.is_running')
       provider.expects(:jobsearch).with(nil).returns({'com.bar.is_not_running' => "/Library/LaunchDaemons/com.bar.is_not_running"})
-      provider.prefetch({}).last.status.should eq :stopped
+      expect(provider.prefetch({}).last.status).to eq :stopped
     end
     it "should return running if listed in launchctl list output" do
       provider.expects(:launchctl).with(:list).returns('com.bar.is_running')
       provider.expects(:jobsearch).with(nil).returns({'com.bar.is_running' => "/Library/LaunchDaemons/com.bar.is_running"})
-      provider.prefetch({}).last.status.should eq :running
+      expect(provider.prefetch({}).last.status).to eq :running
     end
     after :each do
       provider.instance_variable_set(:@job_list, nil)
     end
   end
 
-  describe "when checking whether the service is enabled on OS X 10.5" do
-    it "should return true in if the job plist says disabled is false" do
-      provider.expects(:get_os_version).returns(9)
-      subject.expects(:plist_from_label).with(joblabel).returns(["foo", {"Disabled" => false}])
-      provider.expects(:read_plist).never
-      subject.enabled?.should == :true
-    end
-    it "should return true in if the job plist has no disabled key" do
-      provider.expects(:get_os_version).returns(9)
-      subject.expects(:plist_from_label).returns(["foo", {}])
-      subject.enabled?.should == :true
-    end
-    it "should return false in if the job plist says disabled is true" do
-      subject.expects(:has_macosx_plist_overrides?).returns(false)
-      subject.expects(:plist_from_label).returns(["foo", {"Disabled" => true}])
-      provider.expects(:read_plist).never
-      subject.enabled?.should == :false
-    end
-  end
-
-  [[10, '10.6'], [13, '10.9']].each do |kernel, version|
-    describe "when checking whether the service is enabled on OS X #{version}" do
-      it "should return true if the job plist says disabled is true and the global overrides says disabled is false" do
-        provider.expects(:get_os_version).returns(kernel).at_least_once
-        subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => true}])
-        provider.expects(:read_plist).with(launchd_overrides_6_9).returns({joblabel => {"Disabled" => false}})
-        FileTest.expects(:file?).with(launchd_overrides_6_9).returns(true)
-        subject.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.expects(:get_os_version).returns(kernel).at_least_once
-        subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => false}])
-        provider.expects(:read_plist).with(launchd_overrides_6_9).returns({joblabel => {"Disabled" => true}})
-        FileTest.expects(:file?).with(launchd_overrides_6_9).returns(true)
-        subject.enabled?.should == :false
-      end
-      it "should return true if the job plist and the global overrides have no disabled keys" do
-        provider.expects(:get_os_version).returns(kernel).at_least_once
-        subject.expects(:plist_from_label).returns([joblabel, {}])
-        provider.expects(:read_plist).with(launchd_overrides_6_9).returns({})
-        FileTest.expects(:file?).with(launchd_overrides_6_9).returns(true)
-        subject.enabled?.should == :true
-      end
-    end
-  end
-
-  describe "when checking whether the service is enabled on OS X 10.10" do
-    it "should return true if the job plist says disabled is true and the global overrides says disabled is false" do
-      provider.expects(:get_os_version).returns(14).at_least_once
-      subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => true}])
-      provider.expects(:read_plist).with(launchd_overrides_10_).returns({joblabel => false})
-      FileTest.expects(:file?).with(launchd_overrides_10_).returns(true)
-      subject.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.expects(:get_os_version).returns(14).at_least_once
-      subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => false}])
-      provider.expects(:read_plist).with(launchd_overrides_10_).returns({joblabel => true})
-      FileTest.expects(:file?).with(launchd_overrides_10_).returns(true)
-      subject.enabled?.should == :false
-    end
-    it "should return true if the job plist and the global overrides have no disabled keys" do
-      provider.expects(:get_os_version).returns(14).at_least_once
-      subject.expects(:plist_from_label).returns([joblabel, {}])
-      provider.expects(:read_plist).with(launchd_overrides_10_).returns({})
-      FileTest.expects(:file?).with(launchd_overrides_10_).returns(true)
-      subject.enabled?.should == :true
-    end
-  end
-
   describe "when starting the service" do
     it "should call any explicit 'start' command" do
       resource[:start] = "/bin/false"
@@ -118,13 +47,13 @@ describe Puppet::Type.type(:service).provider(:launchd) do
     it "should look for the relevant plist once" do
       subject.expects(:plist_from_label).returns([joblabel, {}]).once
       subject.expects(:enabled?).returns :true
-      subject.expects(:execute).with([:launchctl, :load, "-w", joblabel])
+      subject.expects(:execute).with([:launchctl, :load, joblabel])
       subject.start
     end
     it "should execute 'launchctl load' once without writing to the plist if the job is enabled" do
       subject.expects(:plist_from_label).returns([joblabel, {}])
       subject.expects(:enabled?).returns :true
-      subject.expects(:execute).with([:launchctl, :load, "-w", joblabel]).once
+      subject.expects(:execute).with([:launchctl, :load, joblabel]).once
       subject.start
     end
     it "should execute 'launchctl load' with writing to the plist once if the job is disabled" do
@@ -218,45 +147,21 @@ describe Puppet::Type.type(:service).provider(:launchd) do
     end
   end
 
-  [[10, "10.6"], [13, "10.9"]].each do |kernel, version|
-    describe "when enabling the service on OS X #{version}" do
-      it "should write to the global launchd overrides file once" do
-        resource[:enable] = true
-        provider.expects(:get_os_version).returns(kernel).at_least_once
-        provider.expects(:read_plist).with(launchd_overrides_6_9).returns({})
-        Plist::Emit.expects(:save_plist).with(has_entry(resource[:name], {'Disabled' => false}), launchd_overrides_6_9).once
-        subject.enable
-      end
-    end
-
-    describe "when disabling the service on OS X #{version}" do
-      it "should write to the global launchd overrides file once" do
-        resource[:enable] = false
-        provider.expects(:get_os_version).returns(kernel).at_least_once
-        provider.expects(:read_plist).with(launchd_overrides_6_9).returns({})
-        Plist::Emit.expects(:save_plist).with(has_entry(resource[:name], {'Disabled' => true}), launchd_overrides_6_9).once
-        subject.disable
-      end
-    end
-  end
-
-  describe "when enabling the service on OS X 10.10" do
+  describe "when enabling the service" do
     it "should write to the global launchd overrides file once" do
       resource[:enable] = true
-      provider.expects(:get_os_version).returns(14).at_least_once
-      provider.expects(:read_plist).with(launchd_overrides_10_).returns({})
-      Plist::Emit.expects(:save_plist).with(has_entry(resource[:name], false), launchd_overrides_10_).once
+      provider.expects(:read_plist).returns({})
+      Plist::Emit.expects(:save_plist).once
       subject.enable
     end
   end
 
-  describe "when disabling the service on OS X 10.10" do
+  describe "when disabling the service" do
     it "should write to the global launchd overrides file once" do
       resource[:enable] = false
-      provider.expects(:get_os_version).returns(14).at_least_once
-      provider.expects(:read_plist).with(launchd_overrides_10_).returns({})
-      Plist::Emit.expects(:save_plist).with(has_entry(resource[:name], true), launchd_overrides_10_).once
-      subject.disable
+      provider.stubs(:read_plist).returns({})
+      Plist::Emit.expects(:save_plist).once
+      subject.enable
     end
   end
 
@@ -274,7 +179,6 @@ describe Puppet::Type.type(:service).provider(:launchd) do
         }
       end
       let(:busted_plist_path) { '/Library/LaunchAgents/org.busted.plist' }
-      let(:binary_plist_path) { '/Library/LaunchAgents/org.binary.plist' }
 
       it "[17624] should warn that the plist in question is being skipped" do
         provider.expects(:launchd_paths).returns(['/Library/LaunchAgents'])
@@ -285,8 +189,6 @@ describe Puppet::Type.type(:service).provider(:launchd) do
       end
 
       it "[15929] should skip plists that plutil cannot read" do
-        Plist.expects(:parse_xml).with(busted_plist_path).raises(ArgumentError, 'boom')
-        Puppet.expects(:debug).with("Error reading #{busted_plist_path}: boom. Retrying with plutil.")
         provider.expects(:plutil).with('-convert', 'xml1', '-o', '/dev/stdout',
           busted_plist_path).raises(Puppet::ExecutionFailure, 'boom')
         Puppet.expects(:warning).with("Cannot read file #{busted_plist_path}; " +
@@ -294,18 +196,10 @@ describe Puppet::Type.type(:service).provider(:launchd) do
                                       "Details: boom")
         provider.read_plist(busted_plist_path)
       end
-
-      it "should read binary plists with plutil" do
-        Plist.expects(:parse_xml).with(binary_plist_path).raises(ArgumentError, 'boom')
-        Puppet.expects(:debug).with("Error reading #{binary_plist_path}: boom. Retrying with plutil.")
-        provider.expects(:plutil).with('-convert', 'xml1', '-o', '/dev/stdout', binary_plist_path).returns('plist')
-        Plist.expects(:parse_xml).with('plist').returns('plist_map')
-        expect(provider.read_plist(binary_plist_path)).to eq('plist_map')
-      end
     end
     it "should return the cached value when available" do
       provider.instance_variable_set(:@label_to_path_map, {'xx'=>'yy'})
-      provider.make_label_to_path_map.should eq({'xx'=>'yy'})
+      expect(provider.make_label_to_path_map).to eq({'xx'=>'yy'})
     end
     describe "when successful" do
       let(:launchd_dir) { '/Library/LaunchAgents' }
@@ -318,11 +212,11 @@ describe Puppet::Type.type(:service).provider(:launchd) do
         provider.expects(:read_plist).with(plist).returns({'Label'=>'foo.bar.service'})
       end
       it "should read the plists and return their contents" do
-        provider.make_label_to_path_map.should eq({label=>plist})
+        expect(provider.make_label_to_path_map).to eq({label=>plist})
       end
       it "should re-read the plists and return their contents when refreshed" do
         provider.instance_variable_set(:@label_to_path_map, {'xx'=>'yy'})
-        provider.make_label_to_path_map(true).should eq({label=>plist})
+        expect(provider.make_label_to_path_map(true)).to eq({label=>plist})
       end
     end
   end
@@ -332,16 +226,16 @@ describe Puppet::Type.type(:service).provider(:launchd) do
                  "org.mozilla.python" => "/path/to/python.plist"} }
     it "returns the entire map with no args" do
       provider.expects(:make_label_to_path_map).returns(map)
-      provider.jobsearch.should == map
+      expect(provider.jobsearch).to eq(map)
     end
     it "returns a singleton hash when given a label" do
       provider.expects(:make_label_to_path_map).returns(map)
-      provider.jobsearch("org.mozilla.puppet").should == { "org.mozilla.puppet" => "/path/to/puppet.plist" }
+      expect(provider.jobsearch("org.mozilla.puppet")).to eq({ "org.mozilla.puppet" => "/path/to/puppet.plist" })
     end
     it "refreshes the label_to_path_map when label is not found" do
       provider.expects(:make_label_to_path_map).with().returns({})
       provider.expects(:make_label_to_path_map).with(true).returns(map)
-      provider.jobsearch("org.mozilla.puppet").should == { "org.mozilla.puppet" => "/path/to/puppet.plist" }
+      expect(provider.jobsearch("org.mozilla.puppet")).to eq({ "org.mozilla.puppet" => "/path/to/puppet.plist" })
     end
     it "raises Puppet::Error when the label is still not found" do
       provider.expects(:make_label_to_path_map).with().returns(map)

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

@@ -6,41 +6,24 @@ require 'spec_helper'
 
 provider_class = Puppet::Type.type(:service).provider(:openbsd)
 
-describe provider_class do
+describe provider_class, :unless => Puppet.features.microsoft_windows? do
   before :each do
     Puppet::Type.type(:service).stubs(:defaultprovider).returns described_class
     Facter.stubs(:value).with(:operatingsystem).returns :openbsd
-    Facter.stubs(:value).with(:osfamily).returns 'OpenBSD'
-  end
-
-  let :rcscripts do
-    [
-      '/etc/rc.d/apmd',
-      '/etc/rc.d/aucat',
-      '/etc/rc.d/cron',
-      '/etc/rc.d/puppetd'
-    ]
+    FileTest.stubs(:file?).with('/usr/sbin/rcctl').returns true
+    FileTest.stubs(:executable?).with('/usr/sbin/rcctl').returns true
   end
 
   describe "#instances" do
     it "should have an instances method" do
-      described_class.should respond_to :instances
+      expect(described_class).to respond_to :instances
     end
 
     it "should list all available services" do
-      File.expects(:directory?).with('/etc/rc.d').returns true
-      Dir.expects(:glob).with('/etc/rc.d/*').returns rcscripts
-
-      rcscripts.each do |script|
-        File.expects(:executable?).with(script).returns true
-      end
-
-      described_class.instances.map(&:name).should == [
-        'apmd',
-        'aucat',
-        'cron',
-        'puppetd'
-      ]
+      described_class.stubs(:execpipe).with(['/usr/sbin/rcctl', :getall]).yields File.read(my_fixture('rcctl_getall'))
+      expect(described_class.instances.map(&:name)).to eq([
+        'accounting', 'pf', 'postgresql', 'tftpd', 'wsmoused', 'xdm',
+      ])
     end
   end
 
@@ -53,8 +36,7 @@ describe provider_class do
 
     it "should start the service otherwise" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      provider.expects(:execute).with(['/etc/rc.d/sshd', '-f', :start], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
-      provider.expects(:search).with('sshd').returns('/etc/rc.d/sshd')
+      provider.expects(:texecute).with(:start, ['/usr/sbin/rcctl', '-f', :start, 'sshd'], true)
       provider.start
     end
   end
@@ -68,8 +50,7 @@ describe provider_class do
 
     it "should stop the service otherwise" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      provider.expects(:execute).with(['/etc/rc.d/sshd', :stop], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
-      provider.expects(:search).with('sshd').returns('/etc/rc.d/sshd')
+      provider.expects(:texecute).with(:stop, ['/usr/sbin/rcctl', :stop, 'sshd'], true)
       provider.stop
     end
   end
@@ -77,181 +58,146 @@ describe provider_class do
   describe "#status" do
     it "should use the status command from the resource" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
-      provider.expects(:execute).with(['/etc/rc.d/sshd', :status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).never
+      provider.expects(:execute).with(['/usr/sbin/rcctl', :get, 'sshd', :status], :failonfail => true, :override_locale => false, :squelch => false, :combine => true).never
       provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
       provider.status
     end
 
     it "should return :stopped when status command returns with a non-zero exitcode" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
-      provider.expects(:execute).with(['/etc/rc.d/sshd', :status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).never
+      provider.expects(:execute).with(['/usr/sbin/rcctl', :get, 'sshd', :status], :failonfail => true, :override_locale => false, :squelch => false, :combine => true).never
       provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
       $CHILD_STATUS.stubs(:exitstatus).returns 3
-      provider.status.should == :stopped
+      expect(provider.status).to eq(:stopped)
     end
 
     it "should return :running when status command returns with a zero exitcode" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
-      provider.expects(:execute).with(['/etc/rc.d/sshd', :status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).never
+      provider.expects(:execute).with(['/usr/sbin/rcctl', :get, 'sshd', :status], :failonfail => true, :override_locale => false, :squelch => false, :combine => true).never
       provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
       $CHILD_STATUS.stubs(:exitstatus).returns 0
-      provider.status.should == :running
+      expect(provider.status).to eq(:running)
     end
   end
 
   describe "#restart" do
     it "should use the supplied restart command if specified" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :restart => '/bin/foo'))
-      provider.expects(:execute).with(['/etc/rc.d/sshd', '-f', :restart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true).never
+      provider.expects(:execute).with(['/usr/sbin/rcctl', '-f', :restart, 'sshd'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true).never
       provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.restart
     end
 
-    it "should restart the service with rc-service restart if hasrestart is true" do
+    it "should restart the service with rcctl restart if hasrestart is true" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => true))
-      provider.expects(:execute).with(['/etc/rc.d/sshd', '-f', :restart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
-      provider.expects(:search).with('sshd').returns('/etc/rc.d/sshd')
+      provider.expects(:texecute).with(:restart, ['/usr/sbin/rcctl', '-f', :restart, 'sshd'], true)
       provider.restart
     end
 
-    it "should restart the service with rc-service stop/start if hasrestart is false" do
+    it "should restart the service with rcctl stop/start if hasrestart is false" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => false))
-      provider.expects(:execute).with(['/etc/rc.d/sshd', '-f', :restart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true).never
-      provider.expects(:execute).with(['/etc/rc.d/sshd', :stop], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
-      provider.expects(:execute).with(['/etc/rc.d/sshd', '-f', :start], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
-      provider.expects(:search).with('sshd').returns('/etc/rc.d/sshd')
+      provider.expects(:texecute).with(:restart, ['/usr/sbin/rcctl', '-f', :restart, 'sshd'], true).never
+      provider.expects(:texecute).with(:stop, ['/usr/sbin/rcctl', :stop, 'sshd'], true)
+      provider.expects(:texecute).with(:start, ['/usr/sbin/rcctl', '-f', :start, 'sshd'], true)
       provider.restart
     end
   end
 
-  describe "#parse_rc_line" do
-    it "can parse a flag line with a known value" do
-      output = described_class.parse_rc_line('daemon_flags=')
-      output.should eq('')
-    end
-
-    it "can parse a flag line with a flag is wrapped in single quotes" do
-      output = described_class.parse_rc_line('daemon_flags=\'\'')
-      output.should eq('\'\'')
-    end
-
-    it "can parse a flag line with a flag is wrapped in double quotes" do
-      output = described_class.parse_rc_line('daemon_flags=""')
-      output.should eq('')
-    end
-
-    it "can parse a flag line with a trailing comment" do
-      output = described_class.parse_rc_line('daemon_flags="-d" # bees')
-      output.should eq('-d')
-    end
-
-    it "can parse a flag line with a bare word" do
-      output = described_class.parse_rc_line('daemon_flags=YES')
-      output.should eq('YES')
-    end
-
-    it "can parse a flag line with a flag that contains an equals" do
-      output = described_class.parse_rc_line('daemon_flags="-Dbla -tmpdir=foo"')
-      output.should eq('-Dbla -tmpdir=foo')
-    end
-  end
-
-  describe "#pkg_scripts" do
-    it "can retrieve the package_scripts array from rc.conf.local" do
-      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'cupsd'))
-      provider.expects(:load_rcconf_local_array).returns ['pkg_scripts="dbus_daemon cupsd"']
-      expect(provider.pkg_scripts).to match_array(['dbus_daemon', 'cupsd'])
+  describe "#enabled?" do
+    it "should return :true if the service is enabled" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      described_class.stubs(:rcctl).with(:get, 'sshd', :status)
+      provider.expects(:execute).with(['/usr/sbin/rcctl', 'get', 'sshd', 'status'], :failonfail => false, :combine => false, :squelch => false).returns(stub(:exitstatus => 0))
+      expect(provider.enabled?).to eq(:true)
     end
 
-    it "returns an empty array when no pkg_scripts line is found" do
-      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'cupsd'))
-      provider.expects(:load_rcconf_local_array).returns ["#\n#\n#"]
-      expect(provider.pkg_scripts).to match_array([])
+    it "should return :false if the service is disabled" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      described_class.stubs(:rcctl).with(:get, 'sshd', :status).returns('NO')
+      provider.expects(:execute).with(['/usr/sbin/rcctl', 'get', 'sshd', 'status'], :failonfail => false, :combine => false, :squelch => false).returns(stub(:exitstatus => 1))
+      expect(provider.enabled?).to eq(:false)
     end
   end
 
-  describe "#pkg_scripts_append" do
-    it "can append to the package_scripts array and return the result" do
-      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'cupsd'))
-      provider.expects(:load_rcconf_local_array).returns ['pkg_scripts="dbus_daemon"']
-      provider.pkg_scripts_append.should === ['dbus_daemon', 'cupsd']
+  describe "#enable" do
+    it "should run rcctl enable to enable the service" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      described_class.stubs(:rcctl).with(:enable, 'sshd').returns('')
+      provider.expects(:rcctl).with(:enable, 'sshd')
+      provider.enable
     end
 
-    it "should not duplicate the script name" do
-      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'cupsd'))
-      provider.expects(:load_rcconf_local_array).returns ['pkg_scripts="cupsd dbus_daemon"']
-      provider.pkg_scripts_append.should === ['cupsd', 'dbus_daemon']
+    it "should run rcctl enable with flags if provided" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :flags => '-6'))
+      described_class.stubs(:rcctl).with(:enable, 'sshd').returns('')
+      described_class.stubs(:rcctl).with(:set, 'sshd', :flags, '-6').returns('')
+      provider.expects(:rcctl).with(:enable, 'sshd')
+      provider.expects(:rcctl).with(:set, 'sshd', :flags, '-6')
+      provider.enable
     end
   end
 
-  describe "#pkg_scripts_remove" do
-    it "can append to the package_scripts array and return the result" do
-      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'cupsd'))
-      provider.expects(:load_rcconf_local_array).returns ['pkg_scripts="dbus_daemon cupsd"']
-      expect(provider.pkg_scripts_remove).to match_array(['dbus_daemon'])
-    end
-
-    it "should not remove the script from the array unless its needed" do
-      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'cupsd'))
-      provider.expects(:load_rcconf_local_array).returns ['pkg_scripts="dbus_daemon"']
-      expect(provider.pkg_scripts_remove).to match_array(['dbus_daemon'])
+  describe "#disable" do
+    it "should run rcctl disable to disable the service" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      described_class.stubs(:rcctl).with(:disable, 'sshd').returns('')
+      provider.expects(:rcctl).with(:disable, 'sshd')
+      provider.disable
     end
   end
 
-  describe "#set_content_flags" do
-    it "can create the necessary content where none is provided" do
-      content = []
-      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'cupsd'))
-      provider.set_content_flags(content,'-d').should match_array(['cupsd_flags="-d"'])
+  describe "#running?" do
+    it "should run rcctl check to check the service" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      described_class.stubs(:rcctl).with(:check, 'sshd').returns('sshd(ok)')
+      provider.expects(:execute).with(['/usr/sbin/rcctl', 'check', 'sshd'], :failonfail => false, :combine => false, :squelch => false).returns('sshd(ok)')
+      expect(provider.running?).to be_truthy
     end
 
-    it "can modify the existing content" do
-      content = ['cupsd_flags="-f"']
-      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'cupsd'))
-      output = provider.set_content_flags(content,"-d")
-      output.should match_array(['cupsd_flags="-d"'])
+    it "should return true if the service is running" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      described_class.stubs(:rcctl).with(:check, 'sshd').returns('sshd(ok)')
+      provider.expects(:execute).with(['/usr/sbin/rcctl', 'check', 'sshd'], :failonfail => false, :combine => false, :squelch => false).returns('sshd(ok)')
+      expect(provider.running?).to be_truthy
     end
 
-    it "does not set empty flags for package scripts" do
-      content = []
-      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'cupsd'))
-      provider.expects(:in_base?).returns(false)
-      output = provider.set_content_flags(content,'')
-      output.should match_array([nil])
+    it "should return nil if the service is not running" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      described_class.stubs(:rcctl).with(:check, 'sshd').returns('sshd(failed)')
+      provider.expects(:execute).with(['/usr/sbin/rcctl', 'check', 'sshd'], :failonfail => false, :combine => false, :squelch => false).returns('sshd(failed)')
+      expect(provider.running?).to be_nil
     end
+  end
 
-    it "does set empty flags for base scripts" do
-      content = []
-      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'ntpd'))
-      provider.expects(:in_base?).returns(true)
-      output = provider.set_content_flags(content,'')
-      output.should match_array(['ntpd_flags=""'])
+  describe "#flags" do
+    it "should return flags when set" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :flags => '-6'))
+      described_class.stubs(:rcctl).with('get', 'sshd', 'flags').returns('-6')
+      provider.expects(:execute).with(['/usr/sbin/rcctl', 'get', 'sshd', 'flags'], :failonfail => false, :combine => false, :squelch => false).returns('-6')
+      provider.flags
     end
-  end
 
-  describe "#remove_content_flags" do
-    it "can remove the flags line from the requested content" do
-      content = ['cupsd_flags="-d"']
-      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'cupsd'))
-      output = provider.remove_content_flags(content)
-      output.should_not match_array(['cupsd_flags="-d"'])
+    it "should return empty flags" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      described_class.stubs(:rcctl).with('get', 'sshd', 'flags').returns('')
+      provider.expects(:execute).with(['/usr/sbin/rcctl', 'get', 'sshd', 'flags'], :failonfail => false, :combine => false, :squelch => false).returns('')
+      provider.flags
     end
-  end
 
-  describe "#set_content_scripts" do
-    it "should append to the list of scripts" do
-      content = ['pkg_scripts="dbus_daemon"']
-      scripts = ['dbus_daemon','cupsd']
-      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'cupsd'))
-      provider.set_content_scripts(content,scripts).should match_array(['pkg_scripts="dbus_daemon cupsd"'])
+    it "should return flags for special services" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'pf'))
+      described_class.stubs(:rcctl).with('get', 'pf', 'flags').returns('YES')
+      provider.expects(:execute).with(['/usr/sbin/rcctl', 'get', 'pf', 'flags'], :failonfail => false, :combine => false, :squelch => false).returns('YES')
+      provider.flags
     end
   end
 
-  describe "#in_base?" do
-    it "should true if in base" do
-      File.stubs(:readlines).with('/etc/rc.conf').returns(['sshd_flags=""'])
+  describe "#flags=" do
+    it "should run rcctl to set flags" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      provider.in_base?.should be_true
+      described_class.stubs(:rcctl).with(:set, 'sshd', :flags, '-4').returns('')
+      provider.expects(:rcctl).with(:set, 'sshd', :flags, '-4')
+      provider.flags = '-4'
     end
   end
 end