puppet 4.10.4-x64-mingw32 → 4.10.5-x64-mingw32

data/spec/integration/util/execution_spec.rb

@@ -15,6 +15,14 @@ describe Puppet::Util::Execution do
       Puppet::Util::Execution.execpipe('echo $LC_ALL'){ |line| out << line.read.chomp }
       expect(out).to eq("C")
     end
+
+    it "should raise an ExecutionFailure with a missing command and :failonfail set to true" do
+      expect {
+        failonfail = true
+        # NOTE: critical to return l in the block for `output` in method to be #<IO:(closed)>
+        Puppet::Util::Execution.execpipe('conan_the_librarion', failonfail) { |l| l }
+      }.to raise_error(Puppet::ExecutionFailure)
+    end
   end
 
   describe "#execute (non-Windows)", :if => !Puppet.features.microsoft_windows? do

data/spec/unit/application/lookup_spec.rb

@@ -59,7 +59,7 @@ describe Puppet::Application::Lookup do
       lookup.command_line.stubs(:args).returns(['atton', 'kreia'])
       lookup.stubs(:generate_scope).yields('scope')
 
-      expected_merge = { "strategy" => "deep", "sort_merge_arrays" => false, "merge_hash_arrays" => true }
+      expected_merge = { "strategy" => "deep", "sort_merged_arrays" => false, "merge_hash_arrays" => true }
 
       (Puppet::Pops::Lookup).expects(:lookup).with(['atton', 'kreia'], nil, nil, false, expected_merge, anything).returns('rand')
 

data/spec/unit/configurer/fact_handler_spec.rb

@@ -72,25 +72,47 @@ describe Puppet::Configurer::FactHandler do
   it "should serialize and CGI escape the fact values for uploading" do
     facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
     Puppet::Node::Facts.indirection.save(facts)
-    text = CGI.escape(facthandler.find_facts.render(:pson))
+    text = Puppet::Util.uri_query_encode(facthandler.find_facts.render(:pson))
 
     expect(facthandler.facts_for_uploading).to eq({:facts_format => :pson, :facts => text})
   end
 
-  it "should properly accept facts containing a '+'" do
-    fact_hash = { 'afact' => 'a+b' }
-    facts = Puppet::Node::Facts.new(Puppet[:node_name_value], fact_hash)
-    Puppet::Node::Facts.indirection.save(facts)
-    text = CGI.escape(facthandler.find_facts.render(:pson))
+  [
+    { :hash => { 'afact' => 'a+b' }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'a%2Bb' + '%22%7D' },
+    { :hash => { 'afact' => 'a b' }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'a%20b' + '%22%7D' },
+    { :hash => { 'afact' => 'a&b' }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'a%26b' + '%22%7D' },
+    { :hash => { 'afact' => 'a*b' }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'a%2Ab' + '%22%7D' },
+    { :hash => { 'afact' => 'a=b' }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'a%3Db' + '%22%7D' },
+    # different UTF-8 widths
+    # 1-byte A
+    # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
+    # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
+    # 4-byte 𠜎 - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
+    { :hash => { 'afact' => "A\u06FF\u16A0\u{2070E}" }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'A%DB%BF%E1%9A%A0%F0%A0%9C%8E' + '%22%7D' },
+
+  ].each do |test_fact|
+    it "should properly accept the fact #{test_fact[:hash]}" do
+      facts = Puppet::Node::Facts.new(Puppet[:node_name_value], test_fact[:hash])
+      Puppet::Node::Facts.indirection.save(facts)
+      text = Puppet::Util.uri_query_encode(facthandler.find_facts.render(:pson))
 
-    expect(facthandler.facts_for_uploading).to eq({:facts_format => :pson, :facts => text})
+      to_upload = facthandler.facts_for_uploading
+      expect(to_upload).to eq({:facts_format => :pson, :facts => text})
+      expect(text).to include(test_fact[:encoded])
+
+      # this is not sufficient to test whether these values are sent via HTTP GET or HTTP POST in actual catalog request
+      expect(JSON.parse(URI.unescape(to_upload[:facts]))['values']).to eq(test_fact[:hash])
+    end
   end
 
   it "should generate valid facts data against the facts schema" do
     facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
     Puppet::Node::Facts.indirection.save(facts)
 
