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

data/spec/integration/type/notify_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/compiler'
-
-describe Puppet::Type.type(:notify) do
-  include PuppetSpec::Compiler
-
-  it "logs the title at notice level" do
-    apply_compiled_manifest(<<-MANIFEST)
-      notify { 'hi': }
-    MANIFEST
-
-    expect(@logs).to include(an_object_having_attributes(level: :notice, message: 'hi'))
-  end
-
-  it "logs the message property" do
-    apply_compiled_manifest(<<-MANIFEST)
-      notify { 'title':
-        message => 'hello'
-      }
-    MANIFEST
-
-    expect(@logs).to include(an_object_having_attributes(level: :notice, message: "defined 'message' as 'hello'"))
-  end
-
-  it "redacts sensitive message properties" do
-    apply_compiled_manifest(<<-MANIFEST)
-      $message = Sensitive('secret')
-      notify { 'notify1':
-        message => $message
-      }
-    MANIFEST
-
-    expect(@logs).to include(an_object_having_attributes(level: :notice, message: 'changed [redacted] to [redacted]'))
-  end
-
-  it "redacts sensitive interpolated message properties" do
-    apply_compiled_manifest(<<-MANIFEST)
-      $message = Sensitive('secret')
-      notify { 'notify2':
-        message => "${message}"
-      }
-    MANIFEST
-
-    expect(@logs).to include(an_object_having_attributes(level: :notice, message: "defined 'message' as 'Sensitive [value redacted]'"))
-  end
-end

data/spec/integration/type/package_spec.rb

