puppet 7.28.0 → 7.29.1

data/spec/integration/node/environment_spec.rb

@@ -1,170 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/files'
-require 'puppet_spec/scope'
-require 'matchers/resource'
-
-describe Puppet::Node::Environment do
-  include PuppetSpec::Files
-  include Matchers::Resource
-
-  def a_module_in(name, dir)
-    Dir.mkdir(dir)
-    moddir = File.join(dir, name)
-    Dir.mkdir(moddir)
-    moddir
-  end
-
-  it "should be able to return each module from its environment with the environment, name, and path set correctly" do
-    base = tmpfile("env_modules")
-    Dir.mkdir(base)
-
-    dirs = []
-    mods = {}
-    %w{1 2}.each do |num|
-      dir = File.join(base, "dir#{num}")
-      dirs << dir
-
-      mods["mod#{num}"] = a_module_in("mod#{num}", dir)
-    end
-
-    environment = Puppet::Node::Environment.create(:foo, dirs)
-
-    environment.modules.each do |mod|
-      expect(mod.environment).to eq(environment)
-      expect(mod.path).to eq(mods[mod.name])
-    end
-  end
-
-  it "should expand 8.3 paths on Windows when creating an environment",
-    :if => Puppet::Util::Platform.windows? do
-
-    # asking for short names only works on paths that exist
-    base = Puppet::Util::Windows::File.get_short_pathname(tmpdir("env_modules"))
-    parent_modules_dir = File.join(base, 'testmoduledir')
-
-    # make sure the paths have ~ in them, indicating unexpanded 8.3 paths
-    expect(parent_modules_dir).to match(/~/)
-
-    module_dir = a_module_in('testmodule', parent_modules_dir)
-
-    # create the environment with unexpanded 8.3 paths
-    environment = Puppet::Node::Environment.create(:foo, [parent_modules_dir])
-
-    # and expect fully expanded paths inside the environment
-    # necessary for comparing module paths internally by the parser
-    expect(environment.modulepath).to eq([Puppet::FileSystem.expand_path(parent_modules_dir)])
-    expect(environment.modules.first.path).to eq(Puppet::FileSystem.expand_path(module_dir))
-  end
-
-  it "should not yield the same module from different module paths" do
-    base = tmpfile("env_modules")
-    Dir.mkdir(base)
-
-    dirs = []
-    %w{1 2}.each do |num|
-      dir = File.join(base, "dir#{num}")
-      dirs << dir
-
-      a_module_in("mod", dir)
-    end
-
-    environment = Puppet::Node::Environment.create(:foo, dirs)
-
-    mods = environment.modules
-    expect(mods.length).to eq(1)
-    expect(mods[0].path).to eq(File.join(base, "dir1", "mod"))
-  end
-
-  it "should not yield a module with the same name as a defined Bolt project" do
-    project_path = File.join(tmpfile('project'), 'bolt_project')
-    FileUtils.mkdir_p(project_path)
-    project = Struct.new("Project", :name, :path, :load_as_module?).new('project', project_path, true)
-
-    Puppet.override(bolt_project: project) do
-      base = tmpfile("base")
-      FileUtils.mkdir_p([File.join(base, 'project'), File.join(base, 'other')])
-      environment = Puppet::Node::Environment.create(:env, [base])
-      mods = environment.modules
-      expect(mods.length).to eq(2)
-      expect(mods.map(&:path)).to eq([project_path, File.join(base, 'other')])
-    end
-  end
-
-  shared_examples_for "the environment's initial import" do |settings|
-    it "a manifest referring to a directory invokes parsing of all its files in sorted order" do
-      settings.each do |name, value|
-        Puppet[name] = value
-      end
-
-      # fixture has three files 00_a.pp, 01_b.pp, and 02_c.pp. The 'b' file
-      # depends on 'a' being evaluated first. The 'c' file is empty (to ensure
-      # empty things do not break the directory import).
-      #
-      dirname = my_fixture('sitedir')
-
-      # Set the manifest to the directory to make it parse and combine them when compiling
-      node = Puppet::Node.new('testnode',
-                              :environment => Puppet::Node::Environment.create(:testing, [], dirname))
-
-      catalog = Puppet::Parser::Compiler.compile(node)
-
-      expect(catalog).to have_resource('Class[A]')
-      expect(catalog).to have_resource('Class[B]')
-      expect(catalog).to have_resource('Notify[variables]').with_parameter(:message, "a: 10, b: 10")
-    end
-  end
-
-  shared_examples_for "the environment's initial import in 4x" do |settings|
-    it "a manifest referring to a directory invokes recursive parsing of all its files in sorted order" do
-      settings.each do |name, value|
-        Puppet[name] = value
-      end
-
-      # fixture has three files 00_a.pp, 01_b.pp, and 02_c.pp. The 'b' file
-      # depends on 'a' being evaluated first. The 'c' file is empty (to ensure
-      # empty things do not break the directory import).
-      #
-      dirname = my_fixture('sitedir2')
-
-      # Set the manifest to the directory to make it parse and combine them when compiling
-      node = Puppet::Node.new('testnode',
-                              :environment => Puppet::Node::Environment.create(:testing, [], dirname))
-
-      catalog = Puppet::Parser::Compiler.compile(node)
-
-      expect(catalog).to have_resource('Class[A]')
-      expect(catalog).to have_resource('Class[B]')
-      expect(catalog).to have_resource('Notify[variables]').with_parameter(:message, "a: 10, b: 10 c: 20")
-    end
-  end
-
-  describe 'using 4x parser' do
-    it_behaves_like "the environment's initial import",
-      # fixture uses variables that are set in a particular order (this ensures
-      # that files are parsed and combined in the right order or an error will
-      # be raised if 'b' is evaluated before 'a').
-      :strict_variables => true
-  end
-
-  describe 'using 4x parser' do
-    it_behaves_like "the environment's initial import in 4x",
-      # fixture uses variables that are set in a particular order (this ensures
-      # that files are parsed and combined in the right order or an error will
-      # be raised if 'b' is evaluated before 'a').
-      :strict_variables => true
-  end
-
-  describe "#extralibs on Windows", :if => Puppet::Util::Platform.windows? do
-
-    describe "with UTF8 characters in PUPPETLIB" do
-      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" }
-
-      before { Puppet::Util::Windows::Process.set_environment_variable('PUPPETLIB', rune_utf8) }
-
-      it "should use UTF8 characters in PUPPETLIB environment variable" do
-        expect(Puppet::Node::Environment.extralibs()).to eq([rune_utf8])
-      end
-    end
-  end
-end