-    expect(CGI.unescape(facthandler.facts_for_uploading[:facts])).to validate_against('api/schemas/facts.json')
+    # prefer URI.unescape but validate CGI also works
+    encoded_facts = facthandler.facts_for_uploading[:facts]
+    expect(URI.unescape(encoded_facts)).to validate_against('api/schemas/facts.json')
+    expect(CGI.unescape(encoded_facts)).to validate_against('api/schemas/facts.json')
   end
 
 end

data/spec/unit/face/epp_face_spec.rb

@@ -237,6 +237,15 @@ describe Puppet::Face[:epp, :current] do
       expect(eppface.render({ :e => 'trusted is hash: <%= $trusted =~ Hash %>' })).to eql("trusted is hash: true")
     end
 
+    it 'initializes the 4x loader' do
+      expect(eppface.render({ :e => <<-EPP.unindent })).to eql("\nString\n\nInteger\n\nBoolean\n")
+        <% $data = [type('a',generalized), type(2,generalized), type(true)] -%>
+        <% $data.each |$value| { %>
+        <%= $value %>
+        <% } -%>
+      EPP
+    end
+
     it "facts can be added to" do
       expect(eppface.render({
         :facts => {'the_crux' => 'biscuit'},

data/spec/unit/file_serving/metadata_spec.rb

@@ -107,6 +107,27 @@ describe Puppet::FileServing::Metadata do
         expect(metadata.content_uri).to eq(uri)
       end
 
+      it "should accept UTF-8 characters" do
+        # different UTF-8 widths
+        # 1-byte A
+        # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
+        # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
+        # 4-byte <U+070E> - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
+        mixed_utf8 = "A\u06FF\u16A0\u{2070E}" # Aۿᚠ<U+070E>
+
+        uri = "puppet:///modules/foo/files/ #{mixed_utf8}"
+        metadata.content_uri = uri
+        expect(metadata.content_uri).to eq(uri)
+        expect(metadata.content_uri.encoding).to eq(Encoding::UTF_8)
+      end
+
+      it "should always set it as UTF-8" do
+        uri = "puppet:///modules/foo/files/".encode(Encoding::ASCII)
+        metadata.content_uri = uri
+        expect(metadata.content_uri).to eq(uri)
+        expect(metadata.content_uri.encoding).to eq(Encoding::UTF_8)
+      end
+
       it "should fail if uri is opaque" do
         expect { metadata.content_uri = 'scheme:www.example.com' }.to raise_error ArgumentError, "Cannot use opaque URLs 'scheme:www.example.com'"
       end

data/spec/unit/forge/forge_spec.rb

@@ -0,0 +1,112 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'net/http'
+require 'puppet/forge/repository'
+
+describe Puppet::Forge do
+  before(:all) do
+    # any local http proxy will break these tests
+    ENV['http_proxy'] = nil
+    ENV['HTTP_PROXY'] = nil
+  end
+
+  let(:host) { 'fake.com' }
+  let(:forge) { Puppet::Forge.new("http://#{host}") }
+  # creates a repository like Puppet::Forge::Repository.new('http://fake.com', USER_AGENT)
+
+  # different UTF-8 widths
+  # 1-byte A
+  # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
+  # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
+  # 4-byte ܎ - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
+  let (:mixed_utf8_query_param) { "foo + A\u06FF\u16A0\u{2070E}" } # Aۿᚠ
+  let (:mixed_utf8_query_param_encoded) { "foo%20%2B%20A%DB%BF%E1%9A%A0%F0%A0%9C%8E"}
+  let (:empty_json) { '{ "results": [], "pagination" : { "next" : null } }' }
+  let (:ok_response) { stub('response', :code => '200', :body => empty_json) }
+
+  describe "making a" do
+    before :each do
+      proxy_settings_of("proxy", 1234)
+    end
+
+    context "search request" do
+
+      it "includes any defined module_groups, ensuring to only encode them once in the URI" do
+        Puppet[:module_groups] = 'base+pe'
+
+        # ignores Puppet::Forge::Repository#read_response, provides response to search
+        performs_an_http_request(ok_response) do |http|
+          encoded_uri = "/v3/modules?query=#{mixed_utf8_query_param_encoded}&module_groups=base%20pe"
+          http.expects(:request).with(responds_with(:path, encoded_uri))
+        end
+
+        forge.search(mixed_utf8_query_param)
+      end
+
+      it "single encodes the search term in the URI" do
+        # ignores Puppet::Forge::Repository#read_response, provides response to search
+        performs_an_http_request(ok_response) do |http|
+          encoded_uri = "/v3/modules?query=#{mixed_utf8_query_param_encoded}"
+          http.expects(:request).with(responds_with(:path, encoded_uri))
+        end
+
+        forge.search(mixed_utf8_query_param)
+      end
+    end
+
+    context "fetch request" do
+
+      it "includes any defined module_groups, ensuring to only encode them once in the URI" do
+        Puppet[:module_groups] = 'base+pe'
+        module_name = 'puppetlabs-acl'
+
+        # ignores Puppet::Forge::Repository#read_response, provides response to fetch
+        performs_an_http_request(ok_response) do |http|
+          encoded_uri = "/v3/releases?module=#{module_name}&module_groups=base%20pe"
+          http.expects(:request).with(responds_with(:path, encoded_uri))
+        end
+
+        forge.fetch(module_name)
+      end
+
+      it "single encodes the module name term in the URI" do
+        module_name = "puppetlabs-#{mixed_utf8_query_param}"
+
+        # ignores Puppet::Forge::Repository#read_response, provides response to fetch
+        performs_an_http_request(ok_response) do |http|
+          encoded_uri = "/v3/releases?module=puppetlabs-#{mixed_utf8_query_param_encoded}"
+          http.expects(:request).with(responds_with(:path, encoded_uri))
+        end
+
+        forge.fetch(module_name)
+      end
+    end
+
+    def performs_an_http_request(result = nil, &block)
+      proxy_args = ["proxy", 1234, nil, nil]
+      mock_proxy(80, proxy_args, result, &block)
+    end
+  end
+
+  def proxy_settings_of(host, port)
+    Puppet[:http_proxy_host] = host
+    Puppet[:http_proxy_port] = port
+  end
+
+  def mock_proxy(port, proxy_args, result, &block)
+    http = mock("http client")
+    proxy = mock("http proxy")
+    proxy_class = mock("http proxy class")
+
+    Net::HTTP.expects(:Proxy).with(*proxy_args).returns(proxy_class)
+    proxy_class.expects(:new).with(host, port).returns(proxy)
+
+    proxy.expects(:open_timeout=)
+    proxy.expects(:read_timeout=)
+
+    proxy.expects(:start).yields(http).returns(result)
+    yield http
+
+    proxy
+  end
+end

data/spec/unit/forge/repository_spec.rb

@@ -121,10 +121,10 @@ describe Puppet::Forge::Repository do
       expect(request['Authorization']).to eq(token)
     end
 
-    it "escapes the received URI" do
+    it "encodes the received URI" do
       unescaped_uri = "héllo world !! ç à"
       performs_an_http_request do |http|
-        http.expects(:request).with(responds_with(:path, URI.escape(unescaped_uri)))
+        http.expects(:request).with(responds_with(:path, Puppet::Util.uri_encode(unescaped_uri)))
       end
 
       repository.make_http_request(unescaped_uri)
@@ -197,10 +197,10 @@ describe Puppet::Forge::Repository do
       expect(request['User-Agent']).to match(/\bRuby\b/)
     end
 
-    it "escapes the received URI" do
+    it "encodes the received URI" do
       unescaped_uri = "héllo world !! ç à"
       performs_an_authenticated_http_request do |http|
-        http.expects(:request).with(responds_with(:path, URI.escape(unescaped_uri)))
+        http.expects(:request).with(responds_with(:path, Puppet::Util.uri_encode(unescaped_uri)))
       end
 
       repository.make_http_request(unescaped_uri)

data/spec/unit/functions/lookup_spec.rb

@@ -933,6 +933,8 @@ describe "The lookup function" do
                 bab: bab (from environment)
               bc:
                 bca: bca (from environment)
+            sa:
+              sa1: ['e', 'd', '--f']
             YAML
           'second.yaml' => <<-YAML.unindent,
             a:
@@ -946,6 +948,8 @@ describe "The lookup function" do
             c:
               ca:
                 cab: c.ca.cab
+            sa:
+              sa1: ['b', 'a', 'f', 'c']
             YAML
         }
       end
@@ -1026,6 +1030,28 @@ describe "The lookup function" do
           expect(lookup('a')).to eql({'aa' => { 'aaa' => 'a.aa.aaa', 'aab' => 'a.aa.aab' }})
         end
       end
+
+      context 'and lookup options use a hash' do
+
+        let(:env_lookup_options) { <<-YAML.unindent }
+          lookup_options:
+            'sa':
+              merge:
+                strategy: deep
+                knockout_prefix: --
+                sort_merged_arrays: true
+        YAML
+
+        it 'applies knockout_prefix and sort_merged_arrays' do
+          expect(lookup('sa')).to eql({ 'sa1' => %w(a b c d e) })
+        end
+
+        it 'overrides knockout_prefix and sort_merged_arrays with explicitly given values' do
+          expect(
+            lookup('sa', 'merge' => { 'strategy' => 'deep', 'knockout_prefix' => '##', 'sort_merged_arrays' => false })).to(
+              eql({ 'sa1' => %w(b a f c e d --f) }))
+        end
+      end
     end
 
     context 'and an environment Hiera v5 configuration using globs' do

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

@@ -258,7 +258,7 @@ describe Puppet::Resource::Catalog::Compiler do
     def a_request_that_contains(facts, format = :pson)
       request = Puppet::Indirector::Request.new(:catalog, :find, "hostname", nil)
       request.options[:facts_format] = format.to_s
-      request.options[:facts] = CGI.escape(facts.render(format))
+      request.options[:facts] = Puppet::Util.uri_encode(facts.render(format))
       request
     end
 

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

@@ -41,16 +41,16 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
       end
 
       it "fails if the contents collide with existing contents" do
-        # This is the shortest known MD5 collision. See https://eprint.iacr.org/2010/643.pdf
+        # This is the shortest known MD5 collision (little endian). See https://eprint.iacr.org/2010/643.pdf
         first_contents = [0x6165300e,0x87a79a55,0xf7c60bd0,0x34febd0b,
                           0x6503cf04,0x854f709e,0xfb0fc034,0x874c9c65,
                           0x2f94cc40,0x15a12deb,0x5c15f4a3,0x490786bb,
-                          0x6d658673,0xa4341f7d,0x8fd75920,0xefd18d5a].pack("I" * 16)
+                          0x6d658673,0xa4341f7d,0x8fd75920,0xefd18d5a].pack("V" * 16)
 
         collision_contents = [0x6165300e,0x87a79a55,0xf7c60bd0,0x34febd0b,
                               0x6503cf04,0x854f749e,0xfb0fc034,0x874c9c65,
                               0x2f94cc40,0x15a12deb,0xdc15f4a3,0x490786bb,
-                              0x6d658673,0xa4341f7d,0x8fd75920,0xefd18d5a].pack("I" * 16)
+                              0x6d658673,0xa4341f7d,0x8fd75920,0xefd18d5a].pack("V" * 16)
 
         checksum_value = save_bucket_file(first_contents, "/foo/bar")
 