@@ -1,200 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:package), "when choosing a default package provider" do
-  before do
-    # the default provider is cached.
-    Puppet::Type.type(:package).defaultprovider = nil
-  end
-
-  def provider_name(os)
-    case os
-    when 'Solaris'
-      if Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value(:kernelrelease), '5.11') >= 0
-        :pkg
-      else
-        :sun
-      end
-    when 'Ubuntu'
-      :apt
-    when 'Debian'
-      :apt
-    when 'Darwin'
-      :pkgdmg
-    when 'RedHat'
-      if ['2.1', '3', '4'].include?(Puppet.runtime[:facter].value(:lsbdistrelease))
-        :up2date
-      else
-        :yum
-      end
-    when 'Fedora'
-      if Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value(:operatingsystemmajrelease), '22') >= 0
-        :dnf
-      else
-        :yum
-      end
-    when 'Suse'
-      if Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value(:operatingsystemmajrelease), '10') >= 0
-        :zypper
-      else
-        :rug
-      end
-    when 'FreeBSD'
-      :ports
-    when 'OpenBSD'
-      :openbsd
-    when 'DragonFly'
-      :pkgng
-    when 'OpenWrt'
-      :opkg
-    end
-  end
-
-  it "should have a default provider" do
-    expect(Puppet::Type.type(:package).defaultprovider).not_to be_nil
-  end
-
-  it "should choose the correct provider each platform" do
-    unless default_provider = provider_name(Puppet.runtime[:facter].value(:operatingsystem))
-      pending("No default provider specified in this test for #{Puppet.runtime[:facter].value(:operatingsystem)}")
-    end
-    expect(Puppet::Type.type(:package).defaultprovider.name).to eq(default_provider)
-  end
-end
-
-describe Puppet::Type.type(:package), "when packages with the same name are sourced" do
-  before :each do
-    allow(Process).to receive(:euid).and_return(0)
-    @provider = double(
-      'provider',
-      :class           => Puppet::Type.type(:package).defaultprovider,
-      :clear           => nil,
-      :satisfies?      => true,
-      :name            => :mock,
-      :validate_source => nil
-    )
-    allow(Puppet::Type.type(:package).defaultprovider).to receive(:new).and_return(@provider)
-    allow(Puppet::Type.type(:package).defaultprovider).to receive(:instances).and_return([])
-    @package = Puppet::Type.type(:package).new(:name => "yay", :ensure => :present)
-
-    @catalog = Puppet::Resource::Catalog.new
-    @catalog.add_resource(@package)
-  end
-
-  describe "with same title" do
-    before {
-      @alt_package = Puppet::Type.type(:package).new(:name => "yay", :ensure => :present)
-    }
-    it "should give an error" do
-      expect {
-        @catalog.add_resource(@alt_package)
-      }.to raise_error Puppet::Resource::Catalog::DuplicateResourceError, 'Duplicate declaration: Package[yay] is already declared; cannot redeclare'
-    end
-  end
-
-  describe "with different title" do
-    before :each do
-      @alt_package = Puppet::Type.type(:package).new(:name => "yay", :title => "gem-yay", :ensure => :present)
-    end
-
-    it "should give an error" do
-      provider_name = Puppet::Type.type(:package).defaultprovider.name
-      expect {
-        @catalog.add_resource(@alt_package)
-      }.to raise_error ArgumentError, "Cannot alias Package[gem-yay] to [nil, \"yay\", :#{provider_name}]; resource [\"Package\", nil, \"yay\", :#{provider_name}] already declared"
-    end
-  end
-
-  describe "from multiple providers", unless: Puppet::Util::Platform.jruby? do
-    provider_class = Puppet::Type.type(:package).provider(:gem)
-
-    before :each do
-      @alt_provider = provider_class.new
-      @alt_package = Puppet::Type.type(:package).new(:name => "yay", :title => "gem-yay", :provider => @alt_provider, :ensure => :present)
-      @catalog.add_resource(@alt_package)
-    end
-
-    describe "when it should be present" do
-      [:present, :latest, "1.0"].each do |state|
-        it "should do nothing if it is #{state.to_s}" do
-          expect(@provider).to receive(:properties).and_return(:ensure => state).at_least(:once)
-          expect(@alt_provider).to receive(:properties).and_return(:ensure => state).at_least(:once)
-          @catalog.apply
-        end
-      end
-
-      [:purged, :absent].each do |state|
-        it "should install if it is #{state.to_s}" do
-          allow(@provider).to receive(:properties).and_return(:ensure => state)
-          expect(@provider).to receive(:install)
-          allow(@alt_provider).to receive(:properties).and_return(:ensure => state)
-          expect(@alt_provider).to receive(:install)
-          @catalog.apply
-        end
-      end
-    end
-  end
-end
-
-describe Puppet::Type.type(:package), 'logging package state transitions' do
-  let(:catalog) { Puppet::Resource::Catalog.new }
-  let(:provider) { double('provider', :class => Puppet::Type.type(:package).defaultprovider, :clear => nil, :validate_source => nil) }
-
-  before :each do
-    allow(Process).to receive(:euid).and_return(0)
-    allow(provider).to receive(:satisfies?).with([:purgeable]).and_return(true)
-    allow(provider.class).to receive(:instances).and_return([])
-    allow(provider).to receive(:install).and_return(nil)
-    allow(provider).to receive(:uninstall).and_return(nil)
-    allow(provider).to receive(:purge).and_return(nil)
-    allow(Puppet::Type.type(:package).defaultprovider).to receive(:new).and_return(provider)
-  end
-
-  after :each do
-    Puppet::Type.type(:package).defaultprovider = nil
-  end
-
-  # Map of old state -> {new state -> change}
-  states = {
-    # 'installed' transitions to 'removed' or 'purged'
-    :installed => {
-      :installed => nil,
-      :absent    => 'removed',
-      :purged    => 'purged'
-    },
-    # 'absent' transitions to 'created' or 'purged'
-    :absent => {
-      :installed => 'created',
-      :absent    => nil,
-      :purged    => 'purged'
-    },
-    # 'purged' transitions to 'created'
-    :purged => {
-      :installed => 'created',
-      :absent    => nil,
-      :purged    => nil
-    }
-  }
-
-  states.each do |old, new_states|
-    describe "#{old} package" do
-      before :each do
-        allow(provider).to receive(:properties).and_return(:ensure => old)
-      end
-
-      new_states.each do |new, status|
-        it "ensure => #{new} should log #{status ? status : 'nothing'}" do
-          catalog.add_resource(described_class.new(:name => 'yay', :ensure => new))
-          catalog.apply
-
-          logs = catalog.apply.report.logs
-          if status
-            expect(logs.first.source).to eq("/Package[yay]/ensure")
-            expect(logs.first.message).to eq(status)
-          else
-            expect(logs.first).to be_nil
-          end
-        end
-      end
-    end
-  end
-end