data/spec/integration/node/facts_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Node::Facts do
-  describe "when using the indirector" do
-    it "should expire any cached node instances when it is saved" do
-      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class).and_return(:yaml)
-
-      expect(Puppet::Node::Facts.indirection.terminus(:yaml)).to equal(Puppet::Node::Facts.indirection.terminus(:yaml))
-      terminus = Puppet::Node::Facts.indirection.terminus(:yaml)
-      allow(terminus).to receive(:save)
-
-      expect(Puppet::Node.indirection).to receive(:expire).with("me", be_a(Hash).or(be_nil))
-
-      facts = Puppet::Node::Facts.new("me")
-      Puppet::Node::Facts.indirection.save(facts)
-    end
-
-    it "should be able to delegate to the :yaml terminus" do
-      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class).and_return(:yaml)
-
-      # Load now, before we stub the exists? method.
-      terminus = Puppet::Node::Facts.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::Node::Facts.indirection.find("me")).to be_nil
-    end
-
-    it "should be able to delegate to the :facter terminus" do
-      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class).and_return(:facter)
-
-      expect(Facter).to receive(:to_hash).and_return("facter_hash")
-      facts = Puppet::Node::Facts.new("me")
-      expect(Puppet::Node::Facts).to receive(:new).with("me", "facter_hash").and_return(facts)
-
-      expect(Puppet::Node::Facts.indirection.find("me")).to equal(facts)
-    end
-  end
-end

data/spec/integration/node_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/node'
-
-describe Puppet::Node do
-  describe "when delegating indirection calls" do
-    before do
-      Puppet::Node.indirection.reset_terminus_class
-      Puppet::Node.indirection.cache_class = nil
-
-      @name = "me"
-      @node = Puppet::Node.new(@name)
-    end
-
-    it "should be able to use the yaml terminus" do
-      allow(Puppet::Node.indirection).to receive(:terminus_class).and_return(:yaml)
-
-      # Load now, before we stub the exists? method.
-      terminus = Puppet::Node.indirection.terminus(:yaml)
-
-      expect(terminus).to receive(:path).with(@name).and_return("/my/yaml/file")
-
-      expect(Puppet::FileSystem).to receive(:exist?).with("/my/yaml/file").and_return(false)
-      expect(Puppet::Node.indirection.find(@name)).to be_nil
-    end
-
-    it "should be able to use the plain terminus" do
-      allow(Puppet::Node.indirection).to receive(:terminus_class).and_return(:plain)
-
-      # Load now, before we stub the exists? method.
-      Puppet::Node.indirection.terminus(:plain)
-
-      expect(Puppet::Node).to receive(:new).with(@name).and_return(@node)
-
-      expect(Puppet::Node.indirection.find(@name)).to equal(@node)
-    end
-
-    describe "and using the memory terminus" do
-      before do
-        @name = "me"
-        @terminus = Puppet::Node.indirection.terminus(:memory)
-        allow(Puppet::Node.indirection).to receive(:terminus).and_return(@terminus)
-        @node = Puppet::Node.new(@name)
-      end
-
-      after do
-        @terminus.instance_variable_set(:@instances, {})
-      end
-
-      it "should find no nodes by default" do
-        expect(Puppet::Node.indirection.find(@name)).to be_nil
-      end
-
-      it "should be able to find nodes that were previously saved" do
-        Puppet::Node.indirection.save(@node)
-        expect(Puppet::Node.indirection.find(@name)).to equal(@node)
-      end
-
-      it "should replace existing saved nodes when a new node with the same name is saved" do
-        Puppet::Node.indirection.save(@node)
-        two = Puppet::Node.new(@name)
-        Puppet::Node.indirection.save(two)
-        expect(Puppet::Node.indirection.find(@name)).to equal(two)
-      end
-
-      it "should be able to remove previously saved nodes" do
-        Puppet::Node.indirection.save(@node)
-        Puppet::Node.indirection.destroy(@node.name)
-        expect(Puppet::Node.indirection.find(@name)).to be_nil
-      end
-
-      it "should fail when asked to destroy a node that does not exist" do
-        expect { Puppet::Node.indirection.destroy(@node) }.to raise_error(ArgumentError)
-      end
-    end
-  end
-end

