puppet 4.4.1-x86-mingw32 → 4.4.2-x86-mingw32

data/spec/unit/module_spec.rb

@@ -609,21 +609,21 @@ describe Puppet::Module do
 
   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).returns "{\"foo\" : \"bar\"}"
+    File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns "{\"foo\" : \"bar\"}"
 
     expect(@module).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).returns "{\"foo\" : \"bar\"}"
+    File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns "{\"foo\" : \"bar\"}"
 
     expect(@module).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).returns "This is some invalid json.\n"
+    File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns "This is some invalid json.\n"
     expect(@module).not_to be_has_metadata
   end
 
@@ -646,7 +646,7 @@ describe Puppet::Module do
 
   it "should tolerate failure to parse" do
     Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
-    File.stubs(:read).with(@module.metadata_file).returns(my_fixture('trailing-comma.json'))
+    File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
 
     expect(@module.has_metadata?).to be_falsey
   end
@@ -656,7 +656,7 @@ describe Puppet::Module do
 
     mod = Puppet::Module.new("foo", "/path", mock("env"))
     mod.stubs(:metadata_file).returns "/my/file"
-    File.stubs(:read).with("/my/file").returns text
+    File.stubs(:read).with("/my/file", {:encoding => 'utf-8'}).returns text
     mod
   end
 
@@ -681,7 +681,7 @@ describe Puppet::Module do
       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").returns @text
+        File.stubs(:read).with("/my/file", {:encoding => 'utf-8'}).returns @text
         expect { @module.load_metadata }.to raise_error(
           Puppet::Module::MissingMetadata,
           "No #{attr} module metadata provided for foo"
@@ -690,6 +690,30 @@ describe Puppet::Module do
     end
   end
 
+  describe "when loading the metadata file from disk" do
+    it "should properly parse utf-8 contents" do
+      rune_utf8 = "\u16A0\u16C7\u16BB" # ᚠᛇᚻ
+      metadata_json = tmpfile('metadata.json')
+      File.open(metadata_json, 'w') do |file|
+        file.puts <<-EOF
+  {
+    "license" : "GPL2",
+    "author" : "#{rune_utf8}",
+    "version" : "1.0",
+    "source" : "http://foo/",
+    "dependencies" : []
+  }
+        EOF
+      end
+
+      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)
+    end
+  end
+
   it "should be able to tell if there are local changes" do
     modpath = tmpdir('modpath')
     foo_checksum = 'acbd18db4cc2f85cedef654fccc4a4d8'

data/spec/unit/module_tool/applications/builder_spec.rb

@@ -56,37 +56,41 @@ describe Puppet::ModuleTool::Applications::Builder do
       Puppet::FileSystem.touch(File.join(path, 'gitdirectory/gitartifact'))
       Puppet::FileSystem.touch(File.join(path, 'gitdirectory/gitimportantfile'))
       Puppet::FileSystem.touch(File.join(path, 'gitdirectory/sub/artifact'))
+      Puppet::FileSystem.touch(File.join(path, "git\u16A0\u16C7\u16BB"))
       Puppet::FileSystem.touch(File.join(path, 'pmtignored.foo'))
       Puppet::FileSystem.mkpath(File.join(path, 'pmtdirectory/sub'))
       Puppet::FileSystem.touch(File.join(path, 'pmtdirectory/pmtimportantfile'))
       Puppet::FileSystem.touch(File.join(path, 'pmtdirectory/pmtartifact'))
       Puppet::FileSystem.touch(File.join(path, 'pmtdirectory/sub/artifact'))
+      Puppet::FileSystem.touch(File.join(path, "pmt\u16A0\u16C7\u16BB"))
     end
 
     def create_pmtignore_file