data/spec/integration/type/tidy_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-require 'puppet_spec/files'
-require 'puppet/file_bucket/dipper'
-
-describe Puppet::Type.type(:tidy) do
-  include PuppetSpec::Files
-  include PuppetSpec::Compiler
-
-  before do
-    allow(Puppet::Util::Storage).to receive(:store)
-  end
-
-  it "should be able to recursively remove directories" do
-    dir = tmpfile("tidy_testing")
-    FileUtils.mkdir_p(File.join(dir, "foo", "bar"))
-
-    apply_compiled_manifest(<<-MANIFEST)
-      tidy { '#{dir}':
-        recurse => true,
-        rmdirs  => true,
-      }
-    MANIFEST
-
-    expect(Puppet::FileSystem.directory?(dir)).to be_falsey
-  end
-
-  # Testing #355.
-  it "should be able to remove dead links", :if => Puppet.features.manages_symlinks? do
-    dir = tmpfile("tidy_link_testing")
-    link = File.join(dir, "link")
-    target = tmpfile("no_such_file_tidy_link_testing")
-    Dir.mkdir(dir)
-    Puppet::FileSystem.symlink(target, link)
-
-    apply_compiled_manifest(<<-MANIFEST)
-      tidy { '#{dir}':
-        recurse => true,
-      }
-    MANIFEST
-
-    expect(Puppet::FileSystem.symlink?(link)).to be_falsey
-  end
-end

data/spec/integration/type_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/type'
-
-describe Puppet::Type do
-  it "should not lose its provider list when it is reloaded" do
-    type = Puppet::Type.newtype(:integration_test) do
-      newparam(:name) {}
-    end
-
-    provider = type.provide(:myprovider) {}
-
-    # reload it
-    type = Puppet::Type.newtype(:integration_test) do
-      newparam(:name) {}
-    end
-
-    expect(type.provider(:myprovider)).to equal(provider)
-  end
-
-  it "should not lose its provider parameter when it is reloaded" do
-    type = Puppet::Type.newtype(:reload_test_type)
-    type.provide(:test_provider)
-
-    # reload it
-    type = Puppet::Type.newtype(:reload_test_type)
-
-    expect(type.parameters).to include(:provider)
-  end
-end

data/spec/integration/util/autoload_spec.rb

