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

data/spec/integration/parser/script_compiler_spec.rb

@@ -1,113 +0,0 @@
-require 'puppet'
-require 'spec_helper'
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-require 'puppet/parser/script_compiler'
-
-describe 'the script compiler' do
-  include PuppetSpec::Compiler
-  include PuppetSpec::Files
-  include Matchers::Resource
-  before(:each) do
-    Puppet[:tasks] = true
-  end
-
-  context "when used" do
-    let(:env_name) { 'testenv' }
-    let(:environments_dir) { Puppet[:environmentpath] }
-    let(:env_dir) { File.join(environments_dir, env_name) }
-    let(:manifest) { Puppet::Node::Environment::NO_MANIFEST }
-    let(:env) { Puppet::Node::Environment.create(env_name.to_sym, [File.join(populated_env_dir, 'modules')], manifest) }
-    let(:node) { Puppet::Node.new("test", :environment => env) }
-
-    let(:env_dir_files) {
-      {
-        'manifests' => {
-          'good.pp' => "'good'\n"
-        },
-        'modules' => {
-          'test' => {
-            'plans' => {
-               'run_me.pp' => 'plan test::run_me() { "worked2" }'
-            }
-          }
-        }
-      }
-    }
-
-    let(:populated_env_dir) do
-      dir_contained_in(environments_dir, env_name => env_dir_files)
-      PuppetSpec::Files.record_tmp(env_dir)
-      env_dir
-    end
-
-    let(:script_compiler) do
-      Puppet::Parser::ScriptCompiler.new(env, node.name)
-    end
-
-    context 'is configured such that' do
-      it 'returns what the script_compiler returns' do
-        Puppet[:code] = <<-CODE
-            42
-          CODE
-        expect(script_compiler.compile).to eql(42)
-      end
-
-      it 'referencing undefined variables raises an error' do
-        expect do
-          Puppet[:code] = <<-CODE
-              notice $rubyversion
-            CODE
-            Puppet::Parser::ScriptCompiler.new(env, 'test_node_name').compile
-
-        end.to raise_error(/Unknown variable: 'rubyversion'/)
-      end
-
-      it 'has strict=error behavior' do
-        expect do
-          Puppet[:code] = <<-CODE
-              notice({a => 10, a => 20})
-            CODE
-            Puppet::Parser::ScriptCompiler.new(env, 'test_node_name').compile
-
-        end.to raise_error(/The key 'a' is declared more than once/)
-      end
-
-      it 'performing a multi assign from a class reference raises an error' do
-        expect do
-          Puppet[:code] = <<-CODE
-              [$a] = Class[the_dalit]
-            CODE
-            Puppet::Parser::ScriptCompiler.new(env, 'test_node_name').compile
-
-        end.to raise_error(/The catalog operation 'multi var assignment from class' is only available when compiling a catalog/)
-      end
-    end
-
-    context 'when using environment manifest' do
-      context 'set to single file' do
-        let (:manifest) { "#{env_dir}/manifests/good.pp" }
-
-        it 'loads and evaluates' do
-          expect(script_compiler.compile).to eql('good')
-        end
-      end
-
-      context 'set to directory' do
-        let (:manifest) { "#{env_dir}/manifests" }
-
-        it 'fails with an error' do
-          expect{script_compiler.compile}.to raise_error(/manifest of environment 'testenv' appoints directory '.*\/manifests'. It must be a file/)
-        end
-      end
-
-      context 'set to non existing path' do
-        let (:manifest) { "#{env_dir}/manyfiests/good.pp" }
-
-        it 'fails with an error' do
-          expect{script_compiler.compile}.to raise_error(/manifest of environment 'testenv' appoints '.*\/good.pp'. It does not exist/)
-        end
-      end
-    end
-  end
-end

data/spec/integration/parser/undef_param_spec.rb

