puppet 5.3.4 → 6.29.0

data/spec/integration/file_system/uniquefile_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::FileSystem::Uniquefile do
-
-  describe "#open_tmp on Windows", :if => Puppet.features.microsoft_windows? do
-
-    describe "with UTF8 characters" do
-      include PuppetSpec::Files
-
-      let(:rune_utf8) { "\u16A0\u16C7\u16BB\u16EB\u16D2\u16E6\u16A6\u16EB\u16A0\u16B1\u16A9\u16A0\u16A2\u16B1\u16EB\u16A0\u16C1\u16B1\u16AA\u16EB\u16B7\u16D6\u16BB\u16B9\u16E6\u16DA\u16B3\u16A2\u16D7" }
-      let(:temp_rune_utf8) { tmpdir(rune_utf8) }
-
-      it "should use UTF8 characters in TMP,TEMP,TMPDIR environment variable" do
-        # Set the temporary environment variables to the UTF8 temp path
-        Puppet::Util::Windows::Process.set_environment_variable('TMPDIR', temp_rune_utf8)
-        Puppet::Util::Windows::Process.set_environment_variable('TMP', temp_rune_utf8)
-        Puppet::Util::Windows::Process.set_environment_variable('TEMP', temp_rune_utf8)
-
-        # Create a unique file
-        filename = Puppet::FileSystem::Uniquefile.open_tmp('foo') do |file|
-          File.dirname(file.path)
-        end
-
-        expect(filename).to eq(temp_rune_utf8)
-      end
-    end
-  end
-
-end

data/spec/integration/indirector/node/ldap_spec.rb

@@ -1,14 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-require 'puppet/indirector/node/ldap'
-
-describe Puppet::Node::Ldap do
-  it "should use a restrictive filter when searching for nodes in a class" do
-    ldap = Puppet::Node.indirection.terminus(:ldap)
-    Puppet::Node.indirection.stubs(:terminus).returns ldap
-    ldap.expects(:ldapsearch).with("(&(objectclass=puppetClient)(puppetclass=foo))")
-
-    Puppet::Node.indirection.search "eh", :class => "foo"
-  end
-end

data/spec/integration/module_tool/tar/mini_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-require 'puppet/module_tool'
-require 'puppet_spec/files'
-
-describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? && Puppet.features.zlib?) do
-  let(:minitar)    { described_class.new }
-
-  describe "Extracts tars with long and short pathnames" do
-    let (:sourcetar) { File.expand_path('../../../../fixtures/module.tar.gz', __FILE__) }
-
-    let (:longfilepath)  { "puppetlabs-dsc-1.0.0/lib/puppet_x/dsc_resources/xWebAdministration/DSCResources/MSFT_xWebAppPoolDefaults/MSFT_xWebAppPoolDefaults.schema.mof" }
-    let (:shortfilepath) { "puppetlabs-dsc-1.0.0/README.md" }
-
-    it "unpacks a tar with a short path length" do
-      extractdir = PuppetSpec::Files.tmpdir('minitar')
-
-      minitar.unpack(sourcetar,extractdir,'module')
-      expect(File).to exist(File.expand_path("#{extractdir}/#{shortfilepath}"))
-    end
-
-    it "unpacks a tar with a long path length" do
-      extractdir = PuppetSpec::Files.tmpdir('minitar')
-
-      minitar.unpack(sourcetar,extractdir,'module')
-      expect(File).to exist(File.expand_path("#{extractdir}/#{longfilepath}"))
-    end
-  end
-end

data/spec/integration/provider/cron/crontab_spec.rb