@@ -1,104 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/util/autoload'
-require 'fileutils'
-
-class AutoloadIntegrator
-  @things = []
-  def self.newthing(name)
-    @things << name
-  end
-
-  def self.thing?(name)
-    @things.include? name
-  end
-
-  def self.clear
-    @things.clear
-  end
-end
-
-require 'puppet_spec/files'
-
-describe Puppet::Util::Autoload do
-  include PuppetSpec::Files
-
-  let(:env) { Puppet::Node::Environment.create(:foo, []) }
-
-  def with_file(name, *path)
-    path = File.join(*path)
-    # Now create a file to load
-    File.open(path, "w") { |f|
-      f.puts "\nAutoloadIntegrator.newthing(:#{name.to_s})\n"
-      }
-    yield
-    File.delete(path)
-  end
-
-  def with_loader(name, path)
-    dir = tmpfile(name + path)
-    $LOAD_PATH << dir
-    Dir.mkdir(dir)
-    rbdir = File.join(dir, path.to_s)
-    Dir.mkdir(rbdir)
-    loader = Puppet::Util::Autoload.new(name, path)
-    yield rbdir, loader
-    Dir.rmdir(rbdir)
-    Dir.rmdir(dir)
-    $LOAD_PATH.pop
-    AutoloadIntegrator.clear
-  end
-
-  it "should not fail when asked to load a missing file" do
-    expect(Puppet::Util::Autoload.new("foo", "bar").load(:eh, env)).to be_falsey
-  end
-
-  it "should load and return true when it successfully loads a file" do
-    with_loader("foo", "bar") { |dir,loader|
-      with_file(:mything, dir, "mything.rb") {
-        expect(loader.load(:mything, env)).to be_truthy
-        expect(loader.class).to be_loaded("bar/mything")
-        expect(AutoloadIntegrator).to be_thing(:mything)
-      }
-    }
-  end
-
-  it "should consider a file loaded when asked for the name without an extension" do
-    with_loader("foo", "bar") { |dir,loader|
-      with_file(:noext, dir, "noext.rb") {
-        loader.load(:noext, env)
-        expect(loader.class).to be_loaded("bar/noext")
-      }
-    }
-  end
-
-  it "should consider a file loaded when asked for the name with an extension" do
-    with_loader("foo", "bar") { |dir,loader|
-      with_file(:noext, dir, "withext.rb") {
-        loader.load(:withext, env)
-        expect(loader.class).to be_loaded("bar/withext.rb")
-      }
-    }
-  end
-
-  it "should be able to load files directly from modules" do
-    ## modulepath can't be used until after app settings are initialized, so we need to simulate that:
-    expect(Puppet.settings).to receive(:app_defaults_initialized?).and_return(true).at_least(:once)
-
-    modulepath = tmpfile("autoload_module_testing")
-    libdir = File.join(modulepath, "mymod", "lib", "foo")
-    FileUtils.mkdir_p(libdir)
-
-    file = File.join(libdir, "plugin.rb")
-
-    env = Puppet::Node::Environment.create(:production, [modulepath])
-    Puppet.override(:environments => Puppet::Environments::Static.new(env)) do
-      with_loader("foo", "foo") do |dir, loader|
-        with_file(:plugin, file.split("/")) do
-          loader.load(:plugin, env)
-          expect(loader.class).to be_loaded("foo/plugin.rb")
-        end
-      end
-    end
-  end
-end

data/spec/integration/util/execution_spec.rb

