puppet 4.9.4-x64-mingw32 → 4.10.0-x64-mingw32

data/spec/unit/functions4_spec.rb

@@ -237,6 +237,22 @@ describe 'the 4x function api' do
     rejected: parameter 's1' expects a String value, got Integer")
     end
 
+    context 'an argument_mismatch handler' do
+      let(:func) { create_function_with_mismatch_handler.new(:closure_scope, :loader) }
+
+      it 'is called on matching arguments' do
+        expect { func.call({}, '1') }.to raise_error(ArgumentError, "'test' It's not OK to pass a string")
+      end
+
+      it 'is not called unless arguments are matching' do
+        expect { func.call({}, '1', 3) }.to raise_error(ArgumentError, "'test' expects 1 argument, got 2")
+      end
+
+      it 'is not included in a signature mismatch description' do
+        expect { func.call({}, 2.3) }.to raise_error { |e| expect(e.message).not_to match(/String/) }
+      end
+    end
+
     context 'can use injection' do
       before :all do
         injector = Puppet::Pops::Binder::Injector.create('test') do
@@ -474,7 +490,7 @@ describe 'the 4x function api' do
         # evaluate a puppet call
         source = "testing::test(10) |$x| { $x+1 }"
         program = parser.parse_string(source, __FILE__)
-        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns(the_loader)
         expect(parser.evaluate(scope, program)).to eql(11)
       end
     end
@@ -962,6 +978,26 @@ describe 'the 4x function api' do
     end
   end
 
+  def create_function_with_mismatch_handler
+    f = Puppet::Functions.create_function('test') do
+      dispatch :test do
+        param 'Integer', :x
+      end
+
+      argument_mismatch :on_error do
+        param 'String', :x
+      end
+
+      def test(x)
+        yield(5,x) if block_given?
+      end
+
+      def on_error(x)
+        "It's not OK to pass a string"
+      end
+    end
+  end
+
   def type_alias_t(name, type_string)
     type_expr = Puppet::Pops::Parser::EvaluatingParser.new.parse_string(type_string).current
     Puppet::Pops::Types::TypeFactory.type_alias(name, type_expr)

data/spec/unit/indirector/file_bucket_file/file_spec.rb

@@ -52,11 +52,42 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
                               0x2f94cc40,0x15a12deb,0xdc15f4a3,0x490786bb,
                               0x6d658673,0xa4341f7d,0x8fd75920,0xefd18d5a].pack("I" * 16)
 
-        save_bucket_file(first_contents, "/foo/bar")
+        checksum_value = save_bucket_file(first_contents, "/foo/bar")
 
+        # We expect Puppet to log an error with the path to the file
+        Puppet.expects(:err).with(regexp_matches(/Unable to verify existing FileBucket backup at '#{Puppet[:bucketdir]}.*#{checksum_value}\/contents'/))
+
+        # But the exception should not contain it
         expect do
           save_bucket_file(collision_contents, "/foo/bar")
