puppet 7.28.0-x64-mingw32 → 7.29.1-x64-mingw32

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

@@ -1,231 +0,0 @@
-require 'spec_helper'
-
-describe 'Puppet::Type::Service::Provider::Openrc',
-         unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
-  let(:provider_class) { Puppet::Type.type(:service).provider(:openrc) }
-
-  before :each do
-    allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(provider_class)
-    ['/sbin/rc-service', '/bin/rc-status', '/sbin/rc-update'].each do |command|
-      # Puppet::Util is both mixed in to providers and is also invoked directly
-      # by Puppet::Provider::CommandDefiner, so we have to stub both out.
-      allow(provider_class).to receive(:which).with(command).and_return(command)
-      allow(Puppet::Util).to receive(:which).with(command).and_return(command)
-    end
-  end
-
-  describe ".instances" do
-    it "should have an instances method" do
-      expect(provider_class).to respond_to :instances
-    end
-
-    it "should get a list of services from rc-service --list" do
-      expect(provider_class).to receive(:rcservice).with('-C','--list').and_return(File.read(my_fixture('rcservice_list')))
-      expect(provider_class.instances.map(&:name)).to eq([
-        'alsasound',
-        'consolefont',
-        'lvm-monitoring',
-        'pydoc-2.7',
-        'pydoc-3.2',
-        'wpa_supplicant',
-        'xdm',
-        'xdm-setup'
-      ])
-    end
-  end
-
-  describe "#start" do
-    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 service with rc-service start otherwise" do
-      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:execute).with(['/sbin/rc-service','sshd',:start], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
-      provider.start
-    end
-  end
-
-  describe "#stop" do
-    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 service with rc-service stop otherwise" do
-      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:execute).with(['/sbin/rc-service','sshd',:stop], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
-      provider.stop
-    end
-  end
-
-  describe 'when invoking `rc-status`' do
-    subject { provider_class.new(Puppet::Type.type(:service).new(:name => 'urandom')) }
-
-    it "clears the RC_SVCNAME environment variable" do
-      Puppet::Util.withenv(:RC_SVCNAME => 'puppet') do
-        expect(Puppet::Util::Execution).to receive(:execute).with(
-          include('/bin/rc-status'),
-          hash_including(custom_environment:  hash_including(RC_SVCNAME: nil))
-        ).and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-
-        subject.enabled?
-      end
-    end
-  end
-
-  describe "#enabled?" do
-    before :each do
-      allow_any_instance_of(provider_class).to receive(:rcstatus).with('-C','-a').and_return(File.read(my_fixture('rcstatus')))
-    end
-
-    it "should run rc-status to get a list of enabled services" do
-      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:rcstatus).with('-C','-a').and_return("\n")
-      provider.enabled?
-    end
-
-    ['hwclock', 'modules', 'urandom'].each do |service|
-      it "should consider service #{service} in runlevel boot as enabled" do
-        provider = provider_class.new(Puppet::Type.type(:service).new(:name => service))
-        expect(provider.enabled?).to eq(:true)
-      end
-    end
-
-    ['netmount', 'xdm', 'local', 'foo_with_very_very_long_servicename_no_still_not_the_end_wait_for_it_almost_there_almost_there_now_finally_the_end'].each do |service|
-      it "should consider service #{service} in runlevel default as enabled" do
-        provider = provider_class.new(Puppet::Type.type(:service).new(:name => service))
-        expect(provider.enabled?).to eq(:true)
-      end
-    end
-
-    ['net.eth0', 'pcscd'].each do |service|
-      it "should consider service #{service} in dynamic runlevel: hotplugged as disabled" do
-        provider = provider_class.new(Puppet::Type.type(:service).new(:name => service))
-        expect(provider.enabled?).to eq(:false)
-      end
-    end
-
-    ['sysfs', 'udev-mount'].each do |service|
-      it "should consider service #{service} in dynamic runlevel: needed as disabled" do
-        provider = provider_class.new(Puppet::Type.type(:service).new(:name => service))
-        expect(provider.enabled?).to eq(:false)
-      end
-    end
-
-    ['sshd'].each do |service|
-      it "should consider service #{service} in dynamic runlevel: manual as disabled" do
-        provider = provider_class.new(Puppet::Type.type(:service).new(:name => service))
-        expect(provider.enabled?).to eq(:false)
-      end
-    end
-
-  end
-
-  describe "#enable" do
-    it "should run rc-update add to enable a service" do
-      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:rcupdate).with('-C', :add, 'sshd')
-      provider.enable
-    end
-  end
-
-  describe "#disable" do
-    it "should run rc-update del to disable a service" do
-      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:rcupdate).with('-C', :del, 'sshd')
-      provider.disable
-    end
-  end
-
-  describe "#status" do
-    describe "when a special status command if specified" do
-      it "should use the status command from the resource" do
-        provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
-        expect(provider).not_to receive(:execute).with(['/sbin/rc-service','sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
-        expect(provider).to receive(:execute)
-          .with(['/bin/foo'], {:failonfail => false, :override_locale => false, :squelch => false, :combine => true})
-          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-        provider.status
-      end
-
-      it "should return :stopped when status command returns with a non-zero exitcode" do
-        provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
-        expect(provider).not_to receive(:execute).with(['/sbin/rc-service','sshd',:status], {:failonfail => false, :override_locale => false, :squelch => false, :combine => true})
-        expect(provider).to receive(:execute)
-          .with(['/bin/foo'], {:failonfail => false, :override_locale => false, :squelch => false, :combine => true})
-          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 3))
-        expect(provider.status).to eq(:stopped)
-      end
-
-      it "should return :running when status command returns with a zero exitcode" do
-        provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
-        expect(provider).not_to receive(:execute).with(['/sbin/rc-service','sshd',:status], {:failonfail => false, :override_locale => false, :squelch => false, :combine => true})
-        expect(provider).to receive(:execute)
-          .with(['/bin/foo'], {:failonfail => false, :override_locale => false, :squelch => false, :combine => true})
-          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-        expect(provider.status).to eq(:running)
-      end
-    end
-
-    describe "when hasstatus is false" do
-      it "should return running if a pid can be found" do
-        provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => false))
-        expect(provider).not_to receive(:execute).with(['/sbin/rc-service','sshd',:status], {:failonfail => false, :override_locale => false, :squelch => false, :combine => true})
-        expect(provider).to receive(:getpid).and_return(1000)
-        expect(provider.status).to eq(:running)
-      end
-
-      it "should return stopped if no pid can be found" do
-        provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => false))
-        expect(provider).not_to receive(:execute).with(['/sbin/rc-service','sshd',:status], {:failonfail => false, :override_locale => false, :squelch => false, :combine => true})
-        expect(provider).to receive(:getpid).and_return(nil)
-        expect(provider.status).to eq(:stopped)
-      end
-    end
-
-    describe "when hasstatus is true" do
-      it "should return running if rc-service status exits with a zero exitcode" do
-        provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => true))
-        expect(provider).to receive(:execute)
-          .with(['/sbin/rc-service','sshd',:status], {:failonfail => false, :override_locale => false, :squelch => false, :combine => true})
-          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-        expect(provider.status).to eq(:running)
-      end
-
-      it "should return stopped if rc-service status exits with a non-zero exitcode" do
-        provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => true))
-        expect(provider).to receive(:execute)
-          .with(['/sbin/rc-service','sshd',:status], {:failonfail => false, :override_locale => false, :squelch => false, :combine => true})
-          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 3))
-        expect(provider.status).to eq(:stopped)
-      end
-    end
-  end
-
-  describe "#restart" do
-    it "should use the supplied restart command if specified" do
-      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :restart => '/bin/foo'))
-      expect(provider).not_to receive(:execute).with(['/sbin/rc-service','sshd',:restart], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
-      expect(provider).to receive(: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
-      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => true))
-      expect(provider).to receive(:execute).with(['/sbin/rc-service','sshd',:restart], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
-      provider.restart
-    end
-
-    it "should restart the service with rc-service stop/start if hasrestart is false" do
-      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => false))
-      expect(provider).not_to receive(:execute).with(['/sbin/rc-service','sshd',:restart], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
-      expect(provider).to receive(:execute).with(['/sbin/rc-service','sshd',:stop], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
-      expect(provider).to receive(:execute).with(['/sbin/rc-service','sshd',:start], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
-      provider.restart
-    end
-  end
-end

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

@@ -1,101 +0,0 @@
-require 'spec_helper'
-
-describe 'Puppet::Type::Service::Provider::Openwrt',
-         unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
-
-  let(:provider_class) { Puppet::Type.type(:service).provider(:openwrt) }
-
-  let(:resource) do
-    Puppet::Type.type(:service).new(
-      :name       => 'myservice',
-      :path       => '/etc/init.d',
-      :hasrestart => true,
-    )
-  end
-
-  let(:provider) do
-    provider = provider_class.new
-    provider.resource = resource
-    provider
-  end
-
-  before :each do
-    resource.provider = provider
-
-    # All OpenWrt tests operate on the init script directly. It must exist.
-    allow(Puppet::FileSystem).to receive(:directory?).and_call_original
-    allow(Puppet::FileSystem).to receive(:directory?).with('/etc/init.d').and_return(true)
-
-    allow(Puppet::FileSystem).to receive(:exist?).with('/etc/init.d/myservice').and_return(true)
-    allow(Puppet::FileSystem).to receive(:file?).and_call_original
-    allow(Puppet::FileSystem).to receive(:file?).with('/etc/init.d/myservice').and_return(true)
-    allow(Puppet::FileSystem).to receive(:executable?).with('/etc/init.d/myservice').and_return(true)
-  end
-
-  it "should be the default provider on 'openwrt'" do
-    expect(Facter).to receive(:value).with(:operatingsystem).and_return('openwrt')
-    expect(provider_class.default?).to be_truthy
-  end
-
-  # test self.instances
-  describe "when getting all service instances" do
-    let(:services) { ['dnsmasq', 'dropbear', 'firewall', 'led', 'puppet', 'uhttpd' ] }
-
-    before :each do
-      allow(Dir).to receive(:entries).and_call_original
-      allow(Dir).to receive(:entries).with('/etc/init.d').and_return(services)
-      allow(Puppet::FileSystem).to receive(:executable?).and_return(true)
-    end
-
-    it "should return instances for all services" do
-      services.each do |inst|
-        expect(provider_class).to receive(:new).with(hash_including(:name => inst, :path => '/etc/init.d')).and_return("#{inst}_instance")
-      end
-      results = services.collect { |x| "#{x}_instance"}
-      expect(provider_class.instances).to eq(results)
-    end
-  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
-
-  [:start, :stop, :restart].each do |method|
-    it "should have a #{method} method" do
-      expect(provider).to respond_to(method)
-    end
-
-    describe "when running #{method}" do
-      it "should use any provided explicit command" do
-        resource[method] = '/user/specified/command'
-        expect(provider).to receive(:execute).with(['/user/specified/command'], any_args)
-        provider.send(method)
-      end
-
-      it "should execute the init script with #{method} when no explicit command is provided" do
-        expect(provider).to receive(:execute).with(['/etc/init.d/myservice', method], any_args)
-        provider.send(method)
-      end
-    end
-  end
-
-  describe "when checking status" do
-    it "should consider the service :running if it has a pid" do
-      expect(provider).to receive(:getpid).and_return("1234")
-      expect(provider.status).to eq(:running)
-    end
-
-    it "should consider the service :stopped if it doesn't have a pid" do
-      expect(provider).to receive(:getpid).and_return(nil)
-      expect(provider.status).to eq(:stopped)
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe 'Puppet::Type::Service::Provider::Rcng',
-         unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
-  let(:provider_class) { Puppet::Type.type(:service).provider(:rcng) }
-
-  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.d')
-    @provider = provider_class.new
-    allow(@provider).to receive(:initscript)
-  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')
-      expect(Puppet::Util).to receive(:replace_file).with('/etc/rc.conf.d/sshd', 0644).and_yield(fh)
-      expect(fh).to receive(:puts).with("sshd=${sshd:=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')
-      expect(Puppet::Util).to receive(:replace_file).with('/etc/rc.conf.d/sshd', 0644).and_yield(fh)
-      expect(fh).to receive(:puts).with("sshd=${sshd:=YES}\n")
-      provider.enable
-    end
-  end
-end

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

@@ -1,190 +0,0 @@
-require 'spec_helper'
-
-describe 'Puppet::Type::Service::Provider::Redhat',
-         unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
-  let(:provider_class) { Puppet::Type.type(:service).provider(:redhat) }
-
-  before :each do
-    @class = Puppet::Type.type(:service).provider(:redhat)
-    @resource = double('resource')
-    allow(@resource).to receive(:[]).and_return(nil)
-    allow(@resource).to receive(:[]).with(:name).and_return("myservice")
-    @provider = provider_class.new
-    allow(@resource).to receive(:provider).and_return(@provider)
-    @provider.resource = @resource
-    allow(@provider).to receive(:get).with(:hasstatus).and_return(false)
-    allow(FileTest).to receive(:file?).with('/sbin/service').and_return(true)
-    allow(FileTest).to receive(:executable?).with('/sbin/service').and_return(true)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return('CentOS')
-    allow(Facter).to receive(:value).with(:osfamily).and_return('RedHat')
-  end
-
-  osfamilies = [ 'RedHat' ]
-
-  osfamilies.each do |osfamily|
-    it "should be the default provider on #{osfamily}" do
-      expect(Facter).to receive(:value).with(:osfamily).and_return(osfamily)
-      expect(provider_class.default?).to be_truthy
-    end
-  end
-
-  it "should be the default provider on sles11" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:suse)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:suse)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("11")
-    expect(provider_class.default?).to be_truthy
-  end
-
-  # test self.instances
-  context "when getting all service instances" do
-    before :each do
-      @services = ['one', 'two', 'three', 'four', 'kudzu', 'functions', 'halt', 'killall', 'single', 'linuxconf', 'boot', 'reboot']
-      @not_services = ['functions', 'halt', 'killall', 'single', 'linuxconf', 'reboot', 'boot']
-      allow(Dir).to receive(:entries).and_return(@services)
-      allow(Puppet::FileSystem).to receive(:directory?).and_call_original
-      allow(Puppet::FileSystem).to receive(:directory?).with('/etc/init.d').and_return(true)
-      allow(Puppet::FileSystem).to receive(:executable?).and_return(true)
-    end
-
-    it "should return instances for all services" do
-      (@services-@not_services).each do |inst|
-        expect(@class).to receive(:new).with(hash_including(name: inst, path: '/etc/init.d')).and_return("#{inst}_instance")
-      end
-      results = (@services-@not_services).collect {|x| "#{x}_instance"}
-      expect(@class.instances).to eq(results)
-    end
-
-    it "should call service status when initialized from provider" do
-      allow(@resource).to receive(:[]).with(:status).and_return(nil)
-      allow(@provider).to receive(:get).with(:hasstatus).and_return(true)
-      expect(@provider).to receive(:execute)
-        .with(['/sbin/service', 'myservice', 'status'], any_args)
-        .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-      @provider.send(:status)
-    end
-  end
-
-  it "should use '--add' and 'on' when calling enable" do
-    expect(provider_class).to receive(:chkconfig).with("--add", @resource[:name])
-    expect(provider_class).to receive(:chkconfig).with(@resource[:name], :on)
-    @provider.enable
-  end
-
-  it "(#15797) should explicitly turn off the service in all run levels" do
-    expect(provider_class).to receive(:chkconfig).with("--level", "0123456", @resource[:name], :off)
-    @provider.disable
-  end
-
-  it "should have an enabled? method" do
-    expect(@provider).to respond_to(:enabled?)
-  end
-
-  context "when checking enabled? on Suse" do
-    before :each do
-      expect(Facter).to receive(:value).with(:osfamily).and_return('Suse')
-    end
-
-    it "should check for on" do
-      allow(provider_class).to receive(:chkconfig).with(@resource[:name]).and_return("#{@resource[:name]}  on")
-      expect(@provider.enabled?).to eq(:true)
-    end
-
-    it "should check for B" do
-      allow(provider_class).to receive(:chkconfig).with(@resource[:name]).and_return("#{@resource[:name]}  B")
-      expect(@provider.enabled?).to eq(:true)
-    end
-
-    it "should check for off" do
-      allow(provider_class).to receive(:chkconfig).with(@resource[:name]).and_return("#{@resource[:name]}  off")
-      expect(@provider.enabled?).to eq(:false)
-    end
-
-    it "should check for unknown service" do
-      allow(provider_class).to receive(:chkconfig).with(@resource[:name]).and_return("#{@resource[:name]}: unknown service")
-      expect(@provider.enabled?).to eq(:false)
-    end
-  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
-
-  [:start, :stop, :status, :restart].each do |method|
-    it "should have a #{method} method" do
-      expect(@provider).to respond_to(method)
-    end
-
-    describe "when running #{method}" do
-      it "should use any provided explicit command" do
-        allow(@resource).to receive(:[]).with(method).and_return("/user/specified/command")
-        expect(@provider).to receive(:execute)
-          .with(["/user/specified/command"], any_args)
-          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-        @provider.send(method)
-      end
-
-      it "should execute the service script with #{method} when no explicit command is provided" do
-        allow(@resource).to receive(:[]).with("has#{method}".intern).and_return(:true)
-        expect(@provider).to receive(:execute)
-          .with(['/sbin/service', 'myservice', method.to_s], any_args)
-          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-        @provider.send(method)
-      end
-    end
-  end
-
-  context "when checking status" do
-    context "when hasstatus is :true" do
-      before :each do
-        allow(@resource).to receive(:[]).with(:hasstatus).and_return(:true)
-      end
-
-      it "should execute the service script with fail_on_failure false" do
-        expect(@provider).to receive(:execute)
-          .with(['/sbin/service', 'myservice', 'status'], any_args)
-          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-        @provider.status
-      end
-
-      it "should consider the process running if the command returns 0" do
-        expect(@provider).to receive(:execute)
-          .with(['/sbin/service', 'myservice', 'status'], hash_including(failonfail: false))
-          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-        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
-          expect(@provider).to receive(:execute)
-            .with(['/sbin/service', 'myservice', 'status'], hash_including(failonfail: false))
-            .and_return(Puppet::Util::Execution::ProcessOutput.new('', ec))
-          expect(@provider.status).to eq(:stopped)
-        end
-      }
-    end
-
-    context "when hasstatus is not :true" do
-      it "should consider the service :running if it has a pid" do
-        expect(@provider).to receive(:getpid).and_return("1234")
-        expect(@provider.status).to eq(:running)
-      end
-
-      it "should consider the service :stopped if it doesn't have a pid" do
-        expect(@provider).to receive(:getpid).and_return(nil)
-        expect(@provider.status).to eq(:stopped)
-      end
-    end
-  end
-
-  context "when restarting and hasrestart is not :true" do
-    it "should stop and restart the process with the server script" do
-      expect(@provider).to receive(:execute).with(['/sbin/service', 'myservice', 'stop'], hash_including(failonfail: true))
-      expect(@provider).to receive(:execute).with(['/sbin/service', 'myservice', 'start'], hash_including(failonfail: true))
-      @provider.restart
-    end
-  end
-end