puppet 7.28.0-universal-darwin → 7.29.0-universal-darwin

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

@@ -1,109 +0,0 @@
-require 'spec_helper'
-require 'rbconfig'
-require 'fileutils'
-
-describe "base service provider" do
-  include PuppetSpec::Files
-
-  let :type do Puppet::Type.type(:service) end
-  let :provider do type.provider(:base) end
-  let(:executor) { Puppet::Util::Execution }
-  let(:start_command) { 'start' }
-  let(:status_command) { 'status' }
-  let(:stop_command) { 'stop' }
-
-  subject { provider }
-
-  context "basic operations" do
-    subject do
-      type.new(
-         :name  => "test",
-         :provider => :base,
-         :start  => start_command,
-         :status => status_command,
-         :stop   => stop_command
-      ).provider
-    end
-
-    def execute_command(command, options)
-      case command.shift
-      when start_command
-        expect(options[:failonfail]).to eq(true)
-        raise(Puppet::ExecutionFailure, 'failed to start') if @running
-        @running = true
-        Puppet::Util::Execution::ProcessOutput.new('started', 0)
-      when status_command
-        expect(options[:failonfail]).to eq(false)
-        if @running
-          Puppet::Util::Execution::ProcessOutput.new('running', 0)
-        else
-          Puppet::Util::Execution::ProcessOutput.new('not running', 1)
-        end
-      when stop_command
-        expect(options[:failonfail]).to eq(true)
-        raise(Puppet::ExecutionFailure, 'failed to stop') unless @running
-        @running = false
-        Puppet::Util::Execution::ProcessOutput.new('stopped', 0)
-      else
-        raise "unexpected command execution: #{command}"
-      end
-    end
-
-    before :each do
-      @running = false
-      expect(executor).to receive(:execute).at_least(:once) { |command, options| execute_command(command, options) }
-    end
-
-    it "should invoke the start command if not running" do
-      subject.start
-    end
-
-    it "should be stopped before being started" do
-      expect(subject.status).to eq(:stopped)
-    end
-
-    it "should be running after being started" do
-      subject.start
-      expect(subject.status).to eq(:running)
-    end
-
-    it "should invoke the stop command when asked" do
-      subject.start
-      expect(subject.status).to eq(:running)
-      subject.stop
-      expect(subject.status).to eq(:stopped)
-    end
-
-    it "should raise an error if started twice" do
-      subject.start
-      expect {subject.start }.to raise_error(Puppet::Error, 'Could not start Service[test]: failed to start')
-    end
-
-    it "should raise an error if stopped twice" do
-      subject.start
-      subject.stop
-      expect {subject.stop }.to raise_error(Puppet::Error, 'Could not stop Service[test]: failed to stop')
-    end
-  end
-
-  context "when hasstatus is false" do
-    subject do
-      type.new(
-         :name  => "status test",
-         :provider => :base,
-         :hasstatus => false,
-         :pattern => "majestik m\u00f8\u00f8se",
-      ).provider
-    end
-
-    it "retrieves a PID from the process table" do
-      allow(Facter).to receive(:value).and_call_original
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return("CentOS")
-      ps_output = File.binread(my_fixture("ps_ef.mixed_encoding")).force_encoding(Encoding::UTF_8)
-
-      expect(executor).to receive(:execute).with("ps -ef").and_return(ps_output)
-
-      expect(subject.status).to eq(:running)
-    end
-  end
-end

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

