puppet 4.4.0 → 4.5.0

data/spec/unit/appmgmt_spec.rb

@@ -1,34 +1,33 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
-require_relative 'pops/parser/parser_rspec_helper'
 require 'puppet/parser/environment_compiler'
 
 describe "Application instantiation" do
   include PuppetSpec::Compiler
-  # We pull this in because we need access to with_app_management; and
-  # since that has to root around in the guts of the Pops parser, there's
-  # no really elegant way to do this
-  include ParserRspecHelper
 
-  def compile_to_env_catalog(string)
+  let(:env) { Puppet::Node::Environment.create(:testing, []) }
+  let(:node) { Puppet::Node.new('test', :environment => env) }
+  let(:loaders) { Puppet::Pops::Loaders.new(env) }
+
+  def compile_to_env_catalog(string, code_id=nil)
     Puppet[:code] = string
-    env = Puppet::Node::Environment.create("test", ["/dev/null"])
-    Puppet::Parser::EnvironmentCompiler.compile(env).filter { |r| r.virtual? }
+    Puppet::Parser::EnvironmentCompiler.compile(env, code_id).filter { |r| r.virtual? }
   end
 
-
-  before :each do
-    with_app_management(true)
-    Puppet::Type.newtype :cap, :is_capability => true do
-      newparam :name
-      newparam :host
+  around :each do |example|
+    Puppet[:app_management] = true
+    Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
+    Puppet::Parser::EnvironmentCompiler.any_instance.stubs(:loaders).returns(loaders)
+    Puppet.override(:loaders => loaders, :current_environment => env) do
+      Puppet::Type.newtype :cap, :is_capability => true do
+        newparam :name
+        newparam :host
+      end
+      example.run
+      Puppet::Type.rmtype(:cap)
     end
-  end
-
-  after :each do
-    Puppet::Type.rmtype(:cap)
-    with_app_management(false)
+    Puppet[:app_management] = false
   end
 
   MANIFEST = <<-EOS
@@ -318,29 +317,29 @@ MANIFEST_WITH_CLASS = <<-EOS
 EOS
 
 
-  describe "a node catalog" do
+  context 'a node catalog' do
     it "is unaffected for a non-participating node" do
-      catalog = compile_to_catalog(MANIFEST, Puppet::Node.new('other'))
+      catalog = compile_to_catalog(MANIFEST, Puppet::Node.new('other', :environment => env))
       types = catalog.resource_keys.map { |type, _| type }.uniq.sort
       expect(types).to eq(["Class", "Stage"])
     end
 
     it "an application instance must be contained in a site" do