data/spec/integration/parser/catalog_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-require 'matchers/include_in_order'
-require 'puppet_spec/compiler'
-require 'puppet/indirector/catalog/compiler'
-
-describe "A catalog" do
-  include PuppetSpec::Compiler
-
-  context "when compiled" do
-    let(:env) { Puppet::Node::Environment.create(:testing, []) }
-    let(:node) { Puppet::Node.new('test', :environment => env) }
-    let(:loaders) { Puppet::Pops::Loaders.new(env) }
-
-    before(:each) do
-      Puppet.push_context({:loaders => loaders, :current_environment => env})
-      allow_any_instance_of(Puppet::Parser::Compiler).to receive(:loaders).and_return(loaders)
-    end
-
-    after(:each) do
-      Puppet.pop_context()
-    end
-
-    context "when transmitted to the agent" do
-      it "preserves the order in which the resources are added to the catalog" do
-        resources_in_declaration_order = ["Class[First]",
-                                          "Second[position]",
-                                          "Class[Third]",
-                                          "Fourth[position]"]
-
-        master_catalog, agent_catalog = master_and_agent_catalogs_for(<<-EOM)
-          define fourth() { }
-          class third { }
-
-          define second() {
-            fourth { "position": }
-          }
-
-          class first {
-            second { "position": }
-            class { "third": }
-          }
-
-          include first
-        EOM
-
-        expect(resources_in(master_catalog)).
-          to include_in_order(*resources_in_declaration_order)
-        expect(resources_in(agent_catalog)).
-          to include_in_order(*resources_in_declaration_order)
-      end
-    end
-  end
-
-  def master_catalog_for(manifest)
-    Puppet::Resource::Catalog::Compiler.new.filter(compile_to_catalog(manifest, node))
-  end
-
-  def master_and_agent_catalogs_for(manifest)
-    compiler = Puppet::Resource::Catalog::Compiler.new
-    master_catalog = compiler.filter(compile_to_catalog(manifest, node))
-    agent_catalog = Puppet::Resource::Catalog.convert_from(:json, master_catalog.render(:json))
-    [master_catalog, agent_catalog]
-  end
-
-  def resources_in(catalog)
-    catalog.resources.map(&:ref)
-  end
-end

data/spec/integration/parser/class_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/language'
-
-describe "Class expressions" do
-  extend PuppetSpec::Language
-
-  produces(
-    "class hi { }"                                       => '!defined(Class[hi])',
-
-    "class hi { } include hi"                            => 'defined(Class[hi])',
-    "include(hi) class hi { }"                           => 'defined(Class[hi])',
-
-    "class hi { } class { hi: }"                         => 'defined(Class[hi])',
-    "class { hi: } class hi { }"                         => 'defined(Class[hi])',
-
-    "class bye { } class hi inherits bye { } include hi" => 'defined(Class[hi]) and defined(Class[bye])')
-
-  produces(<<-EXAMPLE => 'defined(Notify[foo]) and defined(Notify[bar]) and !defined(Notify[foo::bar])')
-    class bar { notify { 'bar': } }
-    class foo::bar { notify { 'foo::bar': } }
-    class foo inherits bar { notify { 'foo': } }
-
-    include foo
-  EXAMPLE
-
-  produces(<<-EXAMPLE => 'defined(Notify[foo]) and defined(Notify[bar]) and !defined(Notify[foo::bar])')
-    class bar { notify { 'bar': } }
-    class foo::bar { notify { 'foo::bar': } }
-    class foo inherits ::bar { notify { 'foo': } }
-
-    include foo
-  EXAMPLE
-end