@@ -1,95 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/compiler'
-
-describe "Parameter passing" do
-  include PuppetSpec::Compiler
-
-  before :each do
-    # DataBinding will be consulted before falling back to a default value,
-    # but we aren't testing that here
-    allow(Puppet::DataBinding.indirection).to receive(:find)
-  end
-
-  def expect_the_message_to_be(message, node = Puppet::Node.new('the node'))
-    catalog = compile_to_catalog(yield, node)
-    expect(catalog.resource('Notify', 'something')[:message]).to eq(message)
-  end
-
-  def expect_puppet_error(message, node = Puppet::Node.new('the node'))
-    expect { compile_to_catalog(yield, node) }.to raise_error(Puppet::Error, message)
-  end
-
-  it "overrides the default when a value is given" do
-    expect_the_message_to_be('2') do <<-MANIFEST
-      define a($x='1') { notify { 'something': message => $x }}
-      a {'a': x => '2'}
-      MANIFEST
-    end
-  end
-
-  it "shadows an inherited variable with the default value when undef is passed" do
-    expect_the_message_to_be('default') do <<-MANIFEST
-      class a { $x = 'inherited' }
-      class b($x='default') inherits a { notify { 'something': message => $x }}
-      class { 'b': x => undef}
-      MANIFEST
-    end
-  end
-
-  it "uses a default value that comes from an inherited class when the parameter is undef" do
-    expect_the_message_to_be('inherited') do <<-MANIFEST
-      class a { $x = 'inherited' }
-      class b($y=$x) inherits a { notify { 'something': message => $y }}
-      class { 'b': y => undef}
-      MANIFEST
-    end
-  end
-
-  it "uses a default value that references another variable when the parameter is passed as undef" do
-    expect_the_message_to_be('a') do <<-MANIFEST
-        define a($a = $title) { notify { 'something': message => $a }}
-        a {'a': a => undef}
-      MANIFEST
-    end
-  end
-
-  it "uses the default when 'undef' is given'" do
-    expect_the_message_to_be('1') do <<-MANIFEST
-        define a($x='1') { notify { 'something': message => $x }}
-        a {'a': x => undef}
-      MANIFEST
-    end
-  end
-
-  it "uses the default when no parameter is provided" do
-    expect_the_message_to_be('1') do <<-MANIFEST
-        define a($x='1') { notify { 'something': message => $x }}
-        a {'a': }
-      MANIFEST
-    end
-  end
-
-  it "uses a value of undef when the default is undef and no parameter is provided" do
-    expect_the_message_to_be(true) do <<-MANIFEST
-        define a($x=undef) { notify { 'something': message => $x == undef}}
-        a {'a': }
-    MANIFEST
-    end
-  end
-
-  it "errors when no parameter is provided and there is no default" do
-    expect_puppet_error(/A\[a\]: expects a value for parameter 'x'/) do <<-MANIFEST
-        define a($x) { notify { 'something': message => $x }}
-        a {'a': }
-    MANIFEST
-    end
-  end
-
-  it "uses a given undef and do not require a default expression" do
-    expect_the_message_to_be(true) do <<-MANIFEST
-        define a(Optional[Integer] $x) { notify { 'something': message => $x == undef}}
-        a {'a': x => undef }
-    MANIFEST
-    end
-  end
-end

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

