puppet 4.0.0 → 4.5.0

data/spec/integration/application/apply_spec.rb

@@ -41,18 +41,31 @@ describe "apply" do
     expect(@logs.map(&:to_s)).to include('it was applied')
   end
 
+  it "adds environment to the $server_facts variable if trusted_server_facts is true" do
+    manifest = file_containing("manifest.pp", "notice(\"$server_facts\")")
+    Puppet[:trusted_server_facts] = true
+
+    puppet = Puppet::Application[:apply]
+    puppet.stubs(:command_line).returns(stub('command_line', :args => [manifest]))
+
+    expect { puppet.run_command }.to exit_with(0)
+
+    expect(@logs.map(&:to_s)).to include(/{environment =>.*/)
+  end
+
   it "applies a given file even when an ENC is configured", :if => !Puppet.features.microsoft_windows? do
     manifest = file_containing("manifest.pp", "notice('specific manifest applied')")
-    site_manifest = file_containing("site_manifest.pp", "notice('the site manifest was applied instead')")
-    enc = file_containing("enc_script", "#!/bin/sh\necho 'classes: []'")
-    File.chmod(0755, enc)
+    enc = script_containing('enc_script',
+      :windows => '@echo classes: []' + "\n" + '@echo environment: special',
+      :posix   => '#!/bin/sh' + "\n" + 'echo "classes: []"' + "\n" + 'echo "environment: special"')
+
+    Dir.mkdir(File.join(Puppet[:environmentpath], "special"), 0755)
 
     special = Puppet::Node::Environment.create(:special, [])
     Puppet.override(:current_environment => special) do
       Puppet[:environment] = 'special'
       Puppet[:node_terminus] = 'exec'
       Puppet[:external_nodes] = enc
-      Puppet[:manifest] = site_manifest
       puppet = Puppet::Application[:apply]
       puppet.stubs(:command_line).returns(stub('command_line', :args => [manifest]))
       expect { puppet.run_command }.to exit_with(0)
@@ -61,21 +74,62 @@ describe "apply" do
     expect(@logs.map(&:to_s)).to include('specific manifest applied')
   end
 
-  context "with a module" do
-    let(:modulepath) { tmpdir('modulepath') }
+  context "handles errors" do
+    it "logs compile errors once" do
+      Puppet.initialize_settings([])
+      apply = Puppet::Application.find(:apply).new(stub('command_line', :subcommand_name => :apply, :args => []))
+      apply.options[:code] = '08'
+
+      msg = 'valid octal'
+      callback = Proc.new do |actual|
+        expect(actual.scan(Regexp.new(msg))).to eq([msg])
+      end
+
+      expect do
+        apply.run
+      end.to have_printed(callback).and_exit_with(1)
+    end
+
+    it "logs compile post processing errors once" do
+      Puppet.initialize_settings([])
+      apply = Puppet::Application.find(:apply).new(stub('command_line', :subcommand_name => :apply, :args => []))
+      path = File.expand_path('/tmp/content_file_test.Q634Dlmtime')
+      apply.options[:code] = "file { '#{path}':
+        content => 'This is the test file content',
+        ensure => present,
+        checksum => mtime
+      }"
+
+      msg = 'You cannot specify content when using checksum'
+      callback = Proc.new do |actual|
+        expect(actual.scan(Regexp.new(msg))).to eq([msg])
+      end
+
+      expect do
+        apply.run
+      end.to have_printed(callback).and_exit_with(1)
+    end
+  end
+
+  context "with a module in an environment" do
+    let(:envdir) { tmpdir('environments') }
+    let(:modulepath) { File.join(envdir, 'spec', 'modules') }
     let(:execute) { 'include amod' }
-    let(:args) { ['-e', execute, '--modulepath', modulepath] }
 
     before(:each) do