-        end.to raise_error(Puppet::FileBucket::BucketError, /Got passed new contents/)
+        end.to raise_error(Puppet::FileBucket::BucketError, /\AExisting backup and new file have different content but same checksum, {md5}#{checksum_value}\. Verify existing backup and remove if incorrect\.\Z/)
+      end
+
+      # See PUP-1334
+      context "when the contents file exists but is corrupted and does not match the expected checksum" do
+        let(:original_contents) { "a file that will get corrupted" }
+        let(:bucket_file) { Puppet::FileBucket::File.new(original_contents) }
+        let(:contents_file) { "#{Puppet[:bucketdir]}/8/e/6/4/f/8/5/d/8e64f85dd54a412f65edabcafe44d491/contents" }
+
+        before(:each) do
+          # Ensure we're starting with a clean slate - no pre-existing backup
+          Puppet::FileSystem.unlink(contents_file) if Puppet::FileSystem.exist?(contents_file)
+          # Create initial "correct" backup
+          Puppet::FileBucket::File.indirection.save(bucket_file)
+          # Modify the contents file so that it no longer matches the SHA, simulating a corrupt backup
+          Puppet::FileSystem.unlink(contents_file) # bucket_files are read-only
+          Puppet::Util.replace_file(contents_file, 0600) { |fh| fh.puts "now with corrupted content" }
+        end
+
+        it "issues a warning that the backup will be overwritten" do
+          Puppet.expects(:warning).with(regexp_matches(/Existing backup does not match its expected sum, #{bucket_file.checksum}/))
+          Puppet::FileBucket::File.indirection.save(bucket_file)
+        end
+
+        it "overwrites the existing contents file (backup)" do
+          Puppet::FileBucket::File.indirection.save(bucket_file)
+          expect(Puppet::FileSystem.read(contents_file)).to eq(original_contents)
+        end
       end
 
       describe "when supplying a path" do

data/spec/unit/indirector/key/file_spec.rb

@@ -66,7 +66,7 @@ describe Puppet::SSL::Key::File do
     it "should save the public key when saving the private key" do
       fh = StringIO.new
 
-      Puppet.settings.setting(:publickeydir).expects(:open_file).with(@public_key_path, 'w').yields fh
+      Puppet.settings.setting(:publickeydir).expects(:open_file).with(@public_key_path, 'w:ASCII').yields fh
       Puppet.settings.setting(:privatekeydir).stubs(:open_file)
       @public_key.expects(:to_pem).returns "my pem"
 

data/spec/unit/indirector/ssl_file_spec.rb

@@ -221,7 +221,7 @@ describe Puppet::Indirector::SslFile do
           @searcher.class.store_in @setting
           fh = mock 'filehandle'
           fh.stubs :print
-          Puppet.settings.setting(@setting).expects(:open_file).with(@certpath, 'w').yields fh
+          Puppet.settings.setting(@setting).expects(:open_file).with(@certpath, 'w:ASCII').yields fh
 
           @searcher.save(@request)
         end
@@ -233,7 +233,7 @@ describe Puppet::Indirector::SslFile do
 
           fh = mock 'filehandle'
           fh.stubs :print
-          Puppet.settings.setting(@setting).expects(:open).with('w').yields fh
+          Puppet.settings.setting(@setting).expects(:open).with('w:ASCII').yields fh
           @searcher.save(@request)
         end
       end
@@ -246,7 +246,7 @@ describe Puppet::Indirector::SslFile do
 
           fh = mock 'filehandle'
           fh.stubs :print
-          Puppet.settings.setting(:cakey).expects(:open).with('w').yields fh
+          Puppet.settings.setting(:cakey).expects(:open).with('w:ASCII').yields fh
           @searcher.stubs(:ca?).returns true
           @searcher.save(@request)
         end

data/spec/unit/module_spec.rb

@@ -170,7 +170,6 @@ describe Puppet::Module do
 
     it "should list modules that are missing" do
       metadata_file = "#{@modpath}/needy/metadata.json"
-      Puppet::FileSystem.expects(:exist?).with(metadata_file).returns true
       mod = PuppetSpec::Modules.create(
         'needy',
         @modpath,
@@ -196,7 +195,6 @@ describe Puppet::Module do
 
     it "should list modules that are missing and have invalid names" do
       metadata_file = "#{@modpath}/needy/metadata.json"
-      Puppet::FileSystem.expects(:exist?).with(metadata_file).returns true
       mod = PuppetSpec::Modules.create(
         'needy',
         @modpath,
@@ -305,7 +303,6 @@ describe Puppet::Module do
       env = Puppet::Node::Environment.create(:testing, [@modpath])
 
       metadata_file = "#{@modpath}/foobar/metadata.json"
-      Puppet::FileSystem.expects(:exist?).with(metadata_file).times(3).returns true
       mod = PuppetSpec::Modules.create(
         'foobar',
         @modpath,
@@ -364,10 +361,6 @@ describe Puppet::Module do
     it "should only list unmet dependencies" do
       env = Puppet::Node::Environment.create(:testing, [@modpath])
 
-      [name, 'satisfied'].each do |mod_name|
-        metadata_file = "#{@modpath}/#{mod_name}/metadata.json"
-        Puppet::FileSystem.expects(:exist?).with(metadata_file).twice.returns true
-      end
       mod = PuppetSpec::Modules.create(
         name,
         @modpath,
@@ -588,60 +581,70 @@ end
 
 describe Puppet::Module do
   include PuppetSpec::Files
-  before do
-    @modpath = tmpdir('modpath')
-    @module = PuppetSpec::Modules.create('mymod', @modpath)
+
+  let!(:modpath) do
+    path = tmpdir('modpath')
+    PuppetSpec::Modules.create('mymod', path)
+    path
   end
 
+  let!(:mymodpath) { File.join(modpath, 'mymod') }
+
+  let!(:mymod_metadata) { File.join(mymodpath, 'metadata.json') }
+
+  let(:mymod) { Puppet::Module.new('mymod', mymodpath, nil) }
+
   it "should use 'License' in its current path as its metadata file" do
-    expect(@module.license_file).to eq("#{@modpath}/mymod/License")
+    expect(mymod.license_file).to eq("#{modpath}/mymod/License")
   end
 
   it "should cache the license file" do
-    @module.expects(:path).once.returns nil
-    @module.license_file
-    @module.license_file
+    mymod.expects(:path).once.returns nil
+    mymod.license_file
+    mymod.license_file
   end
 
   it "should use 'metadata.json' in its current path as its metadata file" do
-    expect(@module.metadata_file).to eq("#{@modpath}/mymod/metadata.json")
+    expect(mymod_metadata).to eq("#{modpath}/mymod/metadata.json")
+  end
+
+  it "should not have metadata if it has a metadata file and its data is valid but empty json hash" do
+    File.stubs(:read).with(mymod_metadata, {:encoding => 'utf-8'}).returns "{}"
+
+    expect(mymod).not_to be_has_metadata
   end
 
-  it "should have metadata if it has a metadata file and its data is not empty" do
-    Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
-    File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns "{\"foo\" : \"bar\"}"
+  it "should not have metadata if it has a metadata file and its data is empty" do
+    File.stubs(:read).with(mymod_metadata, {:encoding => 'utf-8'}).returns ""
 
-    expect(@module).to be_has_metadata
+    expect(mymod).not_to be_has_metadata
   end
 
-  it "should not have metadata if has a metadata file and its data is empty" do
-    Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
-    File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns "This is some invalid json.\n"
-    expect(@module).not_to be_has_metadata
+  it "should not have metadata if has a metadata file and its data is invalid" do
+    File.stubs(:read).with(mymod_metadata, {:encoding => 'utf-8'}).returns "This is some invalid json.\n"
+    expect(mymod).not_to be_has_metadata
   end
 
   it "should know if it is missing a metadata file" do
-    Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns false
+    File.stubs(:read).with(mymod_metadata, {:encoding => 'utf-8'}).raises(Errno::ENOENT)
 
-    expect(@module).not_to be_has_metadata
+    expect(mymod).not_to be_has_metadata
   end
 
   it "should be able to parse its metadata file" do
-    expect(@module).to respond_to(:load_metadata)
+    expect(mymod).to respond_to(:load_metadata)
   end
 
   it "should parse its metadata file on initialization if it is present" do
-    Puppet::Module.any_instance.expects(:has_metadata?).returns true
     Puppet::Module.any_instance.expects(:load_metadata)
 
     Puppet::Module.new("yay", "/path", mock("env"))
   end
 
   it "should tolerate failure to parse" do
-    Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
-    File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
+    File.stubs(:read).with(mymod_metadata, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
 
-    expect(@module.has_metadata?).to be_falsey
+    expect(mymod.has_metadata?).to be_falsey
   end
 
   describe 'when --strict is warning' do
@@ -650,10 +653,9 @@ describe Puppet::Module do
     end
 
     it "should warn about a failure to parse" do
-      Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
-      File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
+      File.stubs(:read).with(mymod_metadata, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
 
-      expect(@module.has_metadata?).to be_falsey
+      expect(mymod.has_metadata?).to be_falsey
       expect(@logs).to have_matching_log(/mymod has an invalid and unparsable metadata\.json file/)
     end
   end
@@ -664,10 +666,9 @@ describe Puppet::Module do
       end
 
       it "should warn about a failure to parse" do
-        Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
-        File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
+        File.stubs(:read).with(mymod_metadata, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
 
-        expect(@module.has_metadata?).to be_falsey
+        expect(mymod.has_metadata?).to be_falsey
         expect(@logs).to have_matching_log(/mymod has an invalid and unparsable metadata\.json file.*/)
       end
     end
@@ -678,47 +679,39 @@ describe Puppet::Module do
       end
 
       it "should fail on a failure to parse" do
-        Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
-        File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
+        File.stubs(:read).with(mymod_metadata, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
 
         expect do
-        expect(@module.has_metadata?).to be_falsey
+        expect(mymod.has_metadata?).to be_falsey
         end.to raise_error(/mymod has an invalid and unparsable metadata\.json file/)
       end
     end
 
   def a_module_with_metadata(data)
-    text = data.to_pson
-
-    mod = Puppet::Module.new("foo", "/path", mock("env"))
-    mod.stubs(:metadata_file).returns "/my/file"
-    File.stubs(:read).with("/my/file", {:encoding => 'utf-8'}).returns text
-    mod
+    File.stubs(:read).with("/path/metadata.json", {:encoding => 'utf-8'}).returns data.to_pson
+    Puppet::Module.new("foo", "/path", mock("env"))
   end
 
   describe "when loading the metadata file" do
-    before do
-      @data = {
+    let(:data) do
+      {
         :license       => "GPL2",
         :author        => "luke",
         :version       => "1.0",
         :source        => "http://foo/",
         :dependencies  => []
       }
-      @module = a_module_with_metadata(@data)
     end
 
     %w{source author version license}.each do |attr|
       it "should set #{attr} if present in the metadata file" do
-        @module.load_metadata
-        expect(@module.send(attr)).to eq(@data[attr.to_sym])
+        mod = a_module_with_metadata(data)
+        expect(mod.send(attr)).to eq(data[attr.to_sym])
       end
 
       it "should fail if #{attr} is not present in the metadata file" do
-        @data.delete(attr.to_sym)
-        @text = @data.to_pson
-        File.stubs(:read).with("/my/file", {:encoding => 'utf-8'}).returns @text
-        expect { @module.load_metadata }.to raise_error(
+        data.delete(attr.to_sym)
+        expect { a_module_with_metadata(data) }.to raise_error(
           Puppet::Module::MissingMetadata,
           "No #{attr} module metadata provided for foo"
         )
@@ -742,8 +735,8 @@ describe Puppet::Module do
         EOF
       end
 
+      Puppet::Module.any_instance.stubs(:metadata_file).returns metadata_json
       mod = Puppet::Module.new('foo', '/path', mock('env'))
-      mod.stubs(:metadata_file).returns metadata_json
 
       mod.load_metadata
       expect(mod.author).to eq(rune_utf8)
@@ -773,17 +766,17 @@ describe Puppet::Module do
   end
 
   it "should know what other modules require it" do
-    env = Puppet::Node::Environment.create(:testing, [@modpath])
+    env = Puppet::Node::Environment.create(:testing, [modpath])
 
     dependable = PuppetSpec::Modules.create(
       'dependable',
-      @modpath,
+      modpath,
       :metadata => {:author => 'puppetlabs'},
       :environment => env
     )
     PuppetSpec::Modules.create(
       'needy',
-      @modpath,
+      modpath,
       :metadata => {
         :author => 'beggar',
         :dependencies => [{
@@ -795,7 +788,7 @@ describe Puppet::Module do
     )
     PuppetSpec::Modules.create(
       'wantit',
-      @modpath,
+      modpath,
       :metadata => {
         :author => 'spoiled',
         :dependencies => [{

data/spec/unit/network/http/compression_spec.rb

@@ -86,17 +86,48 @@ describe "http compression" do
         expect(@uncompressor.uncompress_body(@response)).to eq("uncompresseddata")
       end
 
-      it "should use a GzipReader with 'gzip' content-encoding" do
-        @response.stubs(:[]).with('content-encoding').returns('gzip')
+      context "with 'gzip' content-encoding" do
+        it "should use a GzipReader" do
+          @response.stubs(:[]).with('content-encoding').returns('gzip')
 
-        io = stub 'io'
-        StringIO.expects(:new).with("mydata").returns io
+          io = stub 'io'
+          StringIO.expects(:new).with("mydata").returns io
 
-        reader = stub 'gzip reader'
-        Zlib::GzipReader.expects(:new).with(io).returns(reader)
-        reader.expects(:read).returns "uncompresseddata"
+          reader = stub 'gzip reader'
+          Zlib::GzipReader.expects(:new).with(io, :encoding => Encoding::BINARY).returns(reader)
+          reader.expects(:read).returns "uncompresseddata"
 
-        expect(@uncompressor.uncompress_body(@response)).to eq("uncompresseddata")
+          expect(@uncompressor.uncompress_body(@response)).to eq("uncompresseddata")
+        end
+
+        it "should correctly decompress PSON containing UTF-8 in Binary Encoding" do
+          # Simulate a compressed response body containing PSON containing UTF-8
+          # using different UTF-8 widths:
+
+          # \u06ff - ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
+          # \u16A0 - ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
+          # \u{2070E} - 𠜎 - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
+
+          pson = "foo\u06ff\u16A0\u{2070E}".to_pson # unicode expression eqivalent of "foo\xDB\xBF\xE1\x9A\xA0\xF0\xA0\x9C\x8E\" per above
+          writer = Zlib::GzipWriter.new(StringIO.new)
+          writer.write(pson)
+          compressed_body = writer.close.string
+
+          begin
+            default_external = Encoding.default_external
+            Encoding.default_external = Encoding::ISO_8859_1
+
+            @response.stubs(:[]).with('content-encoding').returns('gzip')
+            @response.stubs(:body).returns(compressed_body)
+
+            uncompressed = @uncompressor.uncompress_body(@response)
+            # By default Zlib::GzipReader decompresses into Encoding.default_external, and we want to ensure our result is BINARY too
+            expect(uncompressed.encoding).to eq(Encoding::BINARY)
+            expect(uncompressed).to eq("\"foo\xDB\xBF\xE1\x9A\xA0\xF0\xA0\x9C\x8E\"".force_encoding(Encoding::BINARY))
+          ensure
+            Encoding.default_external = default_external
+          end
+        end
       end
     end
 

data/spec/unit/parser/compiler_spec.rb

@@ -109,6 +109,20 @@ describe Puppet::Parser::Compiler do
 
   describe "when initializing" do
 
+    it 'should not create the settings class more than once' do
+      logs = []
+      Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+        Puppet[:code] = 'undef'
+        @compiler.compile
+
+        @compiler = Puppet::Parser::Compiler.new(@node)
+        Puppet[:code] = 'undef'
+        @compiler.compile
+      end
+      warnings = logs.select { |log| log.level == :warning }.map { |log| log.message }
+      expect(warnings).not_to include(/Class 'settings' is already defined/)
+    end
+
     it "should set its node attribute" do
       expect(@compiler.node).to equal(@node)
     end