-      expect { compile_to_catalog(FAULTY_MANIFEST, Puppet::Node.new('first'))
+      expect { compile_to_catalog(FAULTY_MANIFEST, Puppet::Node.new('first', :environment => env))
       }.to raise_error(/Application instances .* can only be contained within a Site/)
     end
 
     it "does not raise an error when node mappings are not provided" do
-      expect { compile_to_catalog(MANIFEST_WO_NODE) }.to_not raise_error
+      expect { compile_to_catalog(MANIFEST_WO_NODE, node) }.to_not raise_error
     end
 
     it "raises an error if node mapping is a string" do
-      expect { compile_to_catalog(MANIFEST_WITH_STRING_NODES)
+      expect { compile_to_catalog(MANIFEST_WITH_STRING_NODES, node)
       }.to raise_error(/Invalid node mapping in .*: Mapping must be a hash/)
     end
 
     it "raises an error if node mapping is false" do
-      expect { compile_to_catalog(MANIFEST_WITH_FALSE_NODES)
+      expect { compile_to_catalog(MANIFEST_WITH_FALSE_NODES, node)
       }.to raise_error(/Invalid node mapping in .*: Mapping must be a hash/)
     end
 
@@ -360,7 +359,7 @@ EOS
     end
 
     context "for producing node" do
-      let(:compiled_node) { Puppet::Node.new('first') }
+      let(:compiled_node) { Puppet::Node.new('first', :environment => env) }
       let(:compiled_catalog) { compile_to_catalog(MANIFEST, compiled_node)}
 
       { "App[anapp]"         => 'application instance',
@@ -379,7 +378,7 @@ EOS
     end
 
     context "for consuming node" do
-      let(:compiled_node) { Puppet::Node.new('second') }
+      let(:compiled_node) { Puppet::Node.new('second', :environment => env) }
       let(:compiled_catalog) { compile_to_catalog(MANIFEST, compiled_node)}
       let(:cap) {
         the_cap = Puppet::Resource.new("Cap", "cap")
@@ -407,7 +406,7 @@ EOS
     end
 
     context "for node with class producer" do
-      let(:compiled_node) { Puppet::Node.new('first') }
+      let(:compiled_node) { Puppet::Node.new('first', :environment => env) }
       let(:compiled_catalog) { compile_to_catalog(MANIFEST_WITH_CLASS, compiled_node)}
 
       { "App[anapp]"      => 'application instance',
@@ -427,7 +426,7 @@ EOS
     end
 
     context "for node with class consumer" do
-      let(:compiled_node) { Puppet::Node.new('second') }
+      let(:compiled_node) { Puppet::Node.new('second', :environment => env) }
       let(:compiled_catalog) { compile_to_catalog(MANIFEST_WITH_CLASS, compiled_node)}
       let(:cap) {
         the_cap = Puppet::Resource.new("Cap", "cap")
@@ -460,7 +459,7 @@ EOS
       # that are used to instantiate an application. The application instances are needed.
       #
       it "the node expressions is evaluated" do
-        catalog = compile_to_catalog(MANIFEST_WITH_SITE, Puppet::Node.new('other'))
+        catalog = compile_to_catalog(MANIFEST_WITH_SITE, Puppet::Node.new('other', :environment => env))
         types = catalog.resource_keys.map { |type, _| type }.uniq.sort
         expect(types).to eq(["Class", "Node", "Notify", "Stage"])
         expect(catalog.resource("Notify[on a node]")).to_not be_nil
@@ -471,7 +470,7 @@ EOS
 
     context "when using a site expression" do
       it "the site expression is not evaluated in a node compilation" do
-        catalog = compile_to_catalog(MANIFEST_WITH_SITE, Puppet::Node.new('other'))
+        catalog = compile_to_catalog(MANIFEST_WITH_SITE, Puppet::Node.new('other', :environment => env))
         types = catalog.resource_keys.map { |type, _| type }.uniq.sort
         expect(types).to eq(["Class", "Node", "Notify", "Stage"])
         expect(catalog.resource("Notify[on a node]")).to_not be_nil
@@ -574,12 +573,22 @@ EOS
         }.to raise_error(/Only application components can appear inside a site - Notify\[fail me\] is not allowed at line 20/)
       end
     end
+
+    it "includes code_id if specified" do
+      catalog = compile_to_env_catalog(MANIFEST_WITH_SITE, "12345")
+      expect(catalog.code_id).to eq("12345")
+    end
+
+    it "omits code_id if unspecified" do
+      catalog = compile_to_env_catalog(MANIFEST_WITH_SITE)
+      expect(catalog.code_id).to be_nil
+    end
   end
 
 
   describe "when validation of nodes" do
     it 'validates that the key of a node mapping is a Node' do
-      expect { compile_to_catalog(<<-EOS, Puppet::Node.new('other'))
+      expect { compile_to_catalog(<<-EOS, Puppet::Node.new('other', :environment => env))
         application app {
         }
 
@@ -595,7 +604,7 @@ EOS
     end
 
     it 'validates that the value of a node mapping is a resource' do
-      expect { compile_to_catalog(<<-EOS, Puppet::Node.new('other'))
+      expect { compile_to_catalog(<<-EOS, Puppet::Node.new('other', :environment => env))
         application app {
         }
 
@@ -611,7 +620,7 @@ EOS
     end
 
     it 'validates that the value can be an array or resources' do
-      expect { compile_to_catalog(<<-EOS, Puppet::Node.new('other'))
+      expect { compile_to_catalog(<<-EOS, Puppet::Node.new('other', :environment => env))
         define p {
           notify {$title:}
         }
@@ -633,7 +642,7 @@ EOS
     end
 
     it 'validates that the is bound to exactly one node' do
-      expect { compile_to_catalog(<<-EOS, Puppet::Node.new('first'))
+      expect { compile_to_catalog(<<-EOS, Puppet::Node.new('first', :environment => env))
         define p {
           notify {$title:}
         }

data/spec/unit/capability_spec.rb

@@ -1,33 +1,30 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
-require_relative 'pops/parser/parser_rspec_helper'
 
-describe "Capability types" do
+describe 'Capability types' do
   include PuppetSpec::Compiler
-  # We pull this in because we need access to with_app_management; and
-  # since that has to root around in the guts of the Pops parser, there's
-  # no really elegant way to do this
-  include ParserRspecHelper
-
-  def make_cap_type
-    Puppet::Type.newtype :cap, :is_capability => true do
-      newparam :name
-      newparam :host
+  let(:env) { Puppet::Node::Environment.create(:testing, []) }
+  let(:node) { Puppet::Node.new('test', :environment => env) }
+  let(:loaders) { Puppet::Pops::Loaders.new(env) }
+
+  around :each do |example|
+    Puppet[:app_management] = true
+    Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
+    Puppet.override(:loaders => loaders, :current_environment => env) do
+      Puppet::Type.newtype :cap, :is_capability => true do
+        newparam :name
+        newparam :host
+      end
+      example.run
+      Puppet::Type.rmtype(:cap)
     end
+    Puppet[:app_management] = false
   end
 
-  before :each do
-    with_app_management(true)
-  end
-
-  after :each do
-    with_app_management(false)
-  end
-
-  describe "annotations" do
+  context 'annotations' do
     it "adds a blueprint for a produced resource" do
-      catalog = compile_to_catalog(<<-MANIFEST)
+      catalog = compile_to_catalog(<<-MANIFEST, node)
       define test($hostname) {
         notify { "hostname ${hostname}":}
       }
@@ -49,7 +46,7 @@ describe "Capability types" do
     end
 
     it "adds a blueprint for a consumed resource" do
-      catalog = compile_to_catalog(<<-MANIFEST)
+      catalog = compile_to_catalog(<<-MANIFEST, node)
       define test($hostname) {
         notify { "hostname ${hostname}":}
       }
@@ -136,7 +133,7 @@ describe "Capability types" do
     end
     it "does not allow operator '+>' in a mapping" do
       expect do
-      compile_to_catalog(<<-MANIFEST)
+      compile_to_catalog(<<-MANIFEST, node)
         define test($hostname) {
           notify { "hostname ${hostname}":}
         }
@@ -150,7 +147,7 @@ describe "Capability types" do
 
     it "does not allow operator '*=>' in a mapping" do
       expect do
-        compile_to_catalog(<<-MANIFEST)
+        compile_to_catalog(<<-MANIFEST, node)
         define test($hostname) {
           notify { "hostname ${hostname}":}
         }
@@ -163,9 +160,8 @@ describe "Capability types" do
     end
 
     it "does not allow 'before' relationship to capability mapping" do
-      make_cap_type
       expect do
-        compile_to_catalog(<<-MANIFEST)
+        compile_to_catalog(<<-MANIFEST, node)
         define test() {
           notify { "hello":}
         }
@@ -186,22 +182,14 @@ describe "Capability types" do
       MANIFEST
 
         expect {
-          compile_to_catalog(manifest)
+          compile_to_catalog(manifest, node)
         }.to raise_error(Puppet::Error,
                          /#{kw} clause references nonexistent type Test/)
       end
     end
   end
 
-  describe "exporting a capability" do
-    before(:each) do
-      make_cap_type
-    end
-
-    after :each do
-      Puppet::Type.rmtype(:cap)
-    end
-
+  context 'exporting a capability' do
     it "does not add produced resources that are not exported" do
       manifest = <<-MANIFEST
 define test($hostname) {
@@ -214,7 +202,7 @@ Test produces Cap {
 
 test { one: hostname => "ahost" }
     MANIFEST
-      catalog = compile_to_catalog(manifest)
+      catalog = compile_to_catalog(manifest, node)
       expect(catalog.resource("Test[one]")).to be_instance_of(Puppet::Resource)
       expect(catalog.resource_keys.find { |type, _| type == "Cap" }).to be_nil
     end
@@ -236,7 +224,7 @@ Test produces Cap {
 
 test { one: hostname => "ahost", export => Cap[two] }
     MANIFEST
-      catalog = compile_to_catalog(manifest)
+      catalog = compile_to_catalog(manifest, node)
       expect(catalog.resource("Test[one]")).to be_instance_of(Puppet::Resource)
 
       caps = catalog.resource_keys.select { |type, _| type == "Cap" }
@@ -247,19 +235,11 @@ test { one: hostname => "ahost", export => Cap[two] }
       expect(cap["require"]).to eq("Test[one]")
       expect(cap["host"]).to eq("ahost")
       expect(cap.resource_type).to eq(Puppet::Type::Cap)
-      expect(cap.tags.any? { |t| t == "producer:production" }).to eq(true)
+      expect(cap.tags.any? { |t| t == 'producer:testing' }).to eq(true)
     end
   end
 
-  describe "consuming a capability" do
-    before(:each) do
-      make_cap_type
-    end
-
-    after :each do
-      Puppet::Type.rmtype(:cap)
-    end
-
+  context 'consuming a capability' do
     def make_catalog(instance)
       manifest = <<-MANIFEST
       define test($hostname = nohost) {
@@ -270,7 +250,7 @@ test { one: hostname => "ahost", export => Cap[two] }
         hostname => $host
       }
     MANIFEST
-      compile_to_catalog(manifest + instance)
+      compile_to_catalog(manifest + instance, node)
     end
 
     def mock_cap_finding
@@ -322,10 +302,10 @@ test { one: hostname => "ahost", export => Cap[two] }
       end
     end
 
-    describe 'producing/consuming resources' do
+    context 'producing/consuming resources' do
 
       let(:ral) do
-        compile_to_ral(<<-MANIFEST)
+        compile_to_ral(<<-MANIFEST, node)
   define producer() {
     notify { "producer":}
   }
@@ -365,10 +345,10 @@ test { one: hostname => "ahost", export => Cap[two] }
       end
     end
 
-    describe 'producing/consuming resources to/from classes' do
+    context 'producing/consuming resources to/from classes' do
 
       let(:ral) do
-        compile_to_ral(<<-MANIFEST)
+        compile_to_ral(<<-MANIFEST, node)
   define test($hostname) {
     notify { $hostname:}
   }

data/spec/unit/data_providers/function_data_provider_spec.rb

@@ -43,7 +43,7 @@ describe "when using function data provider" do
     node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}), :environment => 'production')
     compiler = Puppet::Parser::Compiler.new(node)
     catalog = compiler.compile()
-    resources_created_in_fixture = ["Notify[env_test1]", "Notify[env_test2]", "Notify[module_test3]"]
+    resources_created_in_fixture = ["Notify[env_test1]", "Notify[env_test2]", "Notify[module_test3]", "Notify[env_test2-ipl]"]
     expect(resources_in(catalog)).to include(*resources_created_in_fixture)
   end
 
@@ -56,6 +56,24 @@ describe "when using function data provider" do
     expect(resources_in(catalog)).to include(*resources_created_in_fixture)
   end
 
+  it 'gets data from puppet function delivering environment data' do
+    Puppet[:code] = <<-CODE
+      function environment::data() {
+        { 'cls::test1' => 'env_puppet1',
+          'cls::test2' => 'env_puppet2'
+        }
+      }
+      class cls ($test1, $test2) {
+        notify { $test1: }
+        notify { $test2: }
+      }
+      include cls
+    CODE
+    node = Puppet::Node.new('testnode', :facts => Puppet::Node::Facts.new('facts', {}), :environment => 'production')
+    catalog = Puppet::Parser::Compiler.new(node).compile
+    expect(resources_in(catalog)).to include('Notify[env_puppet1]', 'Notify[env_puppet2]')
+  end
+
   it 'raises an error if the environment data function does not return a hash' do
     Puppet[:code] = 'include abc'
     # find the loaders to patch with faulty function

data/spec/unit/data_providers/hiera_data_provider_spec.rb

@@ -45,7 +45,7 @@ describe "when using a hiera data provider" do
 
   it 'reads hiera.yaml in environment root and configures multiple json and yaml providers' do
     resources = compile_and_get_notifications('hiera_env_config')
-    expect(resources).to include('env data param_a is 10, env data param_b is 20, env data param_c is 30, env data param_d is 40, env data param_e is 50')
+    expect(resources).to include("env data param_a is 10, env data param_b is 20, env data param_c is 30, env data param_d is 40, env data param_e is 50, env data param_yaml_utf8 is \u16EB\u16D2\u16E6, env data param_json_utf8 is \u16A0\u16C7\u16BB")
   end
 
   it 'reads hiera.yaml in module root and configures multiple json and yaml providers' do
@@ -186,7 +186,7 @@ Merge strategy first
       Path "#{environmentpath}/hiera_misc/data/common.yaml"
         Original path: "common"
         Interpolation on "Value from interpolation %{scope("target_scope")}"
-          Global Scope"
+          Global Scope
             Found key: "target_scope" value: "with scope"
         Found key: "km_scope" value: "Value from interpolation with scope"
   Merged result: "Value from interpolation with scope"

data/spec/unit/defaults_spec.rb

@@ -72,6 +72,24 @@ describe "Defaults" do
 
   end
 
+  describe 'strict' do
+    it 'should accept the valid value :off' do
+      expect {Puppet.settings[:strict] = 'off'}.to_not raise_exception
+    end
+
+    it 'should accept the valid value :warning' do
+      expect {Puppet.settings[:strict] = 'warning'}.to_not raise_exception
+    end
+
+    it 'should accept the valid value :error' do
+      expect {Puppet.settings[:strict] = 'error'}.to_not raise_exception
+    end
+
+    it 'should fail if given an invalid value' do
+      expect {Puppet.settings[:strict] = 'ignore'}.to raise_exception(/Invalid value 'ignore' for parameter strict\./)
+    end
+  end
+
   describe 'supported_checksum_types' do
     it 'should default to md5,sha256' do
       expect(Puppet.settings[:supported_checksum_types]).to eq(['md5', 'sha256'])

data/spec/unit/file_system/uniquefile_spec.rb

@@ -46,6 +46,26 @@ describe Puppet::FileSystem::Uniquefile do
     expect(Puppet::FileSystem.exist?(filename)).to be_falsey
   end
 
+  it "propagates lock creation failures" do
+    # use an arbitrary exception so as not accidentally collide
+    # with the ENOENT that occurs when trying to call rmdir
+    Puppet::FileSystem::Uniquefile.stubs(:mkdir).raises 'arbitrary failure'
+    Puppet::FileSystem::Uniquefile.expects(:rmdir).never
+
+    expect {
+      Puppet::FileSystem::Uniquefile.open_tmp('foo') { |tmp| }
+    }.to raise_error('arbitrary failure')
+  end
+
+  it "only removes lock files that exist" do
+    # prevent the .lock directory from being created
+    Puppet::FileSystem::Uniquefile.stubs(:mkdir) { }
+
+    # and expect cleanup to be skipped
+    Puppet::FileSystem::Uniquefile.expects(:rmdir).never
+
+    Puppet::FileSystem::Uniquefile.open_tmp('foo') { |tmp| }
+  end
 
   context "Ruby 1.9.3 Tempfile tests" do
     # the remaining tests in this file are ported directly from the ruby 1.9.3 source,

data/spec/unit/file_system_spec.rb

@@ -243,6 +243,67 @@ describe "Puppet::FileSystem" do
       end
     end
 
+    it "should return false for exist? when resolving a cyclic symlink chain" do
+      # point symlink -> file
+      symlink = tmpfile("somefile_link")
+      Puppet::FileSystem.symlink(file, symlink)
+
+      # point symlink2 -> symlink
+      symlink2 = tmpfile("somefile_link2")
+      Puppet::FileSystem.symlink(symlink, symlink2)
+
+      # point symlink3 -> symlink2
+      symlink3 = tmpfile("somefile_link3")
+      Puppet::FileSystem.symlink(symlink2, symlink3)
+
+      # yank file, temporarily dangle
+      ::File.delete(file)
+
+      # and trash it so that we can recreate it OK on windows
+      Puppet::FileSystem.unlink(symlink)
+
+      # point symlink -> symlink3 to create a cycle
+      Puppet::FileSystem.symlink(symlink3, symlink)
+
+      expect(Puppet::FileSystem.exist?(symlink3)).to be_falsey
+    end
+
+    it "should return true for exist? when resolving a symlink chain pointing to a file" do
+      # point symlink -> file
+      symlink = tmpfile("somefile_link")
+      Puppet::FileSystem.symlink(file, symlink)
+
+      # point symlink2 -> symlink
+      symlink2 = tmpfile("somefile_link2")
+      Puppet::FileSystem.symlink(symlink, symlink2)
+
+      # point symlink3 -> symlink2
+      symlink3 = tmpfile("somefile_link3")
+      Puppet::FileSystem.symlink(symlink2, symlink3)
+
+      expect(Puppet::FileSystem.exist?(symlink3)).to be_truthy
+    end
+
+    it "should return false for exist? when resolving a symlink chain that dangles" do
+      # point symlink -> file
+      symlink = tmpfile("somefile_link")
+      Puppet::FileSystem.symlink(file, symlink)
+
+      # point symlink2 -> symlink
+      symlink2 = tmpfile("somefile_link2")
+      Puppet::FileSystem.symlink(symlink, symlink2)
+
+      # point symlink3 -> symlink2
+      symlink3 = tmpfile("somefile_link3")
+      Puppet::FileSystem.symlink(symlink2, symlink3)
+
+      # yank file, and make symlink dangle
+      ::File.delete(file)
+
+      # symlink3 is now indirectly dangled
+      expect(Puppet::FileSystem.exist?(symlink3)).to be_falsey
+    end
+
     it "should not create a symlink when the :noop option is specified" do
       [file, dir].each do |target|
         symlink = tmpfile("#{Puppet::FileSystem.basename(target)}_link")