-      dir_contained_in(modulepath, {
-        "amod" => {
-          "manifests" => {
-            "init.pp" => "class amod{ notice('amod class included') }"
+      dir_contained_in(envdir, {
+        "spec" => {
+          "modules" => {
+            "amod" => {
+              "manifests" => {
+                "init.pp" => "class amod{ notice('amod class included') }"
+              }
+            }
           }
         }
       })
 
-      Puppet[:environmentpath] = dir_containing("environments", { Puppet[:environment] => {} })
+      Puppet[:environmentpath] = envdir
     end
 
     def init_cli_args_and_apply_app(args, execute)
@@ -85,31 +139,68 @@ describe "apply" do
       return puppet
     end
 
-    it "looks in --modulepath even when the default directory environment exists" do
-      apply = init_cli_args_and_apply_app(args, execute)
+    context "given the --modulepath option" do
+      let(:args) { ['-e', execute, '--modulepath', modulepath] }
 
-      expect do
-        expect { apply.run }.to exit_with(0)
-      end.to have_printed('amod class included')
-    end
+      it "looks in --modulepath even when the default directory environment exists" do
+        apply = init_cli_args_and_apply_app(args, execute)
 
-    it "looks in --modulepath even when given a specific directory --environment" do
-      args << '--environment' << 'production'
-      apply = init_cli_args_and_apply_app(args, execute)
+        expect do
+          expect { apply.run }.to exit_with(0)
+        end.to have_printed('amod class included')
+      end
 
-      expect do
-        expect { apply.run }.to exit_with(0)
-      end.to have_printed('amod class included')
+      it "looks in --modulepath even when given a specific directory --environment" do
+        args << '--environment' << 'production'
+        apply = init_cli_args_and_apply_app(args, execute)
+
+        expect do
+          expect { apply.run }.to exit_with(0)
+        end.to have_printed('amod class included')
+      end
+
+      it "looks in --modulepath when given multiple paths in --modulepath" do
+        args = ['-e', execute, '--modulepath', [tmpdir('notmodulepath'), modulepath].join(File::PATH_SEPARATOR)]
+        apply = init_cli_args_and_apply_app(args, execute)
+
+        expect do
+          expect { apply.run }.to exit_with(0)
+        end.to have_printed('amod class included')
+      end
     end
 
-    it "looks in --modulepath when given multiple paths in --modulepath" do
-      args = ['-e', execute, '--modulepath', [tmpdir('notmodulepath'), modulepath].join(File::PATH_SEPARATOR)]
-      apply = init_cli_args_and_apply_app(args, execute)
+    # When executing an ENC script, output cannot be captured using
+    # expect { }.to have_printed(...)
+    # External node script execution will fail, likely due to the tampering
+    # with the basic file descriptors.
+    # Workaround: Define a log destination and merely inspect logs.
+    context "with an ENC" do
+      let(:logdest) { tmpfile('logdest') }
+      let(:args) { ['-e', execute, '--logdest', logdest ] }
+      let(:enc) do
+        script_containing('enc_script',
+          :windows => '@echo environment: spec',
+          :posix   => '#!/bin/sh' + "\n" + 'echo "environment: spec"')
+      end
+
+      before :each do
+        Puppet[:node_terminus] = 'exec'
+        Puppet[:external_nodes] = enc
+      end
+
+      it "should use the environment that the ENC mandates" do
+        apply = init_cli_args_and_apply_app(args, execute)
+        expect { apply.run }.to exit_with(0)
+        expect(@logs.map(&:to_s)).to include('amod class included')
+      end
 
-      expect do
+      it "should prefer the ENC environment over the configured one and emit a warning" do
+        apply = init_cli_args_and_apply_app(args + [ '--environment', 'production' ], execute)
         expect { apply.run }.to exit_with(0)
-      end.to have_printed('amod class included')
+        logs = @logs.map(&:to_s)
+        expect(logs).to include('amod class included')
+        expect(logs).to include(match(/doesn't match server specified environment/))
+      end
     end
   end
-
 end

data/spec/integration/data_binding_spec.rb

@@ -0,0 +1,195 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+
+describe "Data binding" do
+  include PuppetSpec::Files
+  include PuppetSpec::Compiler
+
+  let(:dir) { tmpdir("puppetdir") }
+  let(:data) {{
+    'global' => {
+      'testing::binding::value' => 'the value',
+      'testing::binding::calling_class' => '%{calling_class}',
+      'testing::binding::calling_class_path' => '%{calling_class_path}'
+    }
+  }}
+  let(:hash_data) {{
+    'global' => {
+      'testing::hash::options' => {
+        'key'  => 'value',
+        'port' => '80',
+        'bind' => 'localhost'
+      }
+    },
+    'agent.example.com' => {
+      'testing::hash::options' => {
+        'key'  => 'new value',
+        'port' => '443'
+      }
+    }
+  }}
+  let(:hash_data_with_lopts) {{
+    'global' => {
+      'testing::hash::options' => {
+        'key'  => 'value',
+        'port' => '80',
+        'bind' => 'localhost'
+      }
+    },
+    'agent.example.com' => {
+      'lookup_options' => {
+        'testing::hash::options' => {
+          'merge' => 'deep'
+        }
+      },
+      'testing::hash::options' => {
+        'key'  => 'new value',
+        'port' => '443'
+      }
+    }
+  }}
+
+  before do
+    # Drop all occurances of cached hiera instances. This will reset @hiera in Puppet::Indirector::Hiera, Testing::DataBinding::Hiera,
+    # and Puppet::DataBinding::Hiera. Different classes are active as indirection depending on configuration
+    ObjectSpace.each_object(Class).select {|klass| klass <= Puppet::Indirector::Hiera }.each { |klass| klass.instance_variable_set(:@hiera, nil) }
+    Puppet[:data_binding_terminus] = 'hiera'
+    Puppet[:modulepath] = dir
+  end
+
+  context "with testing::binding and global data only" do
+    it "looks up global data from hiera" do
+      configure_hiera_for_one_tier(data)
+
+      create_manifest_in_module("testing", "binding.pp",
+                                <<-MANIFEST)
+      class testing::binding($value,
+                             $calling_class,
+                             $calling_class_path,
+                             $calling_module = $module_name) {}
+      MANIFEST
+
+      catalog = compile_to_catalog("include testing::binding")
+      resource = catalog.resource('Class[testing::binding]')
+
+      expect(resource[:value]).to eq("the value")
+      expect(resource[:calling_class]).to eq("testing::binding")
+      expect(resource[:calling_class_path]).to eq("testing/binding")
+      expect(resource[:calling_module]).to eq("testing")
+    end
+  end
+
+  context "with testing::hash and global data only" do
+    it "looks up global data from hiera" do
+      configure_hiera_for_one_tier(hash_data)
+
+      create_manifest_in_module("testing", "hash.pp",
+                                <<-MANIFEST)
+      class testing::hash($options) {}
+      MANIFEST
+
+      catalog = compile_to_catalog("include testing::hash")
+      resource = catalog.resource('Class[testing::hash]')
+
+      expect(resource[:options]).to eq({
+	'key'  => 'value',
+	'port' => '80',
+	'bind' => 'localhost'
+      })
+    end
+  end
+
+  context "with custom clientcert" do
+    it "merges global data with agent.example.com data from hiera" do
+      configure_hiera_for_two_tier(hash_data)
+
+      create_manifest_in_module("testing", "hash.pp",
+                                <<-MANIFEST)
+      class testing::hash($options) {}
+      MANIFEST
+
+      catalog = compile_to_catalog("include testing::hash")
+      resource = catalog.resource('Class[testing::hash]')
+
+      expect(resource[:options]).to eq({
+            'key'  => 'new value',
+            'port' => '443',
+      })
+    end
+  end
+
+  context "with custom clientcert and with lookup_options" do
+    it "merges global data with agent.example.com data from hiera" do
+      configure_hiera_for_two_tier(hash_data_with_lopts)
+
+      create_manifest_in_module("testing", "hash.pp",
+                                <<-MANIFEST)
+      class testing::hash($options) {}
+      MANIFEST
+
+      catalog = compile_to_catalog("include testing::hash")
+      resource = catalog.resource('Class[testing::hash]')
+
+      expect(resource[:options]).to eq({
+        'key'  => 'new value',
+        'port' => '443',
+	      'bind' => 'localhost',
+      })
+    end
+  end
+
+
+  def configure_hiera_for_one_tier(data)
+    hiera_config_file = tmpfile("hiera.yaml")
+
+    File.open(hiera_config_file, 'w') do |f|
+      f.write("---
+        :yaml:
+          :datadir: #{dir}
+        :hierarchy: ['global']
+        :logger: 'noop'
+        :backends: ['yaml']
+      ")
+    end
+
+    data.each do | file, contents |
+      File.open(File.join(dir, "#{file}.yaml"), 'w') do |f|
+        f.write(YAML.dump(contents))
+      end
+    end
+
+    Puppet[:hiera_config] = hiera_config_file
+  end
+
+  def configure_hiera_for_two_tier(data)
+    hiera_config_file = tmpfile("hiera.yaml")
+
+    File.open(hiera_config_file, 'w') do |f|
+      f.write("---
+        :yaml:
+          :datadir: #{dir}
+        :hierarchy: ['agent.example.com', 'global']
+        :logger: 'noop'
+        :backends: ['yaml']
+      ")
+    end
+
+    data.each do | file, contents |
+      File.open(File.join(dir, "#{file}.yaml"), 'w') do |f|
+        f.write(YAML.dump(contents))
+      end
+    end
+
+    Puppet[:hiera_config] = hiera_config_file
+  end
+
+  def create_manifest_in_module(module_name, name, manifest)
+    module_dir = File.join(dir, module_name, 'manifests')
+    FileUtils.mkdir_p(module_dir)
+
+    File.open(File.join(module_dir, name), 'w') do |f|
+      f.write(manifest)
+    end
+  end
+end

data/spec/integration/defaults_spec.rb

@@ -116,13 +116,25 @@ describe "Puppet defaults" do
   end
 
   describe "on a Windows-like platform it", :if => Puppet.features.microsoft_windows? do
-    it "should not add anything" 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" }
+
+    it "path should not add anything" do
       path = "c:\\windows\\system32#{File::PATH_SEPARATOR}c:\\windows"
-      Puppet::Util.withenv("PATH" => path) do
+      Puppet::Util.withenv( {"PATH" => path }, :windows ) do
         Puppet.settings[:path] = "none" # this causes it to ignore the setting
         expect(ENV["PATH"]).to eq(path)
       end
     end
+
+    it "path should support UTF8 characters" do
+      path = "c:\\windows\\system32#{File::PATH_SEPARATOR}c:\\windows#{File::PATH_SEPARATOR}C:\\" + rune_utf8
+      Puppet::Util.withenv( {"PATH" => path }, :windows) do
+        Puppet.settings[:path] = "none" # this causes it to ignore the setting
+
+        envhash = Puppet::Util::Windows::Process.get_environment_strings
+        expect(envhash['Path']).to eq(path)
+      end
+    end
   end
 
   it "should default to pson for the preferred serialization format" do

data/spec/integration/faces/plugin_spec.rb

@@ -26,7 +26,6 @@ describe "Puppet plugin face" do
   end
 
   before do
-    FileUtils.mkdir(Puppet[:vardir])
     FileUtils.mkdir(File.join(Puppet[:vardir], 'lib'))
     FileUtils.mkdir(File.join(Puppet[:vardir], 'facts.d'))
     @termini_classes = {}
@@ -37,9 +36,6 @@ describe "Puppet plugin face" do
   end
 
   after do
-    FileUtils.rmdir(File.join(Puppet[:vardir],'lib'))
-    FileUtils.rmdir(File.join(Puppet[:vardir],'facts.d'))
-    FileUtils.rmdir(Puppet[:vardir])
     INDIRECTED_CLASSES.each do |indirected|
       indirected.indirection.terminus_class = @termini_classes[indirected]
       indirected.indirection.termini.clear

data/spec/integration/file_bucket/file_spec.rb

@@ -18,7 +18,7 @@ describe Puppet::FileBucket::File do
 
       {
         "md5/d41d8cd98f00b204e9800998ecf8427e" => :file,
-        "https://puppetmaster:8140/production/file_bucket_file/md5/d41d8cd98f00b204e9800998ecf8427e" => :file,
+        "filebucket://puppetmaster:8140/md5/d41d8cd98f00b204e9800998ecf8427e" => :file,
       }.each do |key, terminus|
         it "should use the #{terminus} terminus when requesting #{key.inspect}" do
           described_class.indirection.terminus(terminus).class.any_instance.expects(:find)
@@ -31,7 +31,7 @@ describe Puppet::FileBucket::File do
     describe "when running another application" do
       {
         "md5/d41d8cd98f00b204e9800998ecf8427e" => :file,
-        "https://puppetmaster:8140/production/file_bucket_file/md5/d41d8cd98f00b204e9800998ecf8427e" => :rest,
+        "filebucket://puppetmaster:8140/md5/d41d8cd98f00b204e9800998ecf8427e" => :rest,
       }.each do |key, terminus|
         it "should use the #{terminus} terminus when requesting #{key.inspect}" do
           described_class.indirection.terminus(terminus).class.any_instance.expects(:find)

data/spec/integration/file_system/uniquefile_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Puppet::FileSystem::Uniquefile do
+
+  describe "#open_tmp on Windows", :if => Puppet.features.microsoft_windows? do
+
+    describe "with UTF8 characters" do
+      include PuppetSpec::Files
+
+      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" }
+      let(:temp_rune_utf8) { tmpdir(rune_utf8) }
+
+      it "should use UTF8 characters in TMP,TEMP,TMPDIR environment variable" do
+        # Set the temporary environment variables to the UTF8 temp path
+        Puppet::Util::Windows::Process.set_environment_variable('TMPDIR', temp_rune_utf8)
+        Puppet::Util::Windows::Process.set_environment_variable('TMP', temp_rune_utf8)
+        Puppet::Util::Windows::Process.set_environment_variable('TEMP', temp_rune_utf8)
+
+        # Create a unique file
+        filename = Puppet::FileSystem::Uniquefile.open_tmp('foo') do |file|
+          File.dirname(file.path)
+        end
+
+        expect(filename).to eq(temp_rune_utf8)
+      end
+    end
+  end
+
+end

data/spec/integration/indirector/facts/facter_spec.rb

@@ -1,9 +1,11 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
+require 'puppet_spec/files'
 require 'puppet_spec/compiler'
 
 describe Puppet::Node::Facts::Facter do
+  include PuppetSpec::Files
   include PuppetSpec::Compiler
 
   it "preserves case in fact values" do
@@ -19,4 +21,99 @@ describe Puppet::Node::Facts::Facter do
                              Puppet::Node.indirection.find('foo'))
     expect(cat.resource("Notify[AaBbCc]")).to be
   end
+
+  context "resolving file based facts" do
+    let(:factdir) { tmpdir('factdir') }
+
+    it "should resolve custom facts" do
+      test_module = File.join(factdir, 'module', 'lib', 'facter')
+      FileUtils.mkdir_p(test_module)
+
+      File.open(File.join(test_module, 'custom.rb'), 'wb') { |file| file.write(<<-EOF)}
+      Facter.add(:custom) do
+        setcode do
+          Facter.value('puppetversion')
+        end
+      end
+      EOF
+
+      Puppet.initialize_settings(['--modulepath', factdir])
+      apply = Puppet::Application.find(:apply).new(stub('command_line', :subcommand_name => :apply, :args => ['--modulepath', factdir, '-e', 'notify { $custom: }']))
+
+      expect do
+        expect { apply.run }.to exit_with(0)
+      end.to have_printed(Puppet.version)
+    end
+
+    it "should resolve external facts" do
+      external_fact = File.join(factdir, 'external')
+
+      if Puppet.features.microsoft_windows?
+        external_fact += '.bat'
+        File.open(external_fact, 'wb') { |file| file.write(<<-EOF)}
+        @echo foo=bar
+        EOF
+      else
+        File.open(external_fact, 'wb') { |file| file.write(<<-EOF)}
+        #!/bin/sh
+        echo "foo=bar"
+        EOF
+
+        Puppet::FileSystem.chmod(0755, external_fact)
+      end
+
+      Puppet.initialize_settings(['--pluginfactdest', factdir])
+      apply = Puppet::Application.find(:apply).new(stub('command_line', :subcommand_name => :apply, :args => ['--pluginfactdest', factdir, '-e', 'notify { $foo: }']))
+
+      expect do
+        expect { apply.run }.to exit_with(0)
+      end.to have_printed('bar')
+    end
+  end
+
+  it "adds the puppetversion fact" do
+    Facter.stubs(:reset)
+
+    cat = compile_to_catalog('notify { $::puppetversion: }',
+                             Puppet::Node.indirection.find('foo'))
+    expect(cat.resource("Notify[#{Puppet.version.to_s}]")).to be
+  end
+
+  it "the agent_specified_environment fact is nil when not set" do
+    expect do
+      compile_to_catalog('notify { $::agent_specified_environment: }',
+                         Puppet::Node.indirection.find('foo'))
+    end.to raise_error(Puppet::PreformattedError)
+  end
+
+  it "adds the agent_specified_environment fact when set in puppet.conf" do
+    FileUtils.mkdir_p(Puppet[:confdir])
+    File.open(File.join(Puppet[:confdir], 'puppet.conf'), 'w') do |f|
+      f.puts("environment=bar")
+    end
+
+    Puppet.initialize_settings
+    cat = compile_to_catalog('notify { $::agent_specified_environment: }',
+                             Puppet::Node.indirection.find('foo'))
+    expect(cat.resource("Notify[bar]")).to be
+  end
+
+  it "adds the agent_specified_environment fact when set via command-line" do
+    Puppet.initialize_settings(['--environment', 'bar'])
+    cat = compile_to_catalog('notify { $::agent_specified_environment: }',
+                             Puppet::Node.indirection.find('foo'))
+    expect(cat.resource("Notify[bar]")).to be
+  end
+
+  it "adds the agent_specified_environment fact, preferring cli, when set in puppet.conf and via command-line" do
+    FileUtils.mkdir_p(Puppet[:confdir])
+    File.open(File.join(Puppet[:confdir], 'puppet.conf'), 'w') do |f|
+      f.puts("environment=bar")
+    end
+
+    Puppet.initialize_settings(['--environment', 'baz'])
+    cat = compile_to_catalog('notify { $::agent_specified_environment: }',
+                             Puppet::Node.indirection.find('foo'))
+    expect(cat.resource("Notify[baz]")).to be
+  end
 end

data/spec/integration/module_tool/tar/mini_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'puppet/module_tool'
+require 'puppet_spec/files'
+
+describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? && Puppet.features.zlib?) do
+  let(:minitar)    { described_class.new }
+
+  describe "Extracts tars with long and short pathnames" do
+    let (:sourcetar) { File.expand_path('../../../../fixtures/module.tar.gz', __FILE__) }
+
+    let (:longfilepath)  { "puppetlabs-dsc-1.0.0/lib/puppet_x/dsc_resources/xWebAdministration/DSCResources/MSFT_xWebAppPoolDefaults/MSFT_xWebAppPoolDefaults.schema.mof" }
+    let (:shortfilepath) { "puppetlabs-dsc-1.0.0/README.md" }
+
+    it "unpacks a tar with a short path length" do
+      extractdir = PuppetSpec::Files.tmpdir('minitar')
+
+      minitar.unpack(sourcetar,extractdir,'module')
+      expect(File).to exist(File.expand_path("#{extractdir}/#{shortfilepath}"))
+    end
+
+    it "unpacks a tar with a long path length" do
+      extractdir = PuppetSpec::Files.tmpdir('minitar')
+
+      minitar.unpack(sourcetar,extractdir,'module')
+      expect(File).to exist(File.expand_path("#{extractdir}/#{longfilepath}"))
+    end
+  end
+end

data/spec/integration/node/environment_spec.rb

@@ -119,4 +119,17 @@ describe Puppet::Node::Environment do
       # be raised if 'b' is evaluated before 'a').
       :strict_variables => true
   end
+
+  describe "#extralibs on Windows", :if => Puppet.features.microsoft_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