puppet 4.4.1 → 4.4.2

data/spec/unit/application/lookup_spec.rb

@@ -30,7 +30,7 @@ describe Puppet::Application::Lookup do
       lookup.options[:merge] = 'hash'
       lookup.command_line.stubs(:args).returns(['atton', 'kreia'])
 
-      expected_error = "The options --knock-out-prefix, --sort-merged-arrays, --unpack-arrays, and --merge-hash-arrays are only available with '--merge deep'\nRun 'puppet lookup --help' for more details"
+      expected_error = "The options --knock-out-prefix, --sort-merged-arrays, and --merge-hash-arrays are only available with '--merge deep'\nRun 'puppet lookup --help' for more details"
 
       expect { lookup.run_command }.to raise_error(RuntimeError, expected_error)
     end

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

data/spec/unit/data_providers/hiera_interpolation_spec.rb

@@ -118,6 +118,7 @@ describe 'Puppet::DataProviders::HieraInterpolate' do
           }
         },
         'x.1' => '(lookup) x dot 1',
+        'key' => 'subkey'
       }
     }
 
@@ -217,6 +218,11 @@ describe 'Puppet::DataProviders::HieraInterpolate' do
       expect_lookup('a.d')
       expect(interpolator.interpolate("a dot f: %{lookup(\"'a.d'\")}", lookup_invocation, true)).to eq('a dot f: ')
     end
+
+    it 'should not find a subkey that is matched within a string' do
+      expect_lookup('key')
+      expect{ interpolator.interpolate('%{hiera("key.subkey")}', lookup_invocation, true) }.to raise_error(/Got String when a hash-like object was expected to enable lookup using key 'subkey'/)
+    end
   end
 
   context 'when dealing with non alphanumeric characters' do

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")

data/spec/unit/functions/assert_type_spec.rb

@@ -86,4 +86,12 @@ describe 'the assert_type function' do
     CODE
     expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /expected an UnprivilegedPort = Integer\[1024, 65537\] value, got Integer\[345, 345\]/)
   end
+
+  it 'will use infer_set to report detailed information about complex mismatches' do
+    code = <<-CODE
+      assert_type(Struct[{a=>Integer,b=>Boolean}], {a=>hej,x=>s})
+    CODE
+    expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error,
+      /struct member 'a' expected an Integer value, got String.*expected a value for key 'b'.*did not have a 'x' key/m)
+  end
 end

data/spec/unit/functions/lookup_spec.rb

@@ -170,7 +170,7 @@ describe "when performing lookup" do
     it 'will not accept a succesful lookup of an undef value when the type rejects it' do
       expect do
         assemble_and_compile('${r}', "'abc::n'", 'String')
-      end.to raise_error(Puppet::ParseError, /Found value has wrong type, expected a String value, got Undef/)
+      end.to raise_error(Puppet::ParseError, /Found value had wrong type, expected a String value, got Undef/)
     end
 
     it 'will raise an exception when value is not found for array key and no default is provided' do
@@ -249,7 +249,7 @@ describe "when performing lookup" do
         expect do
           assemble_and_compile('${r[a]}_${r[b]}', "'abc::x'", 'Hash[String,String]', 'undef', "{'a' => 'dflt_x', 'b' => 32}")
         end.to raise_error(Puppet::ParseError,
-          /Default value has wrong type, expected a Hash\[String, String\] value, got Struct\[\{'a' => String, 'b' => Integer\}\]/)
+          /Default value had wrong type, expected a Hash\[String, String\] value, got Struct\[\{'a' => String, 'b' => Integer\}\]/)
       end
     end
 
@@ -283,7 +283,7 @@ describe "when performing lookup" do
         expect do
           assemble_and_compile_with_block('${r[a]}_${r[b]}', "{'a' => 'dflt_x', 'b' => 32}", "'abc::x'", 'Hash[String,String]')
         end.to raise_error(Puppet::ParseError,
-          /Value returned from default block has wrong type, expected a Hash\[String, String\] value, got Struct\[\{'a' => String, 'b' => Integer\}\]/)
+          /Value returned from default block had wrong type, expected a Hash\[String, String\] value, got Struct\[\{'a' => String, 'b' => Integer\}\]/)
       end
 
       it 'receives a single name parameter' do

data/spec/unit/indirector/catalog/compiler_spec.rb

@@ -94,6 +94,13 @@ describe Puppet::Resource::Catalog::Compiler do
       @compiler.find(@request)
     end
 
+    it "should pass node containing percent character to the compiler" do
+      node_with_percent_character = Puppet::Node.new "%6de"
+      Puppet::Node.indirection.stubs(:find).returns(node_with_percent_character)
+      Puppet::Parser::Compiler.expects(:compile).with(node_with_percent_character, anything)
+      @compiler.find(@request)
+    end
+
     it "should extract and save any facts from the request" do
       Puppet::Node.indirection.expects(:find).with(@name, anything).returns @node
       @compiler.expects(:extract_facts_from_request).with(@request)

data/spec/unit/indirector/msgpack_spec.rb

@@ -76,12 +76,22 @@ describe Puppet::Indirector::Msgpack, :if => Puppet.features.msgpack? do
         expect(subject.find(request)).to be_nil
       end
 
+      it "can load a UTF-8 file from disk" do
+        rune_utf8 = "\u16A0\u16C7\u16BB" # ᚠᛇᚻ
+
+        with_content(model.new(rune_utf8).to_msgpack) do
+          instance = subject.find(request)
+          expect(instance).to be_an_instance_of model
+          expect(instance.value).to eq(rune_utf8)
+        end
+      end
+
       it "raises a descriptive error when the file can't be read" do
         with_content(model.new('foo').to_msgpack) do
           # I don't like this, but there isn't a credible alternative that
           # also works on Windows, so a stub it is. At least the expectation
           # will fail if the implementation changes. Sorry to the next dev.
-          File.expects(:read).with(file).raises(Errno::EPERM)
+          Puppet::FileSystem.expects(:read).with(file, {:encoding => 'utf-8'}).raises(Errno::EPERM)
           expect { subject.find(request) }.
             to raise_error Puppet::Error, /Could not read MessagePack/
         end