@@ -1,127 +0,0 @@
-require 'spec_helper'
-
-describe 'Puppet::Type::Service::Provider::Bsd',
-         unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
-  let(:provider_class) { Puppet::Type.type(:service).provider(:bsd) }
-
-  before :each do
-    allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(provider_class)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:netbsd)
-    allow(Facter).to receive(:value).with(:osfamily).and_return('NetBSD')
-    allow(provider_class).to receive(:defpath).and_return('/etc/rc.conf.d')
-    @provider = provider_class.new
-    allow(@provider).to receive(:initscript)
-  end
-
-  context "#instances" do
-    it "should have an instances method" do
-      expect(provider_class).to respond_to :instances
-    end
-
-    it "should use defpath" do
-      expect(provider_class.instances).to be_all { |provider| provider.get(:path) == provider_class.defpath }
-    end
-  end
-
-  context "#disable" do
-    it "should have a disable method" do
-      expect(@provider).to respond_to(:disable)
-    end
-
-    it "should remove a service file to disable" do
-      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      allow(Puppet::FileSystem).to receive(:exist?).with('/etc/rc.conf.d/sshd').and_return(true)
-      expect(Puppet::FileSystem).to receive(:exist?).with('/etc/rc.conf.d/sshd').and_return(true)
-      allow(File).to receive(:delete).with('/etc/rc.conf.d/sshd')
-      provider.disable
-    end
-
-    it "should not remove a service file if it doesn't exist" do
-      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      allow(File).to receive(:exist?).with('/etc/rc.conf.d/sshd').and_return(false)
-      expect(Puppet::FileSystem).to receive(:exist?).with('/etc/rc.conf.d/sshd').and_return(false)
-      provider.disable
-    end
-  end
-
-  context "#enable" do
-    it "should have an enable method" do
-      expect(@provider).to respond_to(:enable)
-    end
-
-    it "should set the proper contents to enable" do
-      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      allow(Dir).to receive(:mkdir).with('/etc/rc.conf.d')
-      fh = double('fh')
-      allow(File).to receive(:open).with('/etc/rc.conf.d/sshd', File::WRONLY | File::APPEND | File::CREAT, 0644).and_yield(fh)
-      expect(fh).to receive(:<<).with("sshd_enable=\"YES\"\n")
-      provider.enable
-    end
-
-    it "should set the proper contents to enable when disabled" do
-      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      allow(Dir).to receive(:mkdir).with('/etc/rc.conf.d')
-      allow(File).to receive(:read).with('/etc/rc.conf.d/sshd').and_return("sshd_enable=\"NO\"\n")
-      fh = double('fh')
-      allow(File).to receive(:open).with('/etc/rc.conf.d/sshd', File::WRONLY | File::APPEND | File::CREAT, 0644).and_yield(fh)
-      expect(fh).to receive(:<<).with("sshd_enable=\"YES\"\n")
-      provider.enable
-    end
-  end
-
-  context "#enabled?" do
-    it "should have an enabled? method" do
-      expect(@provider).to respond_to(:enabled?)
-    end
-
-    it "should return false if the service file does not exist" do
-      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      allow(Puppet::FileSystem).to receive(:exist?).with('/etc/rc.conf.d/sshd').and_return(false)
-      expect(provider.enabled?).to eq(:false)
-    end
-
-    it "should return true if the service file exists" do
-      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      allow(Puppet::FileSystem).to receive(:exist?).with('/etc/rc.conf.d/sshd').and_return(true)
-      expect(provider.enabled?).to eq(:true)
-    end
-  end
-
-  context "#startcmd" do
-    it "should have a startcmd method" do
-      expect(@provider).to respond_to(:startcmd)
-    end
-
-    it "should use the supplied start command if specified" do
-      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :start => '/bin/foo'))
-      expect(provider).to receive(:execute).with(['/bin/foo'], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
-      provider.start
-    end
-
-    it "should start the serviced directly otherwise" do
-      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:execute).with(['/etc/rc.d/sshd', :onestart], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
-      expect(provider).to receive(:search).with('sshd').and_return('/etc/rc.d/sshd')
-      provider.start
-    end
-  end
-
-  context "#stopcmd" do
-    it "should have a stopcmd method" do
-      expect(@provider).to respond_to(:stopcmd)
-    end
-
-    it "should use the supplied stop command if specified" do
-      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :stop => '/bin/foo'))
-      expect(provider).to receive(:execute).with(['/bin/foo'], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
-      provider.stop
-    end
-
-    it "should stop the serviced directly otherwise" do
-      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:execute).with(['/etc/rc.d/sshd', :onestop], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
-      expect(provider).to receive(:search).with('sshd').and_return('/etc/rc.d/sshd')
-      provider.stop
-    end
-  end
-end

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

@@ -1,190 +0,0 @@
-require 'spec_helper'
-
-describe 'Puppet::Type::Service::Provider::Daemontools',
-         unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
-  let(:provider_class) { Puppet::Type.type(:service).provider(:daemontools) }
-
-  before(:each) do
-    # Create a mock resource
-    @resource = double('resource')
-
-    @provider = provider_class.new
-    @servicedir = "/etc/service"
-    @provider.servicedir=@servicedir
-    @daemondir = "/var/lib/service"
-    @provider.class.defpath=@daemondir
-
-    # A catch all; no parameters set
-    allow(@resource).to receive(:[]).and_return(nil)
-
-    # But set name, source and path (because we won't run
-    # the thing that will fetch the resource path from the provider)
-    allow(@resource).to receive(:[]).with(:name).and_return("myservice")
-    allow(@resource).to receive(:[]).with(:ensure).and_return(:enabled)
-    allow(@resource).to receive(:[]).with(:path).and_return(@daemondir)
-    allow(@resource).to receive(:ref).and_return("Service[myservice]")
-
-    @provider.resource = @resource
-
-    allow(@provider).to receive(:command).with(:svc).and_return("svc")
-    allow(@provider).to receive(:command).with(:svstat).and_return("svstat")
-
-    allow(@provider).to receive(:svc)
-    allow(@provider).to receive(:svstat)
-  end
-
-  it "should have a restart method" do
-    expect(@provider).to respond_to(:restart)
-  end
-
-  it "should have a start method" do
-    expect(@provider).to respond_to(:start)
-  end
-
-  it "should have a stop method" do
-    expect(@provider).to respond_to(:stop)
-  end
-
-  it "should have an enabled? method" do
-    expect(@provider).to respond_to(:enabled?)
-  end
-
-  it "should have an enable method" do
-    expect(@provider).to respond_to(:enable)
-  end
-
-  it "should have a disable method" do
-    expect(@provider).to respond_to(:disable)
-  end
-
-  context "when starting" do
-    it "should use 'svc' to start the service" do
-      allow(@provider).to receive(:enabled?).and_return(:true)
-      expect(@provider).to receive(:svc).with("-u", "/etc/service/myservice")
-
-      @provider.start
-    end
-
-    it "should enable the service if it is not enabled" do
-      allow(@provider).to receive(:svc)
-
-      expect(@provider).to receive(:enabled?).and_return(:false)
-      expect(@provider).to receive(:enable)
-
-      @provider.start
-    end
-  end
-
-  context "when stopping" do
-    it "should use 'svc' to stop the service" do
-      allow(@provider).to receive(:disable)
-      expect(@provider).to receive(:svc).with("-d", "/etc/service/myservice")
-
-      @provider.stop
-    end
-  end
-
-  context "when restarting" do
-    it "should use 'svc' to restart the service" do
-      expect(@provider).to receive(:svc).with("-t", "/etc/service/myservice")
-
-      @provider.restart
-    end
-  end
-
-  context "when enabling" do
-    it "should create a symlink between daemon dir and service dir", :if => Puppet.features.manages_symlinks?  do
-      daemon_path = File.join(@daemondir, "myservice")
-      service_path = File.join(@servicedir, "myservice")
-      expect(Puppet::FileSystem).to receive(:symlink?).with(service_path).and_return(false)
-      expect(Puppet::FileSystem).to receive(:symlink).with(daemon_path, service_path).and_return(0)
-
-      @provider.enable
-    end
-  end
-
-  context "when disabling" do
-    it "should remove the symlink between daemon dir and service dir" do
-      allow(FileTest).to receive(:directory?).and_return(false)
-      path = File.join(@servicedir,"myservice")
-      expect(Puppet::FileSystem).to receive(:symlink?).with(path).and_return(true)
-      expect(Puppet::FileSystem).to receive(:unlink).with(path)
-      allow(@provider).to receive(:execute).and_return("")
-      @provider.disable
-    end
-
-    it "should stop the service" do
-      allow(FileTest).to receive(:directory?).and_return(false)
-      expect(Puppet::FileSystem).to receive(:symlink?).and_return(true)
-      allow(Puppet::FileSystem).to receive(:unlink)
-      expect(@provider).to receive(:stop)
-      @provider.disable
-    end
-  end
-
-  context "when checking if the service is enabled?" do
-    it "should return true if it is running" do
-      allow(@provider).to receive(:status).and_return(:running)
-
-      expect(@provider.enabled?).to eq(:true)
-    end
-
-    [true, false].each do |t|
-      it "should return #{t} if the symlink exists" do
-        allow(@provider).to receive(:status).and_return(:stopped)
-        path = File.join(@servicedir,"myservice")
-        expect(Puppet::FileSystem).to receive(:symlink?).with(path).and_return(t)
-
-        expect(@provider.enabled?).to eq("#{t}".to_sym)
-      end
-    end
-  end
-
-  context "when checking status" do
-    it "should call the external command 'svstat /etc/service/myservice'" do
-      expect(@provider).to receive(:svstat).with(File.join(@servicedir,"myservice"))
-      @provider.status
-    end
-  end
-
-  context "when checking status" do
-    it "and svstat fails, properly raise a Puppet::Error" do
-      expect(@provider).to receive(:svstat).with(File.join(@servicedir,"myservice")).and_raise(Puppet::ExecutionFailure, "failure")
-      expect { @provider.status }.to raise_error(Puppet::Error, 'Could not get status for service Service[myservice]: failure')
-    end
-
-    it "and svstat returns up, then return :running" do
-      expect(@provider).to receive(:svstat).with(File.join(@servicedir,"myservice")).and_return("/etc/service/myservice: up (pid 454) 954326 seconds")
-      expect(@provider.status).to eq(:running)
-    end
-
-    it "and svstat returns not running, then return :stopped" do
-      expect(@provider).to receive(:svstat).with(File.join(@servicedir,"myservice")).and_return("/etc/service/myservice: supervise not running")
-      expect(@provider.status).to  eq(:stopped)
-    end
-  end
-
-  context '.instances' do
-    before do
-      allow(provider_class).to receive(:defpath).and_return(path)
-    end
-
-    context 'when defpath is nil' do
-      let(:path) { nil }
-
-      it 'returns info message' do
-        expect(Puppet).to receive(:info).with(/daemontools is unsuitable because service directory is nil/)
-        provider_class.instances
-      end
-    end
-
-    context 'when defpath does not exist' do
-      let(:path) { '/inexistent_path' }
-
-      it 'returns notice about missing path' do
-        expect(Puppet).to receive(:notice).with(/Service path #{path} does not exist/)
-        provider_class.instances
-      end
-    end
-  end
-end

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

@@ -1,158 +0,0 @@
-require 'spec_helper'
-
-describe 'Puppet::Type::Service::Provider::Debian',
-         unless: Puppet::Util::Platform.jruby? || Puppet::Util::Platform.windows? do
-  let(:provider_class) { Puppet::Type.type(:service).provider(:debian) }
-
-  before(:each) do
-    # Create a mock resource
-    @resource = double('resource')
-
-    @provider = provider_class.new
-
-    # A catch all; no parameters set
-    allow(@resource).to receive(:[]).and_return(nil)
-
-    # But set name, source and path
-    allow(@resource).to receive(:[]).with(:name).and_return("myservice")
-    allow(@resource).to receive(:[]).with(:ensure).and_return(:enabled)
-    allow(@resource).to receive(:ref).and_return("Service[myservice]")
-
-    @provider.resource = @resource
-
-    allow(@provider).to receive(:command).with(:update_rc).and_return("update_rc")
-    allow(@provider).to receive(:command).with(:invoke_rc).and_return("invoke_rc")
-    allow(@provider).to receive(:command).with(:service).and_return("service")
-
-    allow(@provider).to receive(:update_rc)
-    allow(@provider).to receive(:invoke_rc)
-  end
-
-  ['1','2'].each do |version|
-    it "should be the default provider on CumulusLinux #{version}" do
-      expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return('CumulusLinux')
-      expect(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return(version)
-      expect(provider_class.default?).to be_truthy
-    end
-  end
-
-  it "should be the default provider on Devuan" do
-    expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return('Devuan')
-    expect(provider_class.default?).to be_truthy
-  end
-
-  it "should be the default provider on Debian" do
-    expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return('Debian')
-    expect(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return('7')
-    expect(provider_class.default?).to be_truthy
-  end
-
-  it "should have an enabled? method" do
-    expect(@provider).to respond_to(:enabled?)
-  end
-
-  it "should have an enable method" do
-    expect(@provider).to respond_to(:enable)
-  end
-
-  it "should have a disable method" do
-    expect(@provider).to respond_to(:disable)
-  end
-
-  context "when enabling" do
-    it "should call update-rc.d twice" do
-      expect(@provider).to receive(:update_rc).twice
-      @provider.enable
-    end
-  end
-
-  context "when disabling" do
-    it "should be able to disable services with newer sysv-rc versions" do
-      allow(@provider).to receive(:`).with("dpkg --compare-versions $(dpkg-query -W --showformat '${Version}' sysv-rc) ge 2.88 ; echo $?").and_return("0")
-
-      expect(@provider).to receive(:update_rc).with(@resource[:name], "disable")
-
-      @provider.disable
-    end
-
-    it "should be able to enable services with older sysv-rc versions" do
-      allow(@provider).to receive(:`).with("dpkg --compare-versions $(dpkg-query -W --showformat '${Version}' sysv-rc) ge 2.88 ; echo $?").and_return("1")
-
-      expect(@provider).to receive(:update_rc).with("-f", @resource[:name], "remove")
-      expect(@provider).to receive(:update_rc).with(@resource[:name], "stop", "00", "1", "2", "3", "4", "5", "6", ".")
-
-      @provider.disable
-    end
-  end
-
-  context "when checking whether it is enabled" do
-    it "should execute the query command" do
-      expect(@provider).to receive(:execute).with(["/usr/sbin/invoke-rc.d", "--quiet", "--query", @resource[:name], "start"], {:failonfail => false})
-                             .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-      @provider.enabled?
-    end
-
-    it "should return true when invoke-rc.d exits with 104 status" do
-      expect(@provider).to receive(:execute).and_return(Puppet::Util::Execution::ProcessOutput.new('', 104))
-      expect(@provider.enabled?).to eq(:true)
-    end
-
-    it "should return true when invoke-rc.d exits with 106 status" do
-      expect(@provider).to receive(:execute).and_return(Puppet::Util::Execution::ProcessOutput.new('', 106))
-      expect(@provider.enabled?).to eq(:true)
-    end
-
-    it "should consider nonexistent services to be disabled" do
-      @provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'doesnotexist'))
-      expect(@provider).to receive(:execute).with(["/usr/sbin/invoke-rc.d", "--quiet", "--query", "doesnotexist", "start"], {:failonfail => false})
-                             .and_return(Puppet::Util::Execution::ProcessOutput.new("", 1))
-      expect(@provider.enabled?).to be(:false)
-    end
-
-    shared_examples "manually queries service status" do |status|
-      it "links count is 4" do
-        allow(@provider).to receive(:execute).and_return(Puppet::Util::Execution::ProcessOutput.new('', status))
-        allow(@provider).to receive(:get_start_link_count).and_return(4)
-        expect(@provider.enabled?).to eq(:true)
-      end
-      it "links count is less than 4" do
-        allow(@provider).to receive(:execute).and_return(Puppet::Util::Execution::ProcessOutput.new('', status))
-        allow(@provider).to receive(:get_start_link_count).and_return(3)
-        expect(@provider.enabled?).to eq(:false)
-      end
-    end
-
-    context "when invoke-rc.d exits with 101 status" do
-      it_should_behave_like "manually queries service status", 101
-    end
-
-    context "when invoke-rc.d exits with 105 status" do
-      it_should_behave_like "manually queries service status", 105
-    end
-
-    context "when invoke-rc.d exits with 101 status" do
-      it_should_behave_like "manually queries service status", 101
-    end
-
-    context "when invoke-rc.d exits with 105 status" do
-      it_should_behave_like "manually queries service status", 105
-    end
-
-    # pick a range of non-[104.106] numbers, strings and booleans to test with.
-    [-100, -1, 0, 1, 100, "foo", "", :true, :false].each do |exitstatus|
-      it "should return false when invoke-rc.d exits with #{exitstatus} status" do
-        allow(@provider).to receive(:execute).and_return(Puppet::Util::Execution::ProcessOutput.new('', exitstatus))
-        expect(@provider.enabled?).to eq(:false)
-      end
-    end
-  end
-
-  context "when checking service status" do
-    it "should use the service command" do
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return('Debian')
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return('8')
-      allow(@resource).to receive(:[]).with(:hasstatus).and_return(:true)
-      expect(@provider.statuscmd).to eq(["service", @resource[:name], "status"])
-    end
-  end
-end

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

@@ -1,92 +0,0 @@
-require 'spec_helper'
-
-describe 'Puppet::Type::Service::Provider::Freebsd',
-         unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
-  let(:provider_class) { Puppet::Type.type(:service).provider(:freebsd) }
-
-  before :each do
-    @provider = provider_class.new
-    allow(@provider).to receive(:initscript)
-    allow(Facter).to receive(:value).with(:osfamily).and_return('FreeBSD')
-  end
-
-  it "should correctly parse rcvar for FreeBSD < 7" do
-    allow(@provider).to receive(:execute).and_return(<<OUTPUT)
-# ntpd
-$ntpd_enable=YES
-OUTPUT
-    expect(@provider.rcvar).to eq(['# ntpd', 'ntpd_enable=YES'])
-  end
-
-  it "should correctly parse rcvar for FreeBSD 7 to 8" do
-    allow(@provider).to receive(:execute).and_return(<<OUTPUT)
-# ntpd
-ntpd_enable=YES
-OUTPUT
-    expect(@provider.rcvar).to eq(['# ntpd', 'ntpd_enable=YES'])
-  end
-
-  it "should correctly parse rcvar for FreeBSD >= 8.1" do
-    allow(@provider).to receive(:execute).and_return(<<OUTPUT)
-# ntpd
-#
-ntpd_enable="YES"
-#   (default: "")
-OUTPUT
-    expect(@provider.rcvar).to eq(['# ntpd', 'ntpd_enable="YES"', '#   (default: "")'])
-  end
-
-  it "should correctly parse rcvar for DragonFly BSD" do
-    allow(@provider).to receive(:execute).and_return(<<OUTPUT)
-# ntpd
-$ntpd=YES
-OUTPUT
-    expect(@provider.rcvar).to eq(['# ntpd', 'ntpd=YES'])
-  end
-
-  it 'should parse service names with a description' do
-    allow(@provider).to receive(:execute).and_return(<<OUTPUT)
-# local_unbound : local caching forwarding resolver
-local_unbound_enable="YES"
-OUTPUT
-    expect(@provider.service_name).to eq('local_unbound')
-  end
-
-  it 'should parse service names without a description' do
-    allow(@provider).to receive(:execute).and_return(<<OUTPUT)
-# local_unbound
-local_unbound="YES"
-OUTPUT
-    expect(@provider.service_name).to eq('local_unbound')
-  end
-
-  it "should find the right rcvar_value for FreeBSD < 7" do
-    allow(@provider).to receive(:rcvar).and_return(['# ntpd', 'ntpd_enable=YES'])
-
-    expect(@provider.rcvar_value).to eq("YES")
-  end
-
-  it "should find the right rcvar_value for FreeBSD >= 7" do
-    allow(@provider).to receive(:rcvar).and_return(['# ntpd', 'ntpd_enable="YES"', '#   (default: "")'])
-
-    expect(@provider.rcvar_value).to eq("YES")
-  end
-
-  it "should find the right rcvar_name" do
-    allow(@provider).to receive(:rcvar).and_return(['# ntpd', 'ntpd_enable="YES"'])
-
-    expect(@provider.rcvar_name).to eq("ntpd")
-  end
-
-  it "should enable only the selected service" do
-    allow(Puppet::FileSystem).to receive(:exist?).with('/etc/rc.conf').and_return(true)
-    allow(File).to receive(:read).with('/etc/rc.conf').and_return("openntpd_enable=\"NO\"\nntpd_enable=\"NO\"\n")
-    fh = double('fh')
-    allow(Puppet::FileSystem).to receive(:replace_file).with('/etc/rc.conf').and_yield(fh)
-    expect(fh).to receive(:<<).with("openntpd_enable=\"NO\"\nntpd_enable=\"YES\"\n")
-    allow(Puppet::FileSystem).to receive(:exist?).with('/etc/rc.conf.local').and_return(false)
-    allow(Puppet::FileSystem).to receive(:exist?).with('/etc/rc.conf.d/ntpd').and_return(false)
-
-    @provider.rc_replace('ntpd', 'ntpd', 'YES')
-  end
-end