data/spec/unit/indirector/request_spec.rb

@@ -149,6 +149,21 @@ describe Puppet::Indirector::Request do
         expect(request.key.encoding).to eq(Encoding::UTF_8)
       end
 
+      it "should set the request key properly given a UTF-8 URI" do
+        # different UTF-8 widths
+        # 1-byte A
+        # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
+        # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
+        # 4-byte <U+070E> - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
+        mixed_utf8 = "A\u06FF\u16A0\u{2070E}" # Aۿᚠ<U+070E>
+
+        key = "a/path/stu ff/#{mixed_utf8}"
+        req = Puppet::Indirector::Request.new(:ind, :method, "http:///#{key}", nil)
+        expect(req.key).to eq(key)
+        expect(req.key.encoding).to eq(Encoding::UTF_8)
+        expect(req.uri).to eq("http:///#{key}")
+      end
+
       it "should set the :uri attribute to the full URI" do
         expect(Puppet::Indirector::Request.new(:ind, :method, "http:///a/path/stu ff", nil).uri).to eq('http:///a/path/stu ff')
       end
@@ -231,7 +246,7 @@ describe Puppet::Indirector::Request do
   end
 
   it "should be able to return the URI-escaped key" do
-    expect(Puppet::Indirector::Request.new(:myind, :find, "my key", nil).escaped_key).to eq(URI.escape("my key"))
+    expect(Puppet::Indirector::Request.new(:myind, :find, "my key", nil).escaped_key).to eq(Puppet::Util.uri_encode("my key"))
   end
 
   it "should set its environment to an environment instance when a string is specified as its environment" do