@@ -1,104 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Util::Execution, unless: Puppet::Util::Platform.jruby? do
-  include PuppetSpec::Files
-
-  describe "#execpipe" do
-    it "should set LANG to C avoid localized output", :if => !Puppet::Util::Platform.windows? do
-      out = ""
-      Puppet::Util::Execution.execpipe('echo $LANG'){ |line| out << line.read.chomp }
-      expect(out).to eq("C")
-    end
-
-    it "should set LC_ALL to C avoid localized output", :if => !Puppet::Util::Platform.windows? do
-      out = ""
-      Puppet::Util::Execution.execpipe('echo $LC_ALL'){ |line| out << line.read.chomp }
-      expect(out).to eq("C")
-    end
-
-    it "should raise an ExecutionFailure with a missing command and :failonfail set to true" do
-      expect {
-        failonfail = true
-        # NOTE: critical to return l in the block for `output` in method to be #<IO:(closed)>
-        Puppet::Util::Execution.execpipe('conan_the_librarion', failonfail) { |l| l }
-      }.to raise_error(Puppet::ExecutionFailure)
-    end
-  end
-
-  describe "#execute" do
-    if Puppet::Util::Platform.windows?
-      let(:argv) { ["cmd", "/c", "echo", 123] }
-    else
-      let(:argv) { ["echo", 123] }
-    end
-
-    it 'stringifies sensitive arguments when given an array containing integers' do
-      result = Puppet::Util::Execution.execute(argv, sensitive: true)
-      expect(result.to_s.strip).to eq("123")
-      expect(result.exitstatus).to eq(0)
-    end
-
-    it 'redacts sensitive arguments when given an array' do
-      Puppet[:log_level] = :debug
-      Puppet::Util::Execution.execute(argv, sensitive: true)
-      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'"))
-    end
-
-    it 'redacts sensitive arguments when given a string' do
-      Puppet[:log_level] = :debug
-      str = argv.map(&:to_s).join(' ')
-      Puppet::Util::Execution.execute(str, sensitive: true)
-      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'"))
-    end
-
-    it "allows stdout and stderr to share a file" do
-      command = "ruby -e '(1..10).each {|i| (i%2==0) ? $stdout.puts(i) : $stderr.puts(i)}'"
-
-      expect(Puppet::Util::Execution.execute(command, :combine => true).split).to match_array([*'1'..'10'])
-    end
-
-    it "returns output and set $CHILD_STATUS" do
-      command = "ruby -e 'puts \"foo\"; exit 42'"
-
-      output = Puppet::Util::Execution.execute(command, {:failonfail => false})
-
-      expect(output).to eq("foo\n")
-      expect($CHILD_STATUS.exitstatus).to eq(42)
-    end
-
-    it "raises an error if non-zero exit status is returned" do
-      command = "ruby -e 'exit 43'"
-
-      expect { Puppet::Util::Execution.execute(command) }.to raise_error(Puppet::ExecutionFailure, /Execution of '#{command}' returned 43: /)
-      expect($CHILD_STATUS.exitstatus).to eq(43)
-    end
-  end
-
-  describe "#execute (non-Windows)", :if => !Puppet::Util::Platform.windows? do
-    it "should execute basic shell command" do
-      result = Puppet::Util::Execution.execute("ls /tmp", :failonfail => true)
-      expect(result.exitstatus).to eq(0)
-      expect(result.to_s).to_not be_nil
-    end
-  end
-
-  describe "#execute (Windows)", :if => Puppet::Util::Platform.windows? do
-    let(:utf8text) do
-      # Japanese Lorem Ipsum snippet
-      "utf8testfile" + [227, 131, 171, 227, 131, 147, 227, 131, 179, 227, 131, 132, 227,
-                        130, 162, 227, 130, 166, 227, 130, 167, 227, 131, 150, 227, 130,
-                        162, 227, 129, 181, 227, 129, 185, 227, 129, 139, 227, 130, 137,
-                        227, 129, 154, 227, 130, 187, 227, 130, 183, 227, 131, 147, 227,
-                        131, 170, 227, 131, 134].pack('c*').force_encoding(Encoding::UTF_8)
-    end
-    let(:temputf8filename) do
-      script_containing(utf8text, :windows => "@ECHO OFF\r\nECHO #{utf8text}\r\nEXIT 100")
-    end
-
-    it "should execute with non-english characters in command line" do
-      result = Puppet::Util::Execution.execute("cmd /c \"#{temputf8filename}\"", :failonfail => false)
-      expect(temputf8filename.encoding.name).to eq('UTF-8')
-      expect(result.exitstatus).to eq(100)
-    end
-  end
-end

data/spec/integration/util/rdoc/parser_spec.rb

