puppet 4.8.2-universal-darwin → 4.9.0-universal-darwin

data/spec/integration/application/lookup_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+require 'puppet_spec/files'
+require 'puppet_spec/compiler'
+require 'deep_merge/core'
+
+describe 'lookup' do
+  include PuppetSpec::Files
+
+  context 'with an environment' do
+    let(:env_name) { 'spec' }
+    let(:env_dir) { tmpdir('environments') }
+    let(:environment_files) do
+      {
+        env_name => {
+          'modules' => {},
+          'hiera.yaml' => <<-YAML.unindent,
+            ---
+            version: 5
+            hierarchy:
+              - name: "Common"
+                data_hash: yaml_data
+                path: "common.yaml"
+            YAML
+          'data' => {
+            'common.yaml' => <<-YAML.unindent
+              ---
+              a: value a
+              mod_a::a: value mod_a::a (from environment)
+              mod_a::hash_a:
+                a: value mod_a::hash_a.a (from environment)
+              mod_a::hash_b:
+                a: value mod_a::hash_b.a (from environment)
+              lookup_options:
+                mod_a::hash_b:
+                  merge: hash
+              YAML
+          }
+        },
+        'someother' => {
+        }
+      }
+    end
+
+    let(:app) { Puppet::Application[:lookup] }
+    let(:env) { Puppet::Node::Environment.create(env_name.to_sym, [File.join(populated_env_dir, env_name, 'modules')]) }
+    let(:environments) { Puppet::Environments::Directories.new(populated_env_dir, []) }
+
+    let(:populated_env_dir) do
+      dir_contained_in(env_dir, environment_files)
+      env_dir
+    end
+
+    def lookup(key, options = {}, explain = false)
+      key = [key] unless key.is_a?(Array)
+      app.command_line.stubs(:args).returns(key)
+      if explain
+        app.options[:explain] = true
+        app.options[:render_as] = :s
+      else
+        app.options[:render_as] = :json
+      end
+      options.each_pair { |k, v| app.options[k] = v }
+      capture = StringIO.new
+      saved_stdout = $stdout
+      begin
+        $stdout = capture
+        expect { app.run_command }.to exit_with(0)
+      ensure
+        $stdout = saved_stdout
+      end
+      out = capture.string.strip
+      if explain
+        out
+      else
+        out.empty? ? nil : JSON.parse("[#{out}]")[0]
+      end
+    end
+
+    def explain(key, options = {})
+      lookup(key, options, true)
+    end
+
+    around(:each) do |example|
+      Puppet.override(:environments => environments, :current_environment => env) do
+        example.run
+      end
+    end
+
+    it 'finds data in the environment' do
+      expect(lookup('a')).to eql('value a')
+    end
+
+    context 'configured with the wrong environment' do
+      let(:env) { Puppet::Node::Environment.create(env_name.to_sym, [File.join(populated_env_dir, env_name, 'modules')]) }
+      it 'does not find data in non-existing environment' do
+        Puppet.override(:environments => environments, :current_environment => 'someother') do
+          expect(lookup('a', {}, true)).to match(/did not find a value for the name 'a'/)
+        end
+      end
+    end
+
+    context 'and a module' do
+      let(:mod_a_files) do
+        {
+          'mod_a' => {
+            'data' => {
+              'common.yaml' => <<-YAML.unindent
+                ---
+                mod_a::a: value mod_a::a (from mod_a)
+                mod_a::b: value mod_a::b (from mod_a)
+                mod_a::hash_a:
+                  a: value mod_a::hash_a.a (from mod_a)
+                  b: value mod_a::hash_a.b (from mod_a)
+                mod_a::hash_b:
+                  a: value mod_a::hash_b.a (from mod_a)
+                  b: value mod_a::hash_b.b (from mod_a)
+                mod_a::interpolated: "-- %{lookup('mod_a::a')} --"
+                mod_a::a_a: "-- %{lookup('mod_a::hash_a.a')} --"
+                mod_a::a_b: "-- %{lookup('mod_a::hash_a.b')} --"
+                mod_a::b_a: "-- %{lookup('mod_a::hash_b.a')} --"
+                mod_a::b_b: "-- %{lookup('mod_a::hash_b.b')} --"
+                'mod_a::a.quoted.key': 'value mod_a::a.quoted.key (from mod_a)'
+                YAML
+            },
+            'hiera.yaml' => <<-YAML.unindent,
+              ---
+              version: 5
+              hierarchy:
+                - name: "Common"
+                  data_hash: yaml_data
+                  path: "common.yaml"
+              YAML
+          }
+        }
+      end
+
+      let(:populated_env_dir) do
+        dir_contained_in(env_dir, DeepMerge.deep_merge!(environment_files, env_name => { 'modules' => mod_a_files }))
+        env_dir
+      end
+
+      it 'finds data in the module' do
+        expect(lookup('mod_a::b')).to eql('value mod_a::b (from mod_a)')
+      end
+
+      it 'finds quoted keys in the module' do
+        expect(lookup('"mod_a::a.quoted.key"')).to eql('value mod_a::a.quoted.key (from mod_a)')
+      end
+
+      it 'merges hashes from environment and module when merge strategy hash is used' do
+        expect(lookup('mod_a::hash_a', :merge => 'hash')).to eql({'a' => 'value mod_a::hash_a.a (from environment)', 'b' => 'value mod_a::hash_a.b (from mod_a)'})
+      end
+    end
+  end
+end