data/spec/unit/module_spec.rb

@@ -440,6 +440,35 @@ describe Puppet::Module do
     end
   end
 
+
+  describe "initialize_i18n" do
+
+    let(:modpath) { tmpdir('modpath') }
+    let(:modname) { 'puppetlabs-i18n'}
+    let(:modroot) { "#{modpath}/#{modname}/" }
+    let(:config_path) { "#{modroot}/locales/config.yaml" }
+    let(:mod_obj) { PuppetSpec::Modules.create( modname, modpath, :metadata => { :dependencies => [] }, :env => env ) }
+
+    it "is expected to initialize an un-initialized module" do
+      expect(GettextSetup.translation_repositories.has_key? modname).to be false
+
+      FileUtils.mkdir_p("#{mod_obj.path}/locales")
+      config = {
+        "gettext" => {
+          "project_name" => modname
+        }
+      }
+      File.open(config_path, 'w') { |file| file.write(config.to_yaml) }
+
+      mod_obj.initialize_i18n
+
+      expect(GettextSetup.translation_repositories.has_key? modname).to be true
+    end
+    it "is expected return nil if module is intiailized" do
+      expect(mod_obj.initialize_i18n).to be nil
+    end
+  end
+
   describe "when managing supported platforms" do
     it "should support specifying a supported platform" do
       mod.supports "solaris"