@@ -1,242 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'spec_helper'
-require 'puppet/file_bucket/dipper'
-require 'puppet_spec/compiler'
-
-describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless => Puppet.features.microsoft_windows? do
-  include PuppetSpec::Files
-  include PuppetSpec::Compiler
-
-  before :each do
-    Puppet::Type.type(:cron).stubs(:defaultprovider).returns described_class
-    described_class.stubs(:suitable?).returns true
-    Puppet::FileBucket::Dipper.any_instance.stubs(:backup) # Don't backup to filebucket
-
-    # I don't want to execute anything
-    described_class.stubs(:filetype).returns Puppet::Util::FileType::FileTypeFlat
-    described_class.stubs(:default_target).returns crontab_user1
-
-    # I don't want to stub Time.now to get a static header because I don't know
-    # where Time.now is used elsewhere, so just go with a very simple header
-    described_class.stubs(:header).returns "# HEADER: some simple\n# HEADER: header\n"
-    FileUtils.cp(my_fixture('crontab_user1'), crontab_user1)
-    FileUtils.cp(my_fixture('crontab_user2'), crontab_user2)
-  end
-
-  after :each do
-    described_class.clear
-  end
-
-  let :crontab_user1 do
-    tmpfile('cron_integration_specs')
-  end
-
-  let :crontab_user2 do
-    tmpfile('cron_integration_specs')
-  end
-
-  def expect_output(fixture_name)
-    expect(File.read(crontab_user1)).to eq(File.read(my_fixture(fixture_name)))
-  end
-
-  describe "when managing a cron entry" do
-
-    it "should be able to purge unmanaged entries" do
-      apply_with_error_check(<<-MANIFEST)
-      cron {
-        'only managed entry':
-          ensure      => 'present',
-          command     => '/bin/true',
-          target      => '#{crontab_user1}',
-      }
-      resources { 'cron': purge => 'true' }
-      MANIFEST
-      expect_output('purged')
-    end
-
-    describe "with ensure absent" do
-      it "should do nothing if entry already absent" do
-        apply_with_error_check(<<-MANIFEST)
-        cron {
-          'no_such_entry':
-            ensure => 'absent',
-            target => '#{crontab_user1}',
-        }
-        MANIFEST
-        expect_output('crontab_user1')
-      end
-
-      it "should remove the resource from crontab if present" do
-        apply_with_error_check(<<-MANIFEST)
-        cron {
-          'My daily failure':
-            ensure => 'absent',
-            target => '#{crontab_user1}',
-        }
-        MANIFEST
-        expect_output('remove_named_resource')
-      end
-
-      it "should remove a matching cronentry if present" do
-        apply_with_error_check(<<-MANIFEST)
-        cron {
-          'no_such_named_resource_in_crontab':
-            ensure   => absent,
-            minute   => [ '17-19', '22' ],
-            hour     => [ '0-23/2' ],
-            weekday  => 'Tue',
-            command  => '/bin/unnamed_regular_command',
-            target   => '#{crontab_user1}',
-        }
-        MANIFEST
-        expect_output('remove_unnamed_resource')
-      end
-    end
-
-    describe "with ensure present" do
-
-      context "and no command specified" do
-        it "should work if the resource is already present" do
-          apply_with_error_check(<<-MANIFEST)
-          cron {
-            'My daily failure':
-              special => 'daily',
-              target  => '#{crontab_user1}',
-          }
-          MANIFEST
-          expect_output('crontab_user1')
-        end
-        it "should fail if the resource needs creating" do
-          manifest = <<-MANIFEST
-          cron {
-            'Entirely new resource':
-              special => 'daily',
-              target  => '#{crontab_user1}',
-          }
-          MANIFEST
-          apply_compiled_manifest(manifest) do |res|
-            if res.ref == 'Cron[Entirely new resource]'
-              res.expects(:err).with(regexp_matches(/no command/))
-            else
-              res.expects(:err).never
-            end
-          end
-        end
-      end
-
-      it "should do nothing if entry already present" do
-        apply_with_error_check(<<-MANIFEST)
-        cron {
-          'My daily failure':
-            special => 'daily',
-            command => '/bin/false',
-            target  => '#{crontab_user1}',
-        }
-        MANIFEST
-        expect_output('crontab_user1')
-      end
-
-      it "should work correctly when managing 'target' but not 'user'" do
-        apply_with_error_check(<<-MANIFEST)
-        cron {
-          'My daily failure':
-            special => 'daily',
-            command => '/bin/false',
-            target  => '#{crontab_user1}',
-        }
-        MANIFEST
-        expect_output('crontab_user1')
-      end
-
-      it "should do nothing if a matching entry already present" do
-        apply_with_error_check(<<-MANIFEST)
-        cron {
-          'no_such_named_resource_in_crontab':
-            ensure   => present,
-            minute   => [ '17-19', '22' ],
-            hour     => [ '0-23/2' ],
-            command  => '/bin/unnamed_regular_command',
-            target   => '#{crontab_user1}',
-        }
-        MANIFEST
-        expect_output('crontab_user1')
-      end
-
-      it "should add a new normal entry if currently absent" do
-        apply_with_error_check(<<-MANIFEST)
-        cron {
-          'new entry':
-            ensure      => present,
-            minute      => '12',
-            weekday     => 'Tue',
-            command     => '/bin/new',
-            environment => [
-              'MAILTO=""',
-              'SHELL=/bin/bash'
-            ],
-            target      => '#{crontab_user1}',
-        }
-        MANIFEST
-        expect_output('create_normal_entry')
-      end
-
-      it "should add a new special entry if currently absent" do
-        apply_with_error_check(<<-MANIFEST)
-        cron {
-          'new special entry':
-            ensure      => present,
-            special     => 'reboot',
-            command     => 'echo "Booted" 1>&2',
-            environment => 'MAILTO=bob@company.com',
-            target      => '#{crontab_user1}',
-        }
-        MANIFEST
-        expect_output('create_special_entry')
-      end
-
-      it "should change existing entry if out of sync" do
-        apply_with_error_check(<<-MANIFEST)
-        cron {
-          'Monthly job':
-            ensure      => present,
-            special     => 'monthly',
-            #minute => ['22'],
-            command     => '/usr/bin/monthly',
-            environment => [],
-            target      => '#{crontab_user1}',
-        }
-        MANIFEST
-        expect_output('modify_entry')
-      end
-      it "should change a special schedule to numeric if requested" do
-        apply_with_error_check(<<-MANIFEST)
-        cron {
-          'My daily failure':
-            special     => 'absent',
-            command     => '/bin/false',
-            target      => '#{crontab_user1}',
-        }
-        MANIFEST
-        expect_output('unspecialized')
-      end
-      it "should not try to move an entry from one file to another" do
-        # force the parsedfile provider to also parse user1's crontab
-        apply_with_error_check(<<-MANIFEST)
-        cron {
-          'foo':
-            ensure => absent,
-            target => '#{crontab_user1}';
-          'My daily failure':
-            special      => 'daily',
-            command      => "/bin/false",
-            target       => '#{crontab_user2}',
-        }
-        MANIFEST
-        expect(File.read(crontab_user1)).to eq(File.read(my_fixture('moved_cronjob_input1')))
-        expect(File.read(crontab_user2)).to eq(File.read(my_fixture('moved_cronjob_input2')))
-      end
-    end
-  end
-
-end

