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

data/spec/integration/environments/default_manifest_spec.rb

@@ -1,215 +0,0 @@
-require 'spec_helper'
-
-module EnvironmentsDefaultManifestsSpec
-describe "default manifests" do
-
-  context "puppet with default_manifest settings" do
-    let(:confdir) { Puppet[:confdir] }
-    let(:environmentpath) { File.expand_path("envdir", confdir) }
-
-    context "relative default" do
-      let(:testingdir) { File.join(environmentpath, "testing") }
-
-      before(:each) do
-        FileUtils.mkdir_p(testingdir)
-      end
-
-      it "reads manifest from ./manifest of a basic directory environment" do
-        manifestsdir = File.join(testingdir, "manifests")
-        FileUtils.mkdir_p(manifestsdir)
-
-        File.open(File.join(manifestsdir, "site.pp"), "w", :encoding => Encoding::UTF_8) do |f|
-          f.puts("notify { 'ManifestFromRelativeDefault': }")
-        end
-
-        File.open(File.join(confdir, "puppet.conf"), "w", :encoding => Encoding::UTF_8) do |f|
-          f.puts("environmentpath=#{environmentpath}")
-        end
-
-        expect(a_catalog_compiled_for_environment('testing')).to(
-          include_resource('Notify[ManifestFromRelativeDefault]')
-        )
-      end
-    end
-
-    context "set absolute" do
-      let(:testingdir) { File.join(environmentpath, "testing") }
-
-      before(:each) do
-        FileUtils.mkdir_p(testingdir)
-      end
-
-      it "reads manifest from an absolute default_manifest" do
-        manifestsdir = File.expand_path("manifests", confdir)
-        FileUtils.mkdir_p(manifestsdir)
-
-        File.open(File.join(confdir, "puppet.conf"), "w", :encoding => Encoding::UTF_8) do |f|
-          f.puts(<<-EOF)
-  environmentpath=#{environmentpath}
-  default_manifest=#{manifestsdir}
-          EOF
-        end
-
-        File.open(File.join(manifestsdir, "site.pp"), "w", :encoding => Encoding::UTF_8) do |f|
-          f.puts("notify { 'ManifestFromAbsoluteDefaultManifest': }")
-        end
-
-        expect(a_catalog_compiled_for_environment('testing')).to(
-          include_resource('Notify[ManifestFromAbsoluteDefaultManifest]')
-        )
-      end
-
-      it "reads manifest from directory environment manifest when environment.conf manifest set" do
-        default_manifestsdir = File.expand_path("manifests", confdir)
-        File.open(File.join(confdir, "puppet.conf"), "w", :encoding => Encoding::UTF_8) do |f|
-          f.puts(<<-EOF)
-  environmentpath=#{environmentpath}
-  default_manifest=#{default_manifestsdir}
-          EOF
-        end
-
-        manifestsdir = File.join(testingdir, "special_manifests")
-        FileUtils.mkdir_p(manifestsdir)
-
-        File.open(File.join(manifestsdir, "site.pp"), "w", :encoding => Encoding::UTF_8) do |f|
-          f.puts("notify { 'ManifestFromEnvironmentConfManifest': }")
-        end
-
-        File.open(File.join(testingdir, "environment.conf"), "w", :encoding => Encoding::UTF_8) do |f|
-          f.puts("manifest=./special_manifests")
-        end
-
-        expect(a_catalog_compiled_for_environment('testing')).to(
-          include_resource('Notify[ManifestFromEnvironmentConfManifest]')
-        )
-        expect(Puppet[:default_manifest]).to eq(default_manifestsdir)
-      end
-
-      it "ignores manifests in the local ./manifests if default_manifest specifies another directory" do
-        default_manifestsdir = File.expand_path("manifests", confdir)
-        FileUtils.mkdir_p(default_manifestsdir)
-
-        File.open(File.join(confdir, "puppet.conf"), "w", :encoding => Encoding::UTF_8) do |f|
-          f.puts(<<-EOF)
-  environmentpath=#{environmentpath}
-  default_manifest=#{default_manifestsdir}
-          EOF
-        end
-
-        File.open(File.join(default_manifestsdir, "site.pp"), "w", :encoding => Encoding::UTF_8) do |f|
-          f.puts("notify { 'ManifestFromAbsoluteDefaultManifest': }")
-        end
-
-        implicit_manifestsdir = File.join(testingdir, "manifests")
-        FileUtils.mkdir_p(implicit_manifestsdir)
-
-        File.open(File.join(implicit_manifestsdir, "site.pp"), "w", :encoding => Encoding::UTF_8) do |f|
-          f.puts("notify { 'ManifestFromImplicitRelativeEnvironmentManifestDirectory': }")
-        end
-
-        expect(a_catalog_compiled_for_environment('testing')).to(
-          include_resource('Notify[ManifestFromAbsoluteDefaultManifest]')
-        )
-      end
-
-    end
-
-    context "with disable_per_environment_manifest true" do
-      let(:manifestsdir) { File.expand_path("manifests", confdir) }
-      let(:testingdir) { File.join(environmentpath, "testing") }
-
-      before(:each) do
-        FileUtils.mkdir_p(testingdir)
-      end
-
-      before(:each) do
-        FileUtils.mkdir_p(manifestsdir)
-
-        File.open(File.join(confdir, "puppet.conf"), "w", :encoding => Encoding::UTF_8) do |f|
-          f.puts(<<-EOF)
-  environmentpath=#{environmentpath}
-  default_manifest=#{manifestsdir}
-  disable_per_environment_manifest=true
-          EOF
-        end
-
-        File.open(File.join(manifestsdir, "site.pp"), "w", :encoding => Encoding::UTF_8) do |f|
-          f.puts("notify { 'ManifestFromAbsoluteDefaultManifest': }")
-        end
-      end
-
-      it "reads manifest from the default manifest setting" do
-        expect(a_catalog_compiled_for_environment('testing')).to(
-          include_resource('Notify[ManifestFromAbsoluteDefaultManifest]')
-        )
-      end
-
-      it "refuses to compile if environment.conf specifies a different manifest" do
-        File.open(File.join(testingdir, "environment.conf"), "w", :encoding => Encoding::UTF_8) do |f|
-          f.puts("manifest=./special_manifests")
-        end
-
-        expect { a_catalog_compiled_for_environment('testing') }.to(
-          raise_error(Puppet::Error, /disable_per_environment_manifest.*environment.conf.*manifest.*conflict/)
-        )
-      end
-
-      it "reads manifest from default_manifest setting when environment.conf has manifest set if setting equals default_manifest setting" do
-        File.open(File.join(testingdir, "environment.conf"), "w", :encoding => Encoding::UTF_8) do |f|
-          f.puts("manifest=#{manifestsdir}")
-        end
-
-        expect(a_catalog_compiled_for_environment('testing')).to(
-          include_resource('Notify[ManifestFromAbsoluteDefaultManifest]')
-        )
-      end
-
-      it "logs errors if environment.conf specifies a different manifest" do
-        File.open(File.join(testingdir, "environment.conf"), "w", :encoding => Encoding::UTF_8) do |f|
-          f.puts("manifest=./special_manifests")
-        end
-
-        Puppet.initialize_settings
-        expect(Puppet[:environmentpath]).to eq(environmentpath)
-        environment = Puppet.lookup(:environments).get('testing')
-        expect(environment.manifest).to eq(manifestsdir)
-        expect(@logs.first.to_s).to match(%r{disable_per_environment_manifest.*is true, but.*environment.*at #{testingdir}.*has.*environment.conf.*manifest.*#{testingdir}/special_manifests})
-      end
-
-      it "raises an error if default_manifest is not absolute" do
-        File.open(File.join(confdir, "puppet.conf"), "w", :encoding => Encoding::UTF_8) do |f|
-          f.puts(<<-EOF)
-  environmentpath=#{environmentpath}
-  default_manifest=./relative
-  disable_per_environment_manifest=true
-          EOF
-        end
-
-        expect { Puppet.initialize_settings }.to raise_error(Puppet::Settings::ValidationError, /default_manifest.*must be.*absolute.*when.*disable_per_environment_manifest.*true/)
-      end
-    end
-  end
-
-  RSpec::Matchers.define :include_resource do |expected|
-    match do |actual|
-      actual.resources.map(&:ref).include?(expected)
-    end
-
-    def failure_message
-      "expected #{@actual.resources.map(&:ref)} to include #{expected}"
-    end
-
-    def failure_message_when_negated
-      "expected #{@actual.resources.map(&:ref)} not to include #{expected}"
-    end
-  end
-
-  def a_catalog_compiled_for_environment(envname)
-    Puppet.initialize_settings
-    expect(Puppet[:environmentpath]).to eq(environmentpath)
-    node = Puppet::Node.new('testnode', :environment => 'testing')
-    expect(node.environment).to eq(Puppet.lookup(:environments).get('testing'))
-    Puppet::Parser::Compiler.compile(node)
-  end
-end
-end

data/spec/integration/environments/setting_hooks_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe "setting hooks" do
-  let(:confdir) { Puppet[:confdir] }
-  let(:environmentpath) { File.expand_path("envdir", confdir) }
-
-  describe "reproducing PUP-3500" do
-    let(:productiondir) { File.join(environmentpath, "production") }
-
-    before(:each) do
-      FileUtils.mkdir_p(productiondir)
-    end
-
-    it "accesses correct directory environment settings after initializing a setting with an on_write hook" do
-      expect(Puppet.settings.setting(:strict).call_hook).to eq(:on_write_only)
-
-      File.open(File.join(confdir, "puppet.conf"), "w:UTF-8") do |f|
-        f.puts("environmentpath=#{environmentpath}")
-        f.puts("certname=something")
-      end
-
-      Puppet.initialize_settings
-      production_env = Puppet.lookup(:environments).get(:production)
-      expect(Puppet.settings.value(:manifest, production_env)).to eq("#{productiondir}/manifests")
-    end
-  end
-end

data/spec/integration/environments/settings_interpolation_spec.rb

@@ -1,106 +0,0 @@
-require 'pp'
-require 'spec_helper'
-require 'puppet_spec/settings'
-
-module SettingsInterpolationSpec
-describe "interpolating $environment" do
-  include PuppetSpec::Settings
-
-  let(:confdir) { Puppet[:confdir] }
-  let(:cmdline_args) { ['--confdir', confdir, '--vardir', Puppet[:vardir], '--hiera_config', Puppet[:hiera_config]] }
-
-  shared_examples_for "a setting that does not interpolate $environment" do
-
-    before(:each) do
-      set_puppet_conf(confdir, <<-EOF)
-        environmentpath=$confdir/environments
-        #{setting}=#{value}
-      EOF
-    end
-
-    it "does not interpolate $environment" do
-      Puppet.initialize_settings(cmdline_args)
-      expect(Puppet[:environmentpath]).to eq("#{confdir}/environments")
-      expect(Puppet[setting.intern]).to eq(expected)
-    end
-
-    it "displays the interpolated value in the warning" do
-      Puppet.initialize_settings(cmdline_args)
-      Puppet[setting.intern]
-      expect(@logs).to have_matching_log(/cannot interpolate \$environment within '#{setting}'.*Its value will remain #{Regexp.escape(expected)}/)
-    end
-  end
-
-  describe "config_version" do
-    it "interpolates $environment" do
-      envname = 'testing'
-      setting = 'config_version'
-      value = '/some/script $environment'
-      expected = "#{File.expand_path('/some/script')} testing"
-
-      set_puppet_conf(confdir, <<-EOF)
-        environmentpath=$confdir/environments
-        environment=#{envname}
-      EOF
-
-      set_environment_conf("#{confdir}/environments", envname, <<-EOF)
-        #{setting}=#{value}
-      EOF
-
-      Puppet.initialize_settings(cmdline_args)
-      expect(Puppet[:environmentpath]).to eq("#{confdir}/environments")
-      environment = Puppet.lookup(:environments).get(envname)
-      expect(environment.config_version).to eq(expected)
-      expect(@logs).to be_empty
-    end
-  end
-
-  describe "basemodulepath" do
-    let(:setting) { "basemodulepath" }
-    let(:value) { "$confdir/environments/$environment/modules:$confdir/environments/$environment/other_modules" }
-    let(:expected) { "#{confdir}/environments/$environment/modules:#{confdir}/environments/$environment/other_modules" }
-
-    it_behaves_like "a setting that does not interpolate $environment"
-
-    it "logs a single warning for multiple instaces of $environment in the setting" do
-      set_puppet_conf(confdir, <<-EOF)
-        environmentpath=$confdir/environments
-        #{setting}=#{value}
-      EOF
-
-      Puppet.initialize_settings(cmdline_args)
-      expect(@logs.map(&:to_s).grep(/cannot interpolate \$environment within '#{setting}'/).count).to eq(1)
-    end
-  end
-
-  describe "environment" do
-    let(:setting) { "environment" }
-    let(:value) { "whatareyouthinking$environment" }
-    let(:expected) { value }
-
-    it_behaves_like "a setting that does not interpolate $environment"
-  end
-
-  describe "the default_manifest" do
-    let(:setting) { "default_manifest" }
-    let(:value) { "$confdir/manifests/$environment" }
-    let(:expected) { "#{confdir}/manifests/$environment" }
-
-    it_behaves_like "a setting that does not interpolate $environment"
-  end
-
-  it "does not interpolate $environment and logs a warning when interpolating environmentpath" do
-    setting = 'environmentpath'
-    value = "$confdir/environments/$environment"
-    expected = "#{confdir}/environments/$environment"
-
-    set_puppet_conf(confdir, <<-EOF)
-      #{setting}=#{value}
-    EOF
-
-    Puppet.initialize_settings(cmdline_args)
-    expect(Puppet[setting.intern]).to eq(expected)
-    expect(@logs).to have_matching_log(/cannot interpolate \$environment within '#{setting}'/)
-  end
-end
-end

data/spec/integration/environments/settings_spec.rb

@@ -1,128 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/settings'
-
-describe "environment settings" do
-  include PuppetSpec::Settings
-
-  let(:confdir) { Puppet[:confdir] }
-  let(:cmdline_args) { ['--confdir', confdir, '--vardir', Puppet[:vardir], '--hiera_config', Puppet[:hiera_config]] }
-  let(:environmentpath) { File.expand_path("envdir", confdir) }
-  let(:testingdir) { File.join(environmentpath, "testing") }
-
-  before(:each) do
-    FileUtils.mkdir_p(testingdir)
-  end
-
-  def init_puppet_conf(settings = {})
-    set_puppet_conf(confdir, <<-EOF)
-      environmentpath=#{environmentpath}
-      #{settings.map { |k,v| "#{k}=#{v}" }.join("\n")}
-    EOF
-    Puppet.initialize_settings
-  end
-
-  it "raises an error if you set manifest in puppet.conf" do
-    expect { init_puppet_conf("manifest" => "/something") }.to raise_error(Puppet::Settings::SettingsError, /Cannot set manifest.*in puppet.conf/)
-  end
-
-  it "raises an error if you set modulepath in puppet.conf" do
-    expect { init_puppet_conf("modulepath" => "/something") }.to raise_error(Puppet::Settings::SettingsError, /Cannot set modulepath.*in puppet.conf/)
-  end
-
-  it "raises an error if you set config_version in puppet.conf" do
-    expect { init_puppet_conf("config_version" => "/something") }.to raise_error(Puppet::Settings::SettingsError, /Cannot set config_version.*in puppet.conf/)
-  end
-
-  context "when given an environment" do
-    before(:each) do
-      init_puppet_conf
-    end
-
-    context "without an environment.conf" do
-      it "reads manifest from environment.conf defaults" do
-        expect(Puppet.settings.value(:manifest, :testing)).to eq(File.join(testingdir, "manifests"))
-      end
-
-      it "reads modulepath from environment.conf defaults" do
-        expect(Puppet.settings.value(:modulepath, :testing)).to match(/#{File.join(testingdir, "modules")}/)
-      end
-
-      it "reads config_version from environment.conf defaults" do
-        expect(Puppet.settings.value(:config_version, :testing)).to eq('')
-      end
-    end
-
-    context "with an environment.conf" do
-      before(:each) do
-        set_environment_conf(environmentpath, 'testing', <<-EOF)
-          manifest=/special/manifest
-          modulepath=/special/modulepath
-          config_version=/special/config_version
-        EOF
-      end
-
-      it "reads the configured manifest" do
-        expect(Puppet.settings.value(:manifest, :testing)).to eq(Puppet::FileSystem.expand_path('/special/manifest'))
-      end
-
-      it "reads the configured modulepath" do
-        expect(Puppet.settings.value(:modulepath, :testing)).to eq(Puppet::FileSystem.expand_path('/special/modulepath'))
-      end
-
-      it "reads the configured config_version" do
-        expect(Puppet.settings.value(:config_version, :testing)).to eq(Puppet::FileSystem.expand_path('/special/config_version'))
-      end
-    end
-
-    context "with an environment.conf containing 8.3 style Windows paths",
-      :if => Puppet::Util::Platform.windows? do
-
-      before(:each) do
-        # set 8.3 style Windows paths
-        @modulepath = Puppet::Util::Windows::File.get_short_pathname(PuppetSpec::Files.tmpdir('fakemodulepath'))
-
-        # for expansion to work, the file must actually exist
-        @manifest = PuppetSpec::Files.tmpfile('foo.pp', @modulepath)
-        # but tmpfile won't create an empty file
-        Puppet::FileSystem.touch(@manifest)
-        @manifest = Puppet::Util::Windows::File.get_short_pathname(@manifest)
-
-        set_environment_conf(environmentpath, 'testing', <<-EOF)
-          manifest=#{@manifest}
-          modulepath=#{@modulepath}
-        EOF
-      end
-
-      it "reads the configured manifest as a fully expanded path" do
-        expect(Puppet.settings.value(:manifest, :testing)).to eq(Puppet::FileSystem.expand_path(@manifest))
-      end
-
-      it "reads the configured modulepath as a fully expanded path" do
-        expect(Puppet.settings.value(:modulepath, :testing)).to eq(Puppet::FileSystem.expand_path(@modulepath))
-      end
-    end
-
-    context "when environment name collides with a puppet.conf section" do
-      let(:testingdir) { File.join(environmentpath, "main") }
-
-      it "reads manifest from environment.conf defaults" do
-        expect(Puppet.settings.value(:environmentpath)).to eq(environmentpath)
-        expect(Puppet.settings.value(:manifest, :main)).to eq(File.join(testingdir, "manifests"))
-      end
-
-      context "and an environment.conf" do
-        before(:each) do
-          set_environment_conf(environmentpath, 'main', <<-EOF)
-            manifest=/special/manifest
-          EOF
-        end
-
-        it "reads manifest from environment.conf settings" do
-          expect(Puppet.settings.value(:environmentpath)).to eq(environmentpath)
-          expect(Puppet.settings.value(:manifest, :main)).to eq(Puppet::FileSystem.expand_path("/special/manifest"))
-        end
-      end
-    end
-  end
-
-end