puppet 7.28.0-x64-mingw32 → 7.29.0-x64-mingw32

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

@@ -1,250 +0,0 @@
-require 'spec_helper'
-
-describe 'Puppet::Type::Service::Provider::Gentoo',
-         unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
-  let(:provider_class) { Puppet::Type.type(:service).provider(:gentoo) }
-
-  before :each do
-    allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(provider_class)
-    allow(Puppet::FileSystem).to receive(:file?).with('/sbin/rc-update').and_return(true)
-    allow(Puppet::FileSystem).to receive(:executable?).with('/sbin/rc-update').and_return(true)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return('Gentoo')
-    allow(Facter).to receive(:value).with(:osfamily).and_return('Gentoo')
-
-    # The initprovider (parent of the gentoo provider) does a stat call
-    # before it even tries to execute an initscript. We use sshd in all the
-    # tests so make sure it is considered present.
-    sshd_path = '/etc/init.d/sshd'
-    allow(Puppet::FileSystem).to receive(:stat).with(sshd_path).and_return(double('stat'))
-  end
-
-  let :initscripts do
-    [
-      'alsasound',
-      'bootmisc',
-      'functions.sh',
-      'hwclock',
-      'reboot.sh',
-      'rsyncd',
-      'shutdown.sh',
-      'sshd',
-      'vixie-cron',
-      'wpa_supplicant',
-      'xdm-setup'
-    ]
-  end
-
-  let :helperscripts do
-    [
-      'functions.sh',
-      'reboot.sh',
-      'shutdown.sh'
-    ]
-  end
-
-  let :process_output do
-    Puppet::Util::Execution::ProcessOutput.new('', 0)
-  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 /etc/init.d but exclude helper scripts" do
-      allow(Puppet::FileSystem).to receive(:directory?).and_call_original
-      allow(Puppet::FileSystem).to receive(:directory?).with('/etc/init.d').and_return(true)
-      expect(Dir).to receive(:entries).with('/etc/init.d').and_return(initscripts)
-      (initscripts - helperscripts).each do |script|
-        expect(Puppet::FileSystem).to receive(:executable?).with("/etc/init.d/#{script}").and_return(true)
-      end
-      helperscripts.each do |script|
-        expect(Puppet::FileSystem).not_to receive(:executable?).with("/etc/init.d/#{script}")
-      end
-
-      allow(Puppet::FileSystem).to receive(:symlink?).and_return(false)
-      expect(provider_class.instances.map(&:name)).to eq([
-        'alsasound',
-        'bootmisc',
-        'hwclock',
-        'rsyncd',
-        'sshd',
-        'vixie-cron',
-        'wpa_supplicant',
-        '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 <initscript> start otherwise" do
-      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:execute).with(['/etc/init.d/sshd',:start], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
-      expect(provider).to receive(:search).with('sshd').and_return('/etc/init.d/sshd')
-      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 <initscript> stop otherwise" do
-      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:execute).with(['/etc/init.d/sshd',:stop], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
-      expect(provider).to receive(:search).with('sshd').and_return('/etc/init.d/sshd')
-      provider.stop
-    end
-  end
-
-  describe "#enabled?" do
-    before :each do
-      allow_any_instance_of(provider_class).to receive(:update).with(:show).and_return(File.read(my_fixture('rc_update_show')))
-    end
-
-    it "should run rc-update show to get a list of enabled services" do
-      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:update).with(:show).and_return("\n")
-      provider.enabled?
-    end
-
-    ['hostname', 'net.lo', 'procfs'].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
-
-    ['alsasound', 'xdm', 'netmount'].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
-
-    ['rsyncd', 'lighttpd', 'mysql'].each do |service|
-      it "should consider unused service #{service} 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(:update).with(:add, 'sshd', :default)
-      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(:update).with(:del, 'sshd', :default)
-      provider.disable
-    end
-  end
-
-  describe "#status" do
-    describe "when a special status command is 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(['/etc/init.d/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(process_output)
-        provider.status
-      end
-
-      it "should return :stopped when the 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(['/etc/init.d/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 the 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(['/etc/init.d/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(process_output)
-        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(['/etc/init.d/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(['/etc/init.d/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 <initscript> status exits with a zero exitcode" do
-        provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => true))
-        expect(provider).to receive(:search).with('sshd').and_return('/etc/init.d/sshd')
-        expect(provider).to receive(:execute)
-          .with(['/etc/init.d/sshd',:status], {:failonfail => false, :override_locale => false, :squelch => false, :combine => true})
-          .and_return(process_output)
-        expect(provider.status).to eq(:running)
-      end
-
-      it "should return stopped if <initscript> 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(:search).with('sshd').and_return('/etc/init.d/sshd')
-        expect(provider).to receive(:execute)
-          .with(['/etc/init.d/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(['/etc/init.d/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 <initscript> restart if hasrestart is true" do
-      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => true))
-      expect(provider).to receive(:search).with('sshd').and_return('/etc/init.d/sshd')
-      expect(provider).to receive(:execute).with(['/etc/init.d/sshd',:restart], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
-      provider.restart
-    end
-
-    it "should restart the service with <initscript> stop/start if hasrestart is false" do
-      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => false))
-      expect(provider).to receive(:search).with('sshd').and_return('/etc/init.d/sshd')
-      expect(provider).not_to receive(:execute).with(['/etc/init.d/sshd',:restart], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
-      expect(provider).to receive(:execute).with(['/etc/init.d/sshd',:stop], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
-      expect(provider).to receive(:execute).with(['/etc/init.d/sshd',:start], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
-      provider.restart
-    end
-  end
-end

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

@@ -1,316 +0,0 @@
-require 'spec_helper'
-
-describe 'Puppet::Type::Service::Provider::Init',
-         unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
-  let(:provider_class) { Puppet::Type.type(:service).provider(:init) }
-
-  before do
-    Puppet::Type.type(:service).defaultprovider = provider_class
-  end
-
-  after do
-    Puppet::Type.type(:service).defaultprovider = nil
-  end
-
-  let :provider do
-    resource.provider
-  end
-
-  let :resource do
-    Puppet::Type.type(:service).new(
-      :name     => 'myservice',
-      :ensure   => :running,
-      :path     => paths
-    )
-  end
-
-  let :paths do
-    ["/service/path","/alt/service/path"]
-  end
-
-  let :excludes do
-    # Taken from redhat, gentoo, and debian
-    %w{functions.sh reboot.sh shutdown.sh functions halt killall single linuxconf reboot boot wait-for-state rcS module-init-tools}
-  end
-
-  let :process_output do
-    Puppet::Util::Execution::ProcessOutput.new('', 0)
-  end
-
-  describe "when running on FreeBSD" do
-    before :each do
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return('FreeBSD')
-      allow(Facter).to receive(:value).with(:osfamily).and_return('FreeBSD')
-    end
-
-    it "should set its default path to include /etc/rc.d and /usr/local/etc/rc.d" do
-      expect(provider_class.defpath).to eq(["/etc/rc.d", "/usr/local/etc/rc.d"])
-    end
-  end
-
-  describe "when running on HP-UX" do
-    before :each do
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return('HP-UX')
-    end
-
-    it "should set its default path to include /sbin/init.d" do
-      expect(provider_class.defpath).to eq("/sbin/init.d")
-    end
-  end
-
-  describe "when running on Archlinux" do
-    before :each do
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return('Archlinux')
-    end
-
-    it "should set its default path to include /etc/rc.d" do
-      expect(provider_class.defpath).to eq("/etc/rc.d")
-    end
-  end
-
-  describe "when not running on FreeBSD, HP-UX or Archlinux" do
-    before :each do
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return('RedHat')
-    end
-
-    it "should set its default path to include /etc/init.d" do
-      expect(provider_class.defpath).to eq("/etc/init.d")
-    end
-  end
-
-  describe "when getting all service instances" do
-    before :each do
-      allow(provider_class).to receive(:defpath).and_return('tmp')
-
-      @services = ['one', 'two', 'three', 'four', 'umountfs']
-      allow(Dir).to receive(:entries).and_call_original
-      allow(Dir).to receive(:entries).with('tmp').and_return(@services)
-      allow(Puppet::FileSystem).to receive(:directory?).and_call_original
-      allow(Puppet::FileSystem).to receive(:directory?).with('tmp').and_return(true)
-      allow(Puppet::FileSystem).to receive(:executable?).and_return(true)
-    end
-
-    it "should return instances for all services" do
-      expect(provider_class.instances.map(&:name)).to eq(@services)
-    end
-
-    it "should omit directories from the service list" do
-      expect(Puppet::FileSystem).to receive(:directory?).with('tmp/four').and_return(true)
-      expect(provider_class.instances.map(&:name)).to eq(@services - ['four'])
-    end
-
-    it "should omit an array of services from exclude list" do
-      exclude = ['two', 'four']
-      expect(provider_class.get_services(provider_class.defpath, exclude).map(&:name)).to eq(@services - exclude)
-    end
-
-    it "should omit a single service from the exclude list" do
-      exclude = 'two'
-      expect(provider_class.get_services(provider_class.defpath, exclude).map(&:name)).to eq(@services - [exclude])
-    end
-
-    it "should omit Yocto services on cisco-wrlinux" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return('cisco-wrlinux')
-      exclude = 'umountfs'
-      expect(provider_class.get_services(provider_class.defpath).map(&:name)).to eq(@services - [exclude])
-    end
-
-    it "should not omit Yocto services on non cisco-wrlinux platforms" do
-      expect(provider_class.get_services(provider_class.defpath).map(&:name)).to eq(@services)
-    end
-
-    it "should use defpath" do
-      expect(provider_class.instances).to be_all { |provider| provider.get(:path) == provider_class.defpath }
-    end
-
-    it "should set hasstatus to true for providers" do
-      expect(provider_class.instances).to be_all { |provider| provider.get(:hasstatus) == true }
-    end
-
-    it "should discard upstart jobs", :if => Puppet.features.manages_symlinks? do
-      not_init_service, *valid_services = @services
-      path = "tmp/#{not_init_service}"
-      allow(Puppet::FileSystem).to receive(:symlink?).at_least(:once).and_return(false)
-      allow(Puppet::FileSystem).to receive(:symlink?).with(Puppet::FileSystem.pathname(path)).and_return(true)
-      allow(Puppet::FileSystem).to receive(:readlink).with(Puppet::FileSystem.pathname(path)).and_return("/lib/init/upstart-job")
-      expect(provider_class.instances.map(&:name)).to eq(valid_services)
-    end
-
-    it "should discard non-initscript scripts" do
-      valid_services = @services
-      all_services = valid_services + excludes
-      expect(Dir).to receive(:entries).with('tmp').and_return(all_services)
-      expect(provider_class.instances.map(&:name)).to match_array(valid_services)
-    end
-  end
-
-  describe "when checking valid paths" do
-    it "should discard paths that do not exist" do
-      expect(Puppet::FileSystem).to receive(:directory?).with(paths[0]).and_return(false)
-      expect(Puppet::FileSystem).to receive(:exist?).with(paths[0]).and_return(false)
-      expect(Puppet::FileSystem).to receive(:directory?).with(paths[1]).and_return(true)
-
-      expect(provider.paths).to eq([paths[1]])
-    end
-
-    it "should discard paths that are not directories" do
-      paths.each do |path|
-        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
-        expect(Puppet::FileSystem).to receive(:directory?).with(path).and_return(false)
-      end
-      expect(provider.paths).to be_empty
-    end
-  end
-
-  describe "when searching for the init script" do
-    before :each do
-      paths.each {|path| expect(Puppet::FileSystem).to receive(:directory?).with(path).and_return(true) }
-    end
-
-    it "should be able to find the init script in the service path" do
-      expect(Puppet::FileSystem).to receive(:exist?).with("#{paths[0]}/myservice").and_return(true)
-      expect(Puppet::FileSystem).not_to receive(:exist?).with("#{paths[1]}/myservice") # first one wins
-      expect(provider.initscript).to eq("/service/path/myservice")
-    end
-
-    it "should be able to find the init script in an alternate service path" do
-      expect(Puppet::FileSystem).to receive(:exist?).with("#{paths[0]}/myservice").and_return(false)
-      expect(Puppet::FileSystem).to receive(:exist?).with("#{paths[1]}/myservice").and_return(true)
-      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
-      expect(Puppet::FileSystem).to receive(:exist?).with("#{paths[0]}/myservice").and_return(false)
-      expect(Puppet::FileSystem).to receive(:exist?).with("#{paths[1]}/myservice").and_return(false)
-      expect(Puppet::FileSystem).to receive(:exist?).with("#{paths[0]}/myservice.sh").and_return(true)
-      expect(provider.initscript).to eq("/service/path/myservice.sh")
-    end
-
-    it "should fail if the service isn't there" do
-      paths.each do |path|
-        expect(Puppet::FileSystem).to receive(:exist?).with("#{path}/myservice").and_return(false)
-        expect(Puppet::FileSystem).to receive(:exist?).with("#{path}/myservice.sh").and_return(false)
-      end
-      expect { provider.initscript }.to raise_error(Puppet::Error, "Could not find init script for 'myservice'")
-    end
-  end
-
-  describe "if the init script is present" do
-    before :each do
-      allow(Puppet::FileSystem).to receive(:directory?).and_call_original
-      allow(Puppet::FileSystem).to receive(:directory?).with("/service/path").and_return(true)
-      allow(Puppet::FileSystem).to receive(:directory?).with("/alt/service/path").and_return(true)
-      allow(Puppet::FileSystem).to receive(:exist?).with("/service/path/myservice").and_return(true)
-    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
-        before :each do
-          allow(provider).to receive(:execute).and_return(process_output)
-        end
-
-        it "should use any provided explicit command" do
-          resource[method] = "/user/specified/command"
-          expect(provider).to receive(:execute).with(["/user/specified/command"], any_args).and_return(process_output)
-
-          provider.send(method)
-        end
-
-        it "should pass #{method} to the init script when no explicit command is provided" do
-          resource[:hasrestart] = :true
-          resource[:hasstatus] = :true
-          expect(provider).to receive(:execute).with(["/service/path/myservice", method], any_args).and_return(process_output)
-
-          provider.send(method)
-        end
-      end
-    end
-
-    describe "when checking status" do
-      describe "when hasstatus is :true" do
-        before :each do
-          resource[:hasstatus] = :true
-        end
-
-        it "should execute the command" do
-          expect(provider).to receive(:execute)
-            .with(['/service/path/myservice', :status], hash_including(failonfail: false))
-            .and_return(process_output)
-          provider.status
-        end
-
-        it "should consider the process running if the command returns 0" do
-          expect(provider).to receive(:execute)
-            .with(['/service/path/myservice', :status], hash_including(failonfail: false))
-            .and_return(process_output)
-          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(['/service/path/myservice', :status], hash_including(failonfail: false))
-              .and_return(Puppet::Util::Execution::ProcessOutput.new('', ec))
-            expect(provider.status).to eq(:stopped)
-          end
-        }
-      end
-
-      describe "when hasstatus is not :true" do
-        before :each do
-          resource[:hasstatus] = :false
-        end
-
-        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
-
-    describe "when restarting and hasrestart is not :true" do
-      before :each do
-        resource[:hasrestart] = :false
-      end
-
-      it "should stop and restart the process" do
-        expect(provider).to receive(:execute)
-          .with(['/service/path/myservice', :stop], hash_including(failonfail: true))
-          .and_return(process_output)
-        expect(provider).to receive(:execute)
-          .with(['/service/path/myservice', :start], hash_including(failonfail: true))
-          .and_return(process_output)
-        provider.restart
-      end
-    end
-
-    describe "when starting a service on Solaris" do
-      it "should use ctrun" do
-        allow(Facter).to receive(:value).with(:osfamily).and_return('Solaris')
-        expect(provider).to receive(:execute)
-          .with('/usr/bin/ctrun -l child /service/path/myservice start', {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
-          .and_return(process_output)
-        provider.start
-      end
-    end
-
-    describe "when starting a service on RedHat" do
-      it "should not use ctrun" do
-        allow(Facter).to receive(:value).with(:osfamily).and_return('RedHat')
-        expect(provider).to receive(:execute)
-          .with(['/service/path/myservice', :start], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
-          .and_return(process_output)
-        provider.start
-      end
-    end
-  end
-end