@@ -1,162 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/compiler'
-require 'puppet_spec/files'
-
-# For some reason the provider test will not filter out on windows when using the
-# :if => Puppet.features.microsoft_windows? method of filtering the tests.
-if Puppet.features.microsoft_windows?
-  require 'puppet/util/windows'
-  describe Puppet::Type.type(:file).provider(:windows), '(integration)' do
-    include PuppetSpec::Compiler
-    include PuppetSpec::Files
-
-    def create_temp_file(owner_sid, group_sid, initial_mode)
-      tmp_file = tmpfile('filewindowsprovider')
-      File.delete(tmp_file) if File.exist?(tmp_file)
-      File.open(tmp_file, 'w') { |file| file.write("rspec test") }
-
-      # There are other tests to ensure that these methods do indeed
-      # set the owner and group.  Therefore it's ok to depend on them
-      # here
-      Puppet::Util::Windows::Security.set_owner(owner_sid, tmp_file) unless owner_sid.nil?
-      Puppet::Util::Windows::Security.set_group(group_sid, tmp_file) unless group_sid.nil?
-      # Pretend we are managing the owner and group to FORCE this mode, even if it's "bad"
-      Puppet::Util::Windows::Security.set_mode(initial_mode.to_i(8), tmp_file, true, true, true) unless initial_mode.nil?
-
-      tmp_file
-    end
-
-    def strip_sticky(value)
-      # For the purposes of these tests we don't care about the extra-ace bit in modes
-      # This function removes it
-      value & ~Puppet::Util::Windows::Security::S_IEXTRA
-    end
-
-    sids = {
-      :system => Puppet::Util::Windows::SID::LocalSystem,
-      :administrators => Puppet::Util::Windows::SID::BuiltinAdministrators,
-      :users => Puppet::Util::Windows::SID::BuiltinUsers,
-      :power_users => Puppet::Util::Windows::SID::PowerUsers,
-      :none => Puppet::Util::Windows::SID::Nobody,
-      :everyone => Puppet::Util::Windows::SID::Everyone
-    }
-
-    # Testcase Hash options
-    # create_* : These options are used when creating the initial test file
-    # create_owner (Required!)
-    # create_group (Required!)
-    # create_mode
-    #
-    # manifest_* : These options are used to craft the manifest which is applied to the test file after createion
-    # manifest_owner,
-    # manifest_group,
-    # manifest_mode (Required!)
-    #
-    # actual_* : These options are used to check the _actual_ values as opposed to the munged values from puppet
-    # actual_mode (Uses manifest_mode for checks if not set)
-
-    RSpec.shared_examples "a mungable file resource" do |testcase|
-
-      before(:each) do
-        @tmp_file = create_temp_file(sids[testcase[:create_owner]], sids[testcase[:create_group]], testcase[:create_mode])
-        raise "Could not create temporary file" if @tmp_file.nil?
-      end
-
-      after(:each) do
-        File.delete(@tmp_file) if File.exist?(@tmp_file)
-      end
-
-      context_name = "With initial owner '#{testcase[:create_owner]}' and initial group '#{testcase[:create_owner]}'"
-      context_name += " and initial mode of '#{testcase[:create_mode]}'" unless testcase[:create_mode].nil?
-      context_name += " and a mode of '#{testcase[:manifest_mode]}' in the manifest"
-      context_name += " and an owner of '#{testcase[:manifest_owner]}' in the manifest" unless testcase[:manifest_owner].nil?
-      context_name += " and a group of '#{testcase[:manifest_group]}' in the manifest" unless testcase[:manifest_group].nil?
-
-      context context_name do
-        is_idempotent = testcase[:is_idempotent].nil? || testcase[:is_idempotent]
-
-        let(:manifest) do
-          value = <<-MANIFEST
-            file { 'rspec_example':
-              ensure => present,
-              path   => '#{@tmp_file}',
-              mode   => '#{testcase[:manifest_mode]}',
-          MANIFEST
-          value += "  owner  => '#{testcase[:manifest_owner]}',\n" unless testcase[:manifest_owner].nil?
-          value += "  group  => '#{testcase[:manifest_group]}',\n" unless testcase[:manifest_group].nil?
-          value + "}"
-        end
-
-        it "should apply with no errors and have expected ACL" do
-          apply_with_error_check(manifest)
-          new_mode = strip_sticky(Puppet::Util::Windows::Security.get_mode(@tmp_file))
-          expect(new_mode.to_s(8)).to eq (testcase[:actual_mode].nil? ? testcase[:manifest_mode] : testcase[:actual_mode])
-        end
-
-        it "should be idempotent", :if => is_idempotent do
-          result = apply_with_error_check(manifest)
-          result = apply_with_error_check(manifest)
-          # Idempotent. Should be no changed resources
-          expect(result.changed?.count).to eq 0
-        end
-
-        it "should NOT be idempotent", :unless => is_idempotent do
-          result = apply_with_error_check(manifest)
-          result = apply_with_error_check(manifest)
-          result = apply_with_error_check(manifest)
-          result = apply_with_error_check(manifest)
-          # Not idempotent. Expect changed resources
-          expect(result.changed?.count).to be > 0
-        end
-      end
-    end
-
-    # These scenarios round-trip permissions and are idempotent
-    [
-      { :create_owner => :system,         :create_group => :administrators, :manifest_mode => '760' },
-      { :create_owner => :administrators, :create_group => :administrators, :manifest_mode => '660' },
-      { :create_owner => :system,         :create_group => :system,         :manifest_mode => '770' },
-    ].each do |testcase|
-      # What happens if the owner and group are not managed
-      it_behaves_like "a mungable file resource", testcase
-      # What happens if the owner is managed
-      it_behaves_like "a mungable file resource", testcase.merge({ :manifest_owner => testcase[:create_owner]})
-      # What happens if the group is managed
-      it_behaves_like "a mungable file resource", testcase.merge({ :manifest_group => testcase[:create_group]})
-      # What happens if both the owner and group are managed
-      it_behaves_like "a mungable file resource", testcase.merge({
-        :manifest_owner => testcase[:create_owner],
-        :manifest_group => testcase[:create_group]
-      })
-    end
-
-    # SYSTEM is special in that when specifying less than mode 7, the owner and/or group MUST be managed
-    # otherwise it's munged to 7 behind the scenes and is not idempotent
-    both_system_testcase = { :create_owner => :system, :create_group => :system, :manifest_mode => '660', :actual_mode => '770', :is_idempotent => false }
-    # What happens if the owner and group are not managed
-    it_behaves_like "a mungable file resource", both_system_testcase.merge({ :is_idempotent => true })
-    # What happens if the owner is managed
-    it_behaves_like "a mungable file resource", both_system_testcase.merge({ :manifest_owner => both_system_testcase[:create_owner]})
-    # What happens if the group is managed
-    it_behaves_like "a mungable file resource", both_system_testcase.merge({ :manifest_group => both_system_testcase[:create_group]})
-
-    # However when we manage SYSTEM explicitly, then the modes lower than 7 stick and the file provider
-    # assumes it's insync (i.e. idempotent)
-    it_behaves_like "a mungable file resource", both_system_testcase.merge({
-      :manifest_owner => both_system_testcase[:create_owner],
-      :manifest_group => both_system_testcase[:create_group],
-      :actual_mode    => both_system_testcase[:manifest_mode],
-      :is_idempotent  => true
-    })
-
-    # What happens if we _create_ a file that SYSTEM is a part of, and is Full Control, but the manifest says it should not be Full Control
-    # Behind the scenes the mode should be changed to 7 and be idempotent
-    [
-      { :create_owner => :system,         :create_group => :system,         :manifest_mode => '660' },
-      { :create_owner => :administrators, :create_group => :system,         :manifest_mode => '760' },
-      { :create_owner => :system,         :create_group => :administrators, :manifest_mode => '670' },
-    ].each do |testcase|
-      it_behaves_like "a mungable file resource", testcase.merge({ :create_mode => '770', :actual_mode => '770'})
-    end
-  end
-end

data/spec/integration/resource/catalog_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Resource::Catalog do
-  describe "when using the indirector" do
-    before do
-      # This is so the tests work w/out networking.
-      allow(Facter).to receive(:to_hash).and_return({"hostname" => "foo.domain.com"})
-      allow(Facter).to receive(:value).and_return("eh")
-    end
-
-    it "should be able to delegate to the :yaml terminus" do
-      allow(Puppet::Resource::Catalog.indirection).to receive(:terminus_class).and_return(:yaml)
-
-      # Load now, before we stub the exists? method.
-      terminus = Puppet::Resource::Catalog.indirection.terminus(:yaml)
-      expect(terminus).to receive(:path).with("me").and_return("/my/yaml/file")
-
-      expect(Puppet::FileSystem).to receive(:exist?).with("/my/yaml/file").and_return(false)
-      expect(Puppet::Resource::Catalog.indirection.find("me")).to be_nil
-    end
-
-    it "should be able to delegate to the :compiler terminus" do
-      allow(Puppet::Resource::Catalog.indirection).to receive(:terminus_class).and_return(:compiler)
-
-      # Load now, before we stub the exists? method.
-      compiler = Puppet::Resource::Catalog.indirection.terminus(:compiler)
-
-      node = double('node', :add_server_facts => nil, :trusted_data= => nil, :environment => nil)
-
-      expect(Puppet::Node.indirection).to receive(:find).and_return(node)
-      expect(compiler).to receive(:compile).with(node, anything).and_return(nil)
-
-      expect(Puppet::Resource::Catalog.indirection.find("me")).to be_nil
-    end
-
-    it "should pass provided node information directly to the terminus" do
-      node = double('node')
-      terminus = double('terminus')
-      allow(terminus).to receive(:validate)
-      expect(terminus).to receive(:find) { |request| expect(request.options[:use_node]).to eq(node) }
-
-      allow(Puppet::Resource::Catalog.indirection).to receive(:terminus).and_return(terminus)
-
-      Puppet::Resource::Catalog.indirection.find("me", :use_node => node)
-    end
-  end
-end

data/spec/integration/resource/type_collection_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/files'
-require 'puppet/resource/type_collection'
-
-describe Puppet::Resource::TypeCollection do
-  describe "when autoloading from modules" do
-    include PuppetSpec::Files
-
-    before do
-      @dir = tmpfile("autoload_testing")
-      FileUtils.mkdir_p @dir
-
-      loader = double('loader', load: nil, set_entry: nil)
-      loaders = double('loaders', runtime3_type_loader: loader)
-      expect(Puppet::Pops::Loaders).to receive(:loaders).at_most(:once).and_return(loaders)
-
-      environment = Puppet::Node::Environment.create(:env, [@dir])
-      @code = environment.known_resource_types
-    end
-
-    # Setup a module.
-    def mk_module(name, files = {})
-      mdir = File.join(@dir, name)
-      mandir = File.join(mdir, "manifests")
-      FileUtils.mkdir_p mandir
-
-      defs = files.delete(:define)
-
-      Dir.chdir(mandir) do
-        files.each do |file, classes|
-          File.open("#{file}.pp", "w") do |f|
-            classes.each { |klass|
-              if defs
-                f.puts "define #{klass} {}"
-              else
-                f.puts "class #{klass} {}"
-              end
-            }
-          end
-        end
-      end
-    end
-
-    it "should return nil when a class can't be found or loaded" do
-      expect(@code.find_hostclass('nosuchclass')).to be_nil
-    end
-
-    it "should load the module's init file first" do
-      name = "simple"
-      mk_module(name, :init => [name])
-      expect(@code.find_hostclass(name).name).to eq(name)
-    end
-
-    it "should be able to load definitions from the module base file" do
-      name = "simpdef"
-      mk_module(name, :define => true, :init => [name])
-      expect(@code.find_definition(name).name).to eq(name)
-    end
-
-    it "should be able to load qualified classes from the module base file" do
-      mk_module('both', :init => %w{both both::sub})
-      expect(@code.find_hostclass("both::sub").name).to eq("both::sub")
-    end
-
-    it "should be able load classes from a separate file" do
-      mk_module('separate', :init => %w{separate}, :sub => %w{separate::sub})
-      expect(@code.find_hostclass("separate::sub").name).to eq("separate::sub")
-    end
-
-    it "should not fail when loading from a separate file if there is no module file" do
-      mk_module('alone', :sub => %w{alone::sub})
-      expect { @code.find_hostclass("alone::sub") }.not_to raise_error
-    end
-
-    it "should be able to load definitions from their own file" do
-      name = "mymod"
-      mk_module(name, :define => true, :mydefine => ["mymod::mydefine"])
-      expect(@code.find_definition("mymod::mydefine").name).to eq("mymod::mydefine")
-    end
-
-    it 'should be able to load definitions from their own file using uppercased name' do
-      name = 'mymod'
-      mk_module(name, :define => true, :mydefine => ['mymod::mydefine'])
-      expect(@code.find_definition('Mymod::Mydefine')).not_to be_nil
-    end
-  end
-end