data/spec/integration/provider/mailalias/aliases_spec.rb

@@ -1,10 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-require 'shared_behaviours/all_parsedfile_providers'
-
-provider_class = Puppet::Type.type(:mailalias).provider(:aliases)
-
-describe provider_class do
-  # #1560, in which we corrupt the format of complex mail aliases.
-  it_should_behave_like "all parsedfile providers", provider_class
-end

data/spec/integration/provider/mount_spec.rb

@@ -1,161 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/file_bucket/dipper'
-
-describe "mount provider (integration)", :unless => Puppet.features.microsoft_windows? do
-  include PuppetSpec::Files
-
-  family = Facter.value(:osfamily)
-
-  def create_fake_fstab(initially_contains_entry)
-    File.open(@fake_fstab, 'w') do |f|
-      if initially_contains_entry
-        f.puts("/dev/disk1s1\t/Volumes/foo_disk\tmsdos\tlocal\t0\t0")
-      end
-    end
-  end
-
-  before :each do
-    @fake_fstab = tmpfile('fstab')
-    @current_options = "local"
-    @current_device = "/dev/disk1s1"
-    Puppet::Type.type(:mount).defaultprovider.stubs(:default_target).returns(@fake_fstab)
-    Facter.stubs(:value).with(:hostname).returns('some_host')
-    Facter.stubs(:value).with(:domain).returns('some_domain')
-    Facter.stubs(:value).with(:kernel).returns('Linux')
-    Facter.stubs(:value).with(:operatingsystem).returns('RedHat')
-    Facter.stubs(:value).with(:osfamily).returns('RedHat')
-    Puppet::Util::ExecutionStub.set do |command, options|
-      case command[0]
-      when %r{/s?bin/mount}
-        if command.length == 1
-          if @mounted
-            "#{@current_device} on /Volumes/foo_disk (msdos, #{@current_options})\n"
-          else
-            ''
-          end
-        else
-          expect(command.last).to eq('/Volumes/foo_disk')
-          @current_device = check_fstab(true)
-          @mounted = true
-          ''
-        end
-      when %r{/s?bin/umount}
-        expect(command.length).to eq(2)
-        expect(command[1]).to eq('/Volumes/foo_disk')
-        expect(@mounted).to eq(true) # "umount" doesn't work when device not mounted (see #6632)
-        @mounted = false
-        ''
-      else
-        fail "Unexpected command #{command.inspect} executed"
-      end
-    end
-  end
-
-  after :each do
-    Puppet::Type::Mount::ProviderParsed.clear # Work around bug #6628
-  end
-
-  def check_fstab(expected_to_be_present)
-    # Verify that the fake fstab has the expected data in it
-    fstab_contents = File.read(@fake_fstab).split("\n").reject { |x| x =~ /^#|^$/ }
-    if expected_to_be_present
-      expect(fstab_contents.length()).to eq(1)
-      device, rest_of_line = fstab_contents[0].split(/\t/,2)
-      expect(rest_of_line).to eq("/Volumes/foo_disk\tmsdos\t#{@desired_options}\t0\t0")
-      device
-    else
-      expect(fstab_contents.length()).to eq(0)
-      nil
-    end
-  end
-
-  def run_in_catalog(settings)
-    resource = Puppet::Type.type(:mount).new(settings.merge(:name => "/Volumes/foo_disk",
-                                             :device => "/dev/disk1s1", :fstype => "msdos"))
-    Puppet::FileBucket::Dipper.any_instance.stubs(:backup) # Don't backup to the filebucket
-    resource.expects(:err).never
-    catalog = Puppet::Resource::Catalog.new
-    catalog.host_config = false # Stop Puppet from doing a bunch of magic
-    catalog.add_resource resource
-    catalog.apply
-  end
-
-  [false, true].each do |initial_state|
-    describe "When initially #{initial_state ? 'mounted' : 'unmounted'}" do
-      before :each do
-        @mounted = initial_state
-      end
-
-      [false, true].each do |initial_fstab_entry|
-        describe "When there is #{initial_fstab_entry ? 'an' : 'no'} initial fstab entry" do
-          before :each do
-            create_fake_fstab(initial_fstab_entry)
-          end
-
-          [:defined, :present, :mounted, :unmounted, :absent].each do |ensure_setting|
-            expected_final_state = case ensure_setting
-              when :mounted
-                true
-              when :unmounted, :absent
-                false
-              when :defined, :present
-                initial_state
-              else
-                fail "Unknown ensure_setting #{ensure_setting}"
-            end
-            expected_fstab_data = (ensure_setting != :absent)
-            describe "When setting ensure => #{ensure_setting}" do
-              ["local", "journaled", "", nil].each do |options_setting|
-                describe "When setting options => '#{options_setting}'" do
-                  it "should leave the system in the #{expected_final_state ? 'mounted' : 'unmounted'} state, #{expected_fstab_data ? 'with' : 'without'} data in /etc/fstab" do
-                    if family == "Solaris"
-                      skip("Solaris: The mock :operatingsystem value does not get changed in lib/puppet/provider/mount/parsed.rb")
-                    else
-                      if options_setting && options_setting.empty?
-                        expect { run_in_catalog(:ensure=>ensure_setting, :options => options_setting) }.to raise_error Puppet::ResourceError
-                      else
-                        if options_setting
-                          @desired_options = options_setting
-                          run_in_catalog(:ensure=>ensure_setting, :options => options_setting)
-                        else
-                          if initial_fstab_entry
-                            @desired_options = @current_options
-                          else
-                            @desired_options = 'defaults'
-                          end
-                          run_in_catalog(:ensure=>ensure_setting)
-                        end
-                        expect(@mounted).to eq(expected_final_state)
-                        if expected_fstab_data
-                          expect(check_fstab(expected_fstab_data)).to eq("/dev/disk1s1")
-                        else
-                          expect(check_fstab(expected_fstab_data)).to eq(nil)
-                        end
-                      end
-                    end
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-
-  describe "When the wrong device is mounted" do
-    it "should remount the correct device" do
-      pending "Due to bug 6309"
-      @mounted = true
-      @current_device = "/dev/disk2s2"
-      create_fake_fstab(true)
-      @desired_options = "local"
-      run_in_catalog(:ensure=>:mounted, :options=>'local')
-      expect(@current_device).to eq("/dev/disk1s1")
-      expect(@mounted).to eq(true)
-      expect(@current_options).to eq('local')
-      expect(check_fstab(true)).to eq("/dev/disk1s1")
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-provider = Puppet::Type.type(:service).provider(:init)
-
-describe provider do
-  describe "when running on FreeBSD" do
-    before :each do
-      Facter.stubs(:value).with(:operatingsystem).returns 'FreeBSD'
-    end
-
-    it "should set its default path to include /etc/rc.d and /usr/local/etc/rc.d" do
-      expect(provider.defpath).to eq(["/etc/rc.d", "/usr/local/etc/rc.d"])
-    end
-  end
-
-  describe "when running on HP-UX" do
-    before :each do
-      Facter.stubs(:value).with(:operatingsystem).returns 'HP-UX'
-    end
-
-    it "should set its default path to include /sbin/init.d" do
-      expect(provider.defpath).to eq("/sbin/init.d")
-    end
-  end
-
-  describe "when running on Archlinux" do
-    before :each do
-      Facter.stubs(:value).with(:operatingsystem).returns 'Archlinux'
-    end
-
-    it "should set its default path to include /etc/rc.d" do
-      expect(provider.defpath).to eq("/etc/rc.d")
-    end
-  end
-
-  describe "when not running on FreeBSD, HP-UX or Archlinux" do
-    before :each do
-      Facter.stubs(:value).with(:operatingsystem).returns 'RedHat'
-    end
-
-    it "should set its default path to include /etc/init.d" do
-      expect(provider.defpath).to eq("/etc/init.d")
-    end
-  end
-end

data/spec/integration/provider/service/systemd_spec.rb

@@ -1,20 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'spec_helper'
-
-describe Puppet::Type.type(:service).provider(:systemd), '(integration)' do
-  # TODO: Unfortunately there does not seem a way to stub the executable
-  #       checks in the systemd provider because they happen at load time.
-  it "should be considered suitable if /bin/systemctl is present", :if => File.executable?('/bin/systemctl') do
-    expect(described_class).to be_suitable
-  end
-
-  it "should be considered suitable if /usr/bin/systemctl is present", :if => File.executable?('/usr/bin/systemctl')  do
-    expect(described_class).to be_suitable
-  end
-
-  it "should not be cosidered suitable if systemctl is absent",
-    :unless => (File.executable?('/bin/systemctl') or File.executable?('/usr/bin/systemctl')) do
-    expect(described_class).not_to be_suitable
-  end
-end

data/spec/integration/provider/service/windows_spec.rb

@@ -1,49 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-describe Puppet::Type.type(:service).provider(:windows), '(integration)',
-  :if => Puppet.features.microsoft_windows? do
-
-  require 'puppet/util/windows'
-
-  before :each do
-    Puppet::Type.type(:service).stubs(:defaultprovider).returns described_class
-  end
-
-  context 'should fail querying services that do not exist' do
-    let(:service) do
-      Puppet::Type.type(:service).new(:name => 'foobarservice1234')
-    end
-
-    it "with a Puppet::Error when querying enabled?" do
-      expect { service.provider.enabled? }.to raise_error(Puppet::Error)
-    end
-
-    it "with a Puppet::Error when querying status" do
-      expect { service.provider.status }.to raise_error(Puppet::Error)
-    end
-  end
-
-  context 'should return valid values when querying a service that does exist' do
-    let(:service) do
-      # This service should be ubiquitous across all supported Windows platforms
-      Puppet::Type.type(:service).new(:name => 'lmhosts')
-    end
-
-    it "with a valid enabled? value when asked if enabled" do
-      expect([:true, :false, :manual]).to include(service.provider.enabled?)
-    end
-
-    it "with a valid status when asked about status" do
-      expect([
-        :running,
-        :'continue pending',
-        :'pause pending',
-        :paused,
-        :running,
-        :'start pending',
-        :'stop pending',
-        :stopped]).to include(service.provider.status)
-    end
-  end
-end