puppet 7.34.0-x64-mingw32 → 8.0.1-x64-mingw32

data/spec/integration/type/notify_spec.rb

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,200 @@
+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('os.distro.release.full'))
+        :up2date
+      else
+        :yum
+      end
+    when 'Fedora'
+      if Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value('os.release.major'), '22') >= 0
+        :dnf
+      else
+        :yum
+      end
+    when 'Suse'
+      if Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value('os.release.major'), '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('os.name'))
+      pending("No default provider specified in this test for #{Puppet.runtime[:facter].value('os.name')}")
+    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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,104 @@
+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

@@ -0,0 +1,104 @@
+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

@@ -0,0 +1,171 @@
+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