data/spec/integration/data_binding_spec.rb

@@ -143,7 +143,7 @@ describe "Data binding" do
   def configure_hiera_for_one_tier(data)
     hiera_config_file = tmpfile("hiera.yaml")
 
-    File.open(hiera_config_file, 'w') do |f|
+    File.open(hiera_config_file, 'w:UTF-8') do |f|
       f.write("---
         :yaml:
           :datadir: #{dir}
@@ -154,7 +154,7 @@ describe "Data binding" do
     end
 
     data.each do | file, contents |
-      File.open(File.join(dir, "#{file}.yaml"), 'w') do |f|
+      File.open(File.join(dir, "#{file}.yaml"), 'w:UTF-8') do |f|
         f.write(YAML.dump(contents))
       end
     end
@@ -165,7 +165,7 @@ describe "Data binding" do
   def configure_hiera_for_two_tier(data)
     hiera_config_file = tmpfile("hiera.yaml")
 
-    File.open(hiera_config_file, 'w') do |f|
+    File.open(hiera_config_file, 'w:UTF-8') do |f|
       f.write("---
         :yaml:
           :datadir: #{dir}
@@ -176,7 +176,7 @@ describe "Data binding" do
     end
 
     data.each do | file, contents |
-      File.open(File.join(dir, "#{file}.yaml"), 'w') do |f|
+      File.open(File.join(dir, "#{file}.yaml"), 'w:UTF-8') do |f|
         f.write(YAML.dump(contents))
       end
     end
@@ -188,7 +188,7 @@ describe "Data binding" do
     module_dir = File.join(dir, module_name, 'manifests')
     FileUtils.mkdir_p(module_dir)
 
-    File.open(File.join(module_dir, name), 'w') do |f|
+    File.open(File.join(module_dir, name), 'w:UTF-8') do |f|
       f.write(manifest)
     end
   end

data/spec/integration/defaults_spec.rb

@@ -235,6 +235,19 @@ describe "Puppet defaults" do
     it "should be set to hiera by default" do
       expect(Puppet.settings[:data_binding_terminus]).to eq(:hiera)
     end
+
+    it "to be neither 'hiera' nor 'none', a deprecation warning is logged" do
+      expect(@logs).to eql([])
+      Puppet[:data_binding_terminus] = 'magic'
+      expect(@logs[0].to_s).to match(/Setting 'data_binding_terminus' is deprecated/)
+    end
+
+    it "to not log a warning if set to 'none' or 'hiera'" do
+      expect(@logs).to eql([])
+      Puppet[:data_binding_terminus] = 'none'
+      Puppet[:data_binding_terminus] = 'hiera'
+      expect(@logs).to eql([])
+    end
   end
 
   describe "agent_catalog_run_lockfile" do

data/spec/integration/environments/default_manifest_spec.rb

@@ -18,11 +18,11 @@ describe "default manifests" do
         manifestsdir = File.join(testingdir, "manifests")
         FileUtils.mkdir_p(manifestsdir)
 
-        File.open(File.join(manifestsdir, "site.pp"), "w") do |f|
+        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") do |f|
+        File.open(File.join(confdir, "puppet.conf"), "w", :encoding => Encoding::UTF_8) do |f|
           f.puts("environmentpath=#{environmentpath}")
         end
 
@@ -43,14 +43,14 @@ describe "default manifests" do
         manifestsdir = File.expand_path("manifests", confdir)
         FileUtils.mkdir_p(manifestsdir)
 
-        File.open(File.join(confdir, "puppet.conf"), "w") do |f|
+        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") do |f|
+        File.open(File.join(manifestsdir, "site.pp"), "w", :encoding => Encoding::UTF_8) do |f|
           f.puts("notify { 'ManifestFromAbsoluteDefaultManifest': }")
         end
 
@@ -61,7 +61,7 @@ describe "default manifests" do
 
       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") do |f|
+        File.open(File.join(confdir, "puppet.conf"), "w", :encoding => Encoding::UTF_8) do |f|
           f.puts(<<-EOF)
   environmentpath=#{environmentpath}
   default_manifest=#{default_manifestsdir}
@@ -71,11 +71,11 @@ describe "default manifests" do
         manifestsdir = File.join(testingdir, "special_manifests")
         FileUtils.mkdir_p(manifestsdir)
 
-        File.open(File.join(manifestsdir, "site.pp"), "w") do |f|
+        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") do |f|
+        File.open(File.join(testingdir, "environment.conf"), "w", :encoding => Encoding::UTF_8) do |f|
           f.puts("manifest=./special_manifests")
         end
 
@@ -89,21 +89,21 @@ describe "default manifests" do
         default_manifestsdir = File.expand_path("manifests", confdir)
         FileUtils.mkdir_p(default_manifestsdir)
 
-        File.open(File.join(confdir, "puppet.conf"), "w") do |f|
+        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") do |f|
+        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") do |f|
+        File.open(File.join(implicit_manifestsdir, "site.pp"), "w", :encoding => Encoding::UTF_8) do |f|
           f.puts("notify { 'ManifestFromImplicitRelativeEnvironmentManifestDirectory': }")
         end
 
@@ -125,7 +125,7 @@ describe "default manifests" do
       before(:each) do
         FileUtils.mkdir_p(manifestsdir)
 
-        File.open(File.join(confdir, "puppet.conf"), "w") do |f|
+        File.open(File.join(confdir, "puppet.conf"), "w", :encoding => Encoding::UTF_8) do |f|
           f.puts(<<-EOF)
   environmentpath=#{environmentpath}
   default_manifest=#{manifestsdir}
@@ -133,7 +133,7 @@ describe "default manifests" do
           EOF
         end
 
-        File.open(File.join(manifestsdir, "site.pp"), "w") do |f|
+        File.open(File.join(manifestsdir, "site.pp"), "w", :encoding => Encoding::UTF_8) do |f|
           f.puts("notify { 'ManifestFromAbsoluteDefaultManifest': }")
         end
       end
@@ -145,7 +145,7 @@ describe "default manifests" do
       end
 
       it "refuses to compile if environment.conf specifies a different manifest" do
-        File.open(File.join(testingdir, "environment.conf"), "w") do |f|
+        File.open(File.join(testingdir, "environment.conf"), "w", :encoding => Encoding::UTF_8) do |f|
           f.puts("manifest=./special_manifests")
         end
 
@@ -155,7 +155,7 @@ describe "default manifests" do
       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") do |f|
+        File.open(File.join(testingdir, "environment.conf"), "w", :encoding => Encoding::UTF_8) do |f|
           f.puts("manifest=#{manifestsdir}")
         end
 
@@ -165,7 +165,7 @@ describe "default manifests" do
       end
 
       it "logs errors if environment.conf specifies a different manifest" do
-        File.open(File.join(testingdir, "environment.conf"), "w") do |f|
+        File.open(File.join(testingdir, "environment.conf"), "w", :encoding => Encoding::UTF_8) do |f|
           f.puts("manifest=./special_manifests")
         end
 
@@ -177,7 +177,7 @@ describe "default manifests" do
       end
 
       it "raises an error if default_manifest is not absolute" do
-        File.open(File.join(confdir, "puppet.conf"), "w") do |f|
+        File.open(File.join(confdir, "puppet.conf"), "w", :encoding => Encoding::UTF_8) do |f|
           f.puts(<<-EOF)
   environmentpath=#{environmentpath}
   default_manifest=./relative

data/spec/integration/environments/setting_hooks_spec.rb

@@ -14,7 +14,7 @@ describe "setting hooks" do
     it "accesses correct directory environment settings after initializing a setting with an on_write hook" do
       expect(Puppet.settings.setting(:certname).call_hook).to eq(:on_write_only) 
 
-      File.open(File.join(confdir, "puppet.conf"), "w") do |f|
+      File.open(File.join(confdir, "puppet.conf"), "w:UTF-8") do |f|
         f.puts("environmentpath=#{environmentpath}")
         f.puts("certname=something")
       end

data/spec/integration/test/test_helper_spec.rb

@@ -7,12 +7,16 @@ describe "Windows UTF8 environment variables", :if => Puppet.features.microsoft_
   # Do not use before and after hooks in these tests as it may have unintended consequences
 
   before(:all) {
-    @varname = 'test-helper-foo'
+    @varname = 'test_helper_spec-test_variable'
     @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"
 
     Puppet::Util::Windows::Process.set_environment_variable(@varname, @rune_utf8)
   }
-
+  after(:all) {
+    # Need to cleanup this environment variable otherwise it contaminates any subsequent tests
+    Puppet::Util::Windows::Process.set_environment_variable(@varname, nil)
+  }
+  
   it "#after_each_test should preserve UTF8 environment variables" do
     envhash = Puppet::Util::Windows::Process.get_environment_strings
     expect(envhash[@varname]).to eq(@rune_utf8)

data/spec/integration/transaction_spec.rb

@@ -266,6 +266,80 @@ describe Puppet::Transaction do
     expect(Puppet::FileSystem.exist?(newfile)).to be_truthy
   end
 
+  # Ensure when resources have been generated with eval_generate that event
+  # propagation still works when filtering with tags
+  context "when filtering with tags" do
+    context "when resources are dependent on dynamically generated resources" do
+      it "should trigger (only) appropriately tagged dependent resources" do
+        source = dir_containing('sourcedir', {'foo' => 'bar'})
+        target = tmpdir('targetdir')
+        file1 = tmpfile("file1")
+        file2 = tmpfile("file2")
+
+        file = Puppet::Type.type(:file).new(
+          :path    => target,
+          :source  => source,
+          :ensure  => :present,
+          :recurse => true,
+          :tag     => "foo_tag",
+        )
+
+        exec1 = Puppet::Type.type(:exec).new(
+          :path        => ENV["PATH"],
+          :command     => touch(file1),
+          :refreshonly => true,
+          :subscribe   => file,
+          :tag         => "foo_tag",
+        )
+
+        exec2 = Puppet::Type.type(:exec).new(
+          :path        => ENV["PATH"],
+          :command     => touch(file2),
+          :refreshonly => true,
+          :subscribe   => file,
+        )
+
+        Puppet[:tags] = "foo_tag"
+        catalog = mk_catalog(file, exec1, exec2)
+        catalog.apply
+        expect(Puppet::FileSystem.exist?(file1)).to be_truthy
+        expect(Puppet::FileSystem.exist?(file2)).to be_falsey
+      end
+
+      it "should trigger implicitly tagged dependent resources, ie via type name" do
+        file1 = tmpfile("file1")
+        file2 = tmpfile("file2")
+
+        exec1 = Puppet::Type.type(:exec).new(
+          :name        => "exec1",
+          :path        => ENV["PATH"],
+          :command     => touch(file1),
+        )
+
+        exec1.stubs(:eval_generate).returns(
+          [ (Puppet::Type.type(:notify).new :name => "eval1_notify")]
+        )
+
+        exec2 = Puppet::Type.type(:exec).new(
+          :name        => "exec2",
+          :path        => ENV["PATH"],
+          :command     => touch(file2),
+          :refreshonly => true,
+          :subscribe   => exec1,
+        )
+        exec2.stubs(:eval_generate).returns(
+          [ (Puppet::Type.type(:notify).new :name => "eval2_notify")]
+        )
+
+        Puppet[:tags] = "exec"
+        catalog = mk_catalog(exec1, exec2)
+        catalog.apply
+        expect(Puppet::FileSystem.exist?(file1)).to be_truthy
+        expect(Puppet::FileSystem.exist?(file2)).to be_truthy
+      end
+    end
+  end
+
   describe "skipping resources" do
     let(:fname) { tmpfile("exec") }
 

data/spec/integration/util/execution_spec.rb

@@ -17,6 +17,14 @@ describe Puppet::Util::Execution do
     end
   end
 
+  describe "#execute (non-Windows)", :if => !Puppet.features.microsoft_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.features.microsoft_windows? do
     let(:utf8text) do
       # Japanese Lorem Ipsum snippet

data/spec/lib/puppet_spec/module_tool/shared_functions.rb

@@ -31,7 +31,7 @@ module PuppetSpec
         if options.nil?
           expect(release).to be_nil
         else
-          from = options.keys.find { |k| k.nil? || k.is_a?(Semantic::Version) }
+          from = options.keys.find { |k| k.nil? || k.is_a?(SemanticPuppet::Version) }
           to   = options.delete(from)
 
           if to or from
@@ -49,7 +49,7 @@ module PuppetSpec
       end
 
       def v(str)
-        Semantic::Version.parse(str)
+        SemanticPuppet::Version.parse(str)
       end
     end
   end

data/spec/lib/puppet_spec/module_tool/stub_source.rb

@@ -1,6 +1,6 @@
 module PuppetSpec
   module ModuleTool
-    class StubSource < Semantic::Dependency::Source
+    class StubSource < SemanticPuppet::Dependency::Source
       def inspect; "Stub Source"; end
       def host
         "http://nowhe.re"

data/spec/lib/puppet_spec/unindent.rb

@@ -1,5 +1,5 @@
 class String
-  def unindent
-    gsub(/^#{scan(/^\s*/).min_by{ |l| l.length }}/, '')
+  def unindent(left_padding = '')
+    gsub(/^#{scan(/^\s*/).min_by{ |l| l.length }}/, left_padding)
   end
 end

data/spec/unit/application/face_base_spec.rb

@@ -267,6 +267,22 @@ describe Puppet::Application::FaceBase do
       app.expects(:render).with(app.arguments.length + 1, ["myname", "myarg"])
       expect { app.main }.to exit_with(0)
     end
+
+    it "should issue a deprecation warning if the face is deprecated" do
+      # since app is shared across examples, stub to avoid affecting shared context
+      app.face.stubs(:deprecated?).returns(true)
+      app.face.expects(:foo).with(*app.arguments)
+      Puppet.expects(:deprecation_warning).with(regexp_matches(/'puppet basetest' is deprecated/))
+      expect { app.main }.to exit_with(0)
+    end
+
+    it "should not issue a deprecation warning if the face is not deprecated" do
+      Puppet.expects(:deprecation_warning).never
+      # since app is shared across examples, stub to avoid affecting shared context
+      app.face.stubs(:deprecated?).returns(false)
+      app.face.expects(:foo).with(*app.arguments)
+      expect { app.main }.to exit_with(0)
+    end
   end
 
   describe "error reporting" do