@@ -1,171 +0,0 @@
-require 'spec_helper'
-require 'puppet/util/rdoc'
-
-describe "RDoc::Parser", :unless => Puppet::Util::Platform.windows? do
-  require 'puppet_spec/files'
-  include PuppetSpec::Files
-
-  let(:document_all) { false }
-  let(:tmp_dir) { tmpdir('rdoc_parser_tmp') }
-  let(:doc_dir) { File.join(tmp_dir, 'doc') }
-  let(:manifests_dir) { File.join(tmp_dir, 'manifests') }
-  let(:modules_dir) { File.join(tmp_dir, 'modules') }
-
-  let(:modules_and_manifests) do
-    {
-      :site => [
-        File.join(manifests_dir, 'site.pp'),
-        <<-EOF
-# The test class comment
-class test {
-  # The virtual resource comment
-  @notify { virtual: }
-  # The a_notify_resource comment
-  notify { a_notify_resource:
-    message => "a_notify_resource message"
-  }
-}
-
-# The includes_another class comment
-class includes_another {
-  include another
-}
-
-# The requires_another class comment
-class requires_another {
-  require another
-}
-
-# node comment
-node foo {
-  include test
-  $a_var = "var_value"
-  realize Notify[virtual]
-  notify { bar: }
-}
-        EOF
-      ],
-      :module_readme => [
-        File.join(modules_dir, 'a_module', 'README'),
-        <<-EOF
-The a_module README docs.
-        EOF
-      ],
-      :module_init => [
-        File.join(modules_dir, 'a_module', 'manifests', 'init.pp'),
-        <<-EOF
-# The a_module class comment
-class a_module {}
-
-class another {}
-        EOF
-      ],
-      :module_type => [
-        File.join(modules_dir, 'a_module', 'manifests', 'a_type.pp'),
-        <<-EOF
-# The a_type type comment
-define a_module::a_type() {}
-        EOF
-      ],
-      :module_plugin => [
-        File.join(modules_dir, 'a_module', 'lib', 'puppet', 'type', 'a_plugin.rb'),
-        <<-EOF
-# The a_plugin type comment
-Puppet::Type.newtype(:a_plugin) do
-  @doc = "Not presented"
-end
-        EOF
-      ],
-      :module_function => [
-        File.join(modules_dir, 'a_module', 'lib', 'puppet', 'parser', 'a_function.rb'),
-        <<-EOF
-# The a_function function comment
-module Puppet::Parser::Functions
-  newfunction(:a_function, :type => :rvalue) do
-    return
-  end
-end
-        EOF
-      ],
-      :module_fact => [
-        File.join(modules_dir, 'a_module', 'lib', 'facter', 'a_fact.rb'),
-        <<-EOF
-# The a_fact fact comment
-Puppet.runtime[:facter].add("a_fact") do
-end
-        EOF
-      ],
-    }
-  end
-
-  def write_file(file, content)
-    FileUtils.mkdir_p(File.dirname(file))
-    File.open(file, 'w') do |f|
-      f.puts(content)
-    end
-  end
-
-  def prepare_manifests_and_modules
-    modules_and_manifests.each do |key,array|
-      write_file(*array)
-    end
-  end
-
-  def file_exists_and_matches_content(file, *content_patterns)
-    expect(Puppet::FileSystem.exist?(file)).to(be_truthy, "Cannot find #{file}")
-    content_patterns.each do |pattern|
-      content = File.read(file)
-      expect(content).to match(pattern)
-    end
-  end
-
-  def some_file_exists_with_matching_content(glob, *content_patterns)
-    expect(Dir.glob(glob).select do |f|
-      contents = File.read(f)
-      content_patterns.all? { |p| p.match(contents) }
-    end).not_to(be_empty, "Could not match #{content_patterns} in any of the files found in #{glob}")
-  end
-
-  around(:each) do |example|
-    env = Puppet::Node::Environment.create(:doc_test_env, [modules_dir], manifests_dir)
-    Puppet.override({:environments => Puppet::Environments::Static.new(env), :current_environment => env}) do
-      example.run
-    end
-  end
-
-  before :each do
-    prepare_manifests_and_modules
-    Puppet.settings[:document_all] = document_all
-    Puppet.settings[:modulepath] = modules_dir
-    Puppet::Util::RDoc.rdoc(doc_dir, [modules_dir, manifests_dir])
-  end
-
-  describe "rdoc2 support" do
-    def module_path(module_name)
-      "#{doc_dir}/#{module_name}.html"
-    end
-
-    def plugin_path(module_name, type, name)
-      "#{doc_dir}/#{module_name}/__#{type}s__.html"
-    end
-
-    def has_plugin_rdoc(module_name, type, name)
-      file_exists_and_matches_content(
-        plugin_path(module_name, type, name),
-        /The .*?#{name}.*?\s*#{type} comment/m, /Type.*?#{type}/m
-      )
-    end
-
-    it "documents the a_module::a_plugin type" do
-      has_plugin_rdoc("a_module", :type, 'a_plugin')
-    end
-
-    it "documents the a_module::a_function function" do
-      has_plugin_rdoc("a_module", :function, 'a_function')
-    end
-
-    it "documents the a_module::a_fact fact" do
-      has_plugin_rdoc("a_module", :fact, 'a_fact')
-    end
-  end
-end