data/spec/unit/network/http/api/indirected_routes_spec.rb

@@ -127,13 +127,13 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should not URI unescape the indirection key" do
-      escaped = URI.escape("foo bar")
+      escaped = Puppet::Util.uri_encode("foo bar")
       indirection, _, key, _ = handler.uri2indirection("GET", "#{master_url_prefix}/node/#{escaped}", params)
       expect(key).to eq(escaped)
     end
 
     it "should not unescape the URI passed through in a call to check_authorization" do
-      key_escaped = URI.escape("foo bar")
+      key_escaped = Puppet::Util.uri_encode("foo bar")
       uri_escaped = "#{master_url_prefix}/node/#{key_escaped}"
       handler.expects(:check_authorization).with(anything, uri_escaped, anything)
       indirection, _, _, _ = handler.uri2indirection("GET", uri_escaped, params)
@@ -199,7 +199,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should use the escaped key as the remainder of the URI" do
-      escaped = URI.escape("with spaces")
+      escaped = Puppet::Util.uri_encode("with spaces")
       expect(handler.class.request_to_uri_and_body(request).first.split("/")[4].sub(/\?.+/, '')).to eq(escaped)
     end
 

data/spec/unit/network/http/rack/rest_spec.rb

@@ -67,7 +67,7 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
 
       it "should return the unescaped path for an escaped request path" do
         unescaped_path = '/foo/bar baz'
-        escaped_path = URI.escape(unescaped_path)
+        escaped_path = Puppet::Util.uri_encode(unescaped_path)
         req = mk_req(escaped_path)
         expect(@handler.path(req)).to eq(unescaped_path)
       end
@@ -170,7 +170,7 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
       end
 
       it "should CGI-decode the HTTP parameters" do
-        encoding = CGI.escape("foo bar")
+        encoding = Puppet::Util.uri_query_encode("foo bar")
         req = mk_req("/?foo=#{encoding}")
         result = @handler.params(req)
         expect(result[:foo]).to eq("foo bar")
@@ -201,7 +201,7 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
       end
 
       it "should treat YAML encoded parameters like it was any string" do
-        escaping = CGI.escape(YAML.dump(%w{one two}))
+        escaping = Puppet::Util.uri_query_encode(YAML.dump(%w{one two}))
         req = mk_req("/?foo=#{escaping}")
         expect(@handler.params(req)[:foo]).to eq("---\n- one\n- two\n")
       end