-      Puppet::FileSystem.open(File.join(path, '.pmtignore'), 0600, 'w') do |f|
+      File.open(File.join(path, '.pmtignore'), 'w', 0600, :encoding => 'utf-8') do |f|
         f << <<-PMTIGNORE
 pmtignored.*
 pmtdirectory/sub/**
 pmtdirectory/pmt*
 !pmtimportantfile
+pmt\u16A0\u16C7\u16BB
 PMTIGNORE
       end
     end
 
     def create_gitignore_file
-      Puppet::FileSystem.open(File.join(path, '.gitignore'), 0600, 'w') do |f|
+      File.open(File.join(path, '.gitignore'), 'w', 0600, :encoding => 'utf-8') do |f|
         f << <<-GITIGNORE
 gitignored.*
 gitdirectory/sub/**
 gitdirectory/git*
 !gitimportantfile
+git\u16A0\u16C7\u16BB
 GITIGNORE
       end
     end
 
     def create_symlink_gitignore_file
-      Puppet::FileSystem.open(File.join(path, '.gitignore'), 0600, 'w') do |f|
+      File.open(File.join(path, '.gitignore'), 'w', 0600, :encoding => 'utf-8') do |f|
         f << <<-GITIGNORE
 symlinkfile
     GITIGNORE
@@ -152,6 +156,10 @@ symlinkfile
         expect(target_exists?('gitignored.foo')).to eq true
       end
 
+      it "leaves UTF-8 files" do
+        expect(target_exists?("git\u16A0\u16C7\u16BB")).to eq true
+      end
+
       it "leaves directories" do
         expect(target_exists?('gitdirectory')).to eq true
       end
@@ -178,6 +186,10 @@ symlinkfile
         expect(target_exists?('gitignored.foo')).to eq false
       end
 
+      it "ignores UTF-8 files" do
+        expect(target_exists?("git\u16A0\u16C7\u16BB")).to eq false
+      end
+
       it "ignores directories" do
         expect(target_exists?('gitdirectory')).to eq true
       end
@@ -204,6 +216,10 @@ symlinkfile
         expect(target_exists?('pmtignored.foo')).to eq true
       end
 
+      it "leaves UTF-8 files" do
+        expect(target_exists?("pmt\u16A0\u16C7\u16BB")).to eq true
+      end
+
       it "leaves directories" do
         expect(target_exists?('pmtdirectory')).to eq true
       end
@@ -230,6 +246,10 @@ symlinkfile
         expect(target_exists?('pmtignored.foo')).to eq false
       end
 
+      it "ignores UTF-8 files" do
+        expect(target_exists?("pmt\u16A0\u16C7\u16BB")).to eq false
+      end
+
       it "ignores directories" do
         expect(target_exists?('pmtdirectory')).to eq true
       end

data/spec/unit/network/auth_config_parser_spec.rb

@@ -4,6 +4,7 @@ require 'puppet/network/auth_config_parser'
 require 'puppet/network/authconfig'
 
 describe Puppet::Network::AuthConfigParser do
+  include PuppetSpec::Files
 
   let(:fake_authconfig) do
     "path ~ ^/catalog/([^/])\nmethod find\nallow *\n"
@@ -98,4 +99,19 @@ describe Puppet::Network::AuthConfigParser do
       described_class.new("path /certificates\nauthenticated yes").parse_rights
     end
   end
+
+  describe "when parsing rights from files" do
+    it "can read UTF-8" do
+      rune_path = "/\u16A0\u16C7\u16BB" # ᚠᛇᚻ
+      config = tmpfile('config')
+
+      File.open(config, 'w', :encoding => 'utf-8') do |file|
+        file.puts <<-EOF
+path #{rune_path}
+      EOF
+    end
+
+      expect(described_class.new_from_file(config).parse_rights[rune_path]).to be
+    end
+  end
 end

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

@@ -127,22 +127,17 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       expect(lambda { handler.uri2indirection("UPDATE", "#{master_url_prefix}/node/bar", params) }).to raise_error(ArgumentError)
     end
 
-    it "should URI unescape the indirection key" do
+    it "should not URI unescape the indirection key" do
       escaped = URI.escape("foo bar")
-      indirection, method, key, final_params = handler.uri2indirection("GET", "#{master_url_prefix}/node/#{escaped}", params)
-      expect(key).to eq("foo bar")
+      indirection, _, key, _ = handler.uri2indirection("GET", "#{master_url_prefix}/node/#{escaped}", params)
+      expect(key).to eq(escaped)
     end
 
-    it "should pass through a proper environment param in a call to check_authorization" do
-      handler.expects(:check_authorization).with(anything,
-                                                 anything,
-                                                 all_of(
-                                                   has_entry(:environment,
-                                                             is_a(Puppet::Node::Environment)),
-                                                   has_entry(:environment,
-                                                             responds_with(:name,
-                                                                           :env))))
-      handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", params)
+    it "should not unescape the URI passed through in a call to check_authorization" do
+      key_escaped = URI.escape("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)
     end
 
     it "should not pass through an environment to check_authorization and fail if the environment is unknown" do
@@ -153,6 +148,19 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
                                               "#{master_url_prefix}/node/bar",
                                               {:environment => 'bogus'}) }).to raise_error(ArgumentError)
     end
+
+    it "should not URI unescape the indirection key as passed through to a call to check_authorization" do
+      handler.expects(:check_authorization).with(anything,
+                                                 anything,
+                                                 all_of(
+                                                     has_entry(:environment,
+                                                               is_a(Puppet::Node::Environment)),
+                                                     has_entry(:environment,
+                                                               responds_with(:name,
+                                                                             :env))))
+      handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", params)
+    end
+
   end
 
   describe "when converting a request into a URI" do

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

@@ -65,6 +65,13 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
         expect(@handler.path(req)).to eq("/foo/bar")
       end
 
+      it "should return the unescaped path for an escaped request path" do
+        unescaped_path = '/foo/bar baz'
+        escaped_path = URI.escape(unescaped_path)
+        req = mk_req(escaped_path)
+        expect(@handler.path(req)).to eq(unescaped_path)
+      end
+
       it "should return the request body as the body" do
         req = mk_req('/foo/bar', :input => 'mybody')
         expect(@handler.body(req)).to eq("mybody")

data/spec/unit/pops/loaders/loaders_spec.rb

@@ -107,7 +107,7 @@ describe 'loaders' do
     end
 
     it 'loader allows loading a function more than once' do
-      File.stubs(:read).with(user_metadata_path).returns ''
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns ''
 
       env = environment_for(File.join(dependent_modules_with_metadata, 'modules'))
       loaders = Puppet::Pops::Loaders.new(env)
@@ -166,7 +166,7 @@ describe 'loaders' do
     end
 
     it 'all dependent modules are visible' do
-      File.stubs(:read).with(user_metadata_path).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'}, { 'name' => 'test-usee2'} ]).to_pson
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'}, { 'name' => 'test-usee2'} ]).to_pson
       loaders = Puppet::Pops::Loaders.new(env)
 
       moduleb_loader = loaders.private_loader_for_module('user')
@@ -183,7 +183,7 @@ describe 'loaders' do
         {:from => from, :called => 'a ruby function', :expects => "I'm the function usee::usee_ruby()"} ].each_with_index do |desc, called_idx|
         case_number = from_idx * 3 + called_idx + 1
         it "can call #{desc[:called]} from #{desc[:from]} when dependency is present in metadata.json" do
-          File.stubs(:read).with(user_metadata_path).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+          File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
           Puppet[:code] = "$case_number = #{case_number}\ninclude ::user"
           catalog = compiler.compile
           resource = catalog.resource('Notify', "case_#{case_number}")
@@ -201,7 +201,7 @@ describe 'loaders' do
         end
 
         it 'can not call ruby function in a dependent module from outside a function if dependency is missing in existing metadata.json' do
-          File.stubs(:read).with(user_metadata_path).returns user_metadata.merge('dependencies' => []).to_pson
+          File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => []).to_pson
           Puppet[:code] = "$case_number = #{case_number}\ninclude ::user"
           expect { catalog = compiler.compile }.to raise_error(Puppet::Error, /Unknown function/)
         end
@@ -209,7 +209,7 @@ describe 'loaders' do
     end
 
     it "a type can reference an autoloaded type alias from another module when dependency is present in metadata.json" do
-      File.stubs(:read).with(user_metadata_path).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
         assert_type(Usee::Zero, 0)
         notice(ok)
@@ -225,7 +225,7 @@ describe 'loaders' do
     end
 
     it "a type can reference a type alias from another module when other module has it declared in init.pp" do
-      File.stubs(:read).with(user_metadata_path).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
         include 'usee'
         assert_type(Usee::One, 1)
@@ -234,7 +234,7 @@ describe 'loaders' do
     end
 
     it "an autoloaded type can reference an autoloaded type alias from another module when dependency is present in metadata.json" do
-      File.stubs(:read).with(user_metadata_path).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
         assert_type(User::WithUseeZero, [0])
         notice(ok)
@@ -242,7 +242,7 @@ describe 'loaders' do
     end
 
     it "an autoloaded type can reference an autoloaded type alias from another module when other module has it declared in init.pp" do
-      File.stubs(:read).with(user_metadata_path).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
         include 'usee'
         assert_type(User::WithUseeOne, [1])