puppet 4.1.0 → 4.10.0

data/spec/unit/util_spec.rb

@@ -24,13 +24,15 @@ describe Puppet::Util do
   end
 
   describe "#withenv" do
+    let(:mode) { Puppet.features.microsoft_windows? ? :windows : :posix }
+
     before :each do
       @original_path = ENV["PATH"]
       @new_env = {:PATH => "/some/bogus/path"}
     end
 
     it "should change environment variables within the block then reset environment variables to their original values" do
-      Puppet::Util.withenv @new_env do
+      Puppet::Util.withenv @new_env, mode do
         expect(ENV["PATH"]).to eq("/some/bogus/path")
       end
       expect(ENV["PATH"]).to eq(@original_path)
@@ -38,7 +40,7 @@ describe Puppet::Util do
 
     it "should reset environment variables to their original values even if the block fails" do
       begin
-        Puppet::Util.withenv @new_env do
+        Puppet::Util.withenv @new_env, mode do
           expect(ENV["PATH"]).to eq("/some/bogus/path")
           raise "This is a failure"
         end
@@ -50,7 +52,7 @@ describe Puppet::Util do
     it "should reset environment variables even when they are set twice" do
       # Setting Path & Environment parameters in Exec type can cause weirdness
       @new_env["PATH"] = "/someother/bogus/path"
-      Puppet::Util.withenv @new_env do
+      Puppet::Util.withenv @new_env, mode do
         # When assigning duplicate keys, can't guarantee order of evaluation
         expect(ENV["PATH"]).to match(/\/some.*\/bogus\/path/)
       end
@@ -60,12 +62,194 @@ describe Puppet::Util do
     it "should remove any new environment variables after the block ends" do
       @new_env[:FOO] = "bar"
       ENV["FOO"] = nil
-      Puppet::Util.withenv @new_env do
+      Puppet::Util.withenv @new_env, mode do
         expect(ENV["FOO"]).to eq("bar")
       end
       expect(ENV["FOO"]).to eq(nil)
     end
+  end
+
+  describe "#withenv on POSIX", :unless => Puppet.features.microsoft_windows? do
+    it "should preserve case" do
+      # start with lower case key,
+      env_key = SecureRandom.uuid.downcase
+
+      begin
+        original_value = 'hello'
+        ENV[env_key] = original_value
+        new_value = 'goodbye'
+
+        Puppet::Util.withenv({env_key.upcase => new_value}, :posix) do
+          expect(ENV[env_key]).to eq(original_value)
+          expect(ENV[env_key.upcase]).to eq(new_value)
+        end
+
+        expect(ENV[env_key]).to eq(original_value)
+        expect(ENV[env_key.upcase]).to be_nil
+      ensure
+        ENV.delete(env_key)
+      end
+    end
+  end
+
+  describe "#withenv on Windows", :if => Puppet.features.microsoft_windows? do
+
+    let(:process) { Puppet::Util::Windows::Process }
+
+    it "should ignore case" do
+      # start with lower case key, ensuring string is not entirely numeric
+      env_key = SecureRandom.uuid.downcase + 'a'
+
+      begin
+        original_value = 'hello'
+        ENV[env_key] = original_value
+        new_value = 'goodbye'
+
+        Puppet::Util.withenv({env_key.upcase => new_value}, :windows) do
+          expect(ENV[env_key]).to eq(new_value)
+          expect(ENV[env_key.upcase]).to eq(new_value)
+        end
+
+        expect(ENV[env_key]).to eq(original_value)
+        expect(ENV[env_key.upcase]).to eq(original_value)
+      ensure
+        ENV.delete(env_key)
+      end
+    end
+
+
+    def withenv_utf8(&block)
+      env_var_name = SecureRandom.uuid
+      utf_8_bytes = [225, 154, 160] # rune ᚠ
+
+      utf_8_key = env_var_name + utf_8_bytes.pack('c*').force_encoding(Encoding::UTF_8)
+      utf_8_value = utf_8_key + 'value'
+      codepage_key = utf_8_key.dup.force_encoding(Encoding.default_external)
+
+      Puppet::Util.withenv({utf_8_key => utf_8_value}, :windows) do
+        # the true Windows environment APIs see the variables correctly
+        expect(process.get_environment_strings[utf_8_key]).to eq(utf_8_value)
+
+        # the string contain the same bytes, but have different Ruby metadata
+        expect(utf_8_key.bytes.to_a).to eq(codepage_key.bytes.to_a)
+
+        yield utf_8_key, utf_8_value, codepage_key
+      end
+
+      # real environment shouldn't have env var anymore
+      expect(process.get_environment_strings[utf_8_key]).to eq(nil)
+    end
+
+    # document buggy Ruby behavior here for https://bugs.ruby-lang.org/issues/8822
+    # Ruby retrieves / stores ENV names in the current codepage
+    # when these tests no longer pass, Ruby has fixed its bugs and workarounds can be removed
+
+
+    # interestingly we would expect some of these tests to fail when codepage is 65001
+    # but instead the env values are in Encoding::ASCII_8BIT!
+    it "works around Ruby bug 8822 (which fails to preserve UTF-8 properly when accessing ENV) (Ruby <= 2.1) ",
+      :if => ((RUBY_VERSION =~ /^(1\.|2\.0\.|2\.1\.)/) && Puppet.features.microsoft_windows?) do
+
+      withenv_utf8 do |utf_8_key, utf_8_value, codepage_key|
+        # both a string in UTF-8 and current codepage are deemed valid keys to the hash
+        # which is because Ruby compares the BINARY versions of the string, but ignores encoding
+        expect(ENV.key?(codepage_key)).to eq(true)
+        expect(ENV.key?(utf_8_key)).to eq(true)
+
+        # Ruby's ENV.keys has slightly different behavior than ENV.key?(key)
+        # the keys collection in 2.1 has a string with the correct bytes
+        # (codepage_key / utf_8_key have same bytes for the sake of searching)
+        found = ENV.keys.find { |k| k.bytes == codepage_key.bytes }
+        # but the string is actually a binary string
+        expect(found.encoding).to eq(Encoding::BINARY)
+        # meaning we can't use include? to find it in either UTF-8 or codepage encoding
+        expect(ENV.keys.include?(codepage_key)).to eq(false)
+        expect(ENV.keys.include?(utf_8_key)).to eq(false)
+
+        # and can only search with a BINARY encoded string
+        expect(ENV.keys.include?(utf_8_key.dup.force_encoding(Encoding::BINARY))).to eq(true)
+
+        # similarly the value stored at the real key is in current codepage
+        # but won't match real UTF-8 value
+        env_value = ENV[utf_8_key]
+        expect(env_value).to_not eq(utf_8_value)
+        expect(env_value.encoding).to_not eq(Encoding::UTF_8)
+
+        # but it can be forced back to UTF-8 to make it match.. ugh
+        converted_value = ENV[utf_8_key].dup.force_encoding(Encoding::UTF_8)
+        expect(converted_value).to eq(utf_8_value)
+      end
+    end
+
+    # but in 2.3, the behavior is mostly correct when external codepage is 65001 / UTF-8
+    it "works around Ruby bug 8822 (which fails to preserve UTF-8 properly when accessing ENV) (Ruby >= 2.3.x) ",
+      :if => ((match = RUBY_VERSION.match(/^2\.(\d+)\./)) && match.captures[0].to_i >= 3 && Puppet.features.microsoft_windows?) do
+
+      raise 'This test requires a non-UTF8 codepage' if Encoding.default_external == Encoding::UTF_8
+
+      withenv_utf8 do |utf_8_key, utf_8_value, codepage_key|
+        # Ruby 2.3 fixes access by the original UTF-8 key, and behaves differently than 2.1
+        # keying by local codepage will work only when the UTF-8 can be converted to local codepage
+        # the key selected for this test contains characters unavailable to a local codepage, hence doesn't work
+
+        # On Japanese Windows (Code Page 932) this test resolves as true.
+        # otherwise the key selected for this test contains characters
+        # unavailable to a local codepage, hence doesn't work
+        # HACK: tech debt to replace once PUP-7019 is understood
+        should_be_found = (Encoding.default_external == Encoding::CP932)
+        expect(ENV.key?(codepage_key)).to eq(should_be_found)
+        expect(ENV.key?(utf_8_key)).to eq(true)
+
+        # Ruby's ENV.keys has slightly different behavior than ENV.key?(key), and 2.3 differs from 2.1
+        # (codepage_key / utf_8_key have same bytes for the sake of searching)
+        found = ENV.keys.find { |k| k.bytes == codepage_key.bytes }
+
+        # the keys collection in 2.3 does not have a string with the correct bytes!
+        # a corrupt version of the key exists with the bytes [225, 154, 160] replaced with [63]!
+        expect(found).to be_nil
+
+        # given the key is corrupted, include? cannot be used to find it in either UTF-8 or codepage encoding
+        expect(ENV.keys.include?(codepage_key)).to eq(false)
+        expect(ENV.keys.include?(utf_8_key)).to eq(false)
+
+        # The value stored at the UTF-8 key is a corrupted current codepage string and won't match UTF-8 value
+        # again the bytes [225, 154, 160] have irreversibly been changed to [63]!
+        env_value = ENV[utf_8_key]
+        expect(env_value).to_not eq(utf_8_value)
+        expect(env_value.encoding).to_not eq(Encoding::UTF_8)
+
+        # the ENV value returned will be in the local codepage which may or may not be able to be
+        # encoded to UTF8.  Our test UTF8 data is not convertible to non-Unicode codepages
+        converted_value = ENV[utf_8_key].dup.force_encoding(Encoding::UTF_8)
+        expect(converted_value).to_not eq(utf_8_value)
+      end
+    end
 
+    it "should preseve existing environment and should not corrupt UTF-8 environment variables" do
+      env_var_name = SecureRandom.uuid
+      utf_8_bytes = [225, 154, 160] # rune ᚠ
+      utf_8_str = env_var_name + utf_8_bytes.pack('c*').force_encoding(Encoding::UTF_8)
+      env_var_name_utf_8 = utf_8_str
+
+      begin
+        # UTF-8 name and value
+        process.set_environment_variable(env_var_name_utf_8, utf_8_str)
+        # ASCII name / UTF-8 value
+        process.set_environment_variable(env_var_name, utf_8_str)
+
+        original_keys = process.get_environment_strings.keys.to_a
+        Puppet::Util.withenv({}, :windows) { }
+
+        env = process.get_environment_strings
+
+        expect(env[env_var_name]).to eq(utf_8_str)
+        expect(env[env_var_name_utf_8]).to eq(utf_8_str)
+        expect(env.keys.to_a).to eq(original_keys)
+      ensure
+        process.set_environment_variable(env_var_name_utf_8, nil)
+        process.set_environment_variable(env_var_name, nil)
+      end
+    end
   end
 
   describe "#absolute_path?" do
@@ -229,11 +413,30 @@ describe Puppet::Util do
       (0..256).each {|n| IO.stubs(:new) }
     end
 
-    it "should close all open file descriptors except stdin/stdout/stderr" do
+    it "should close all open file descriptors except stdin/stdout/stderr when /proc/self/fd exists" do
+      # This is ugly, but I can't really think of a better way to do it without
+      # letting it actually close fds, which seems risky
+      fds = [".", "..","0","1","2","3","5","100","1000"]
+      fds.each do |fd|
+        if fd == '.' || fd == '..'
+          next
+        elsif ['0', '1', '2'].include? fd
+          IO.expects(:new).with(fd.to_i).never
+        else
+          IO.expects(:new).with(fd.to_i).returns mock('io', :close)
+        end
+      end
+
+      Dir.stubs(:foreach).with('/proc/self/fd').multiple_yields(*fds)
+      Puppet::Util.safe_posix_fork
+    end
+
+    it "should close all open file descriptors except stdin/stdout/stderr when /proc/self/fd doesn't exists" do
       # This is ugly, but I can't really think of a better way to do it without
       # letting it actually close fds, which seems risky
       (0..2).each {|n| IO.expects(:new).with(n).never}
-      (3..256).each {|n| IO.expects(:new).with(n).returns mock('io', :close) }
+      (3..256).each { |n| IO.expects(:new).with(n).returns mock('io', :close)  }
+      Dir.stubs(:foreach).with('/proc/self/fd') { raise Errno::ENOENT }
 
       Puppet::Util.safe_posix_fork
     end
@@ -305,7 +508,8 @@ describe Puppet::Util do
       end
 
       it "should walk the search PATH returning the first executable" do
-        ENV.stubs(:[]).with('PATH').returns(File.expand_path('/bin'))
+        Puppet::Util.stubs(:get_env).with('PATH').returns(File.expand_path('/bin'))
+        Puppet::Util.stubs(:get_env).with('PATHEXT').returns(nil)
 
         expect(Puppet::Util.which('foo')).to eq(path)
       end
@@ -321,11 +525,11 @@ describe Puppet::Util do
 
       describe "when a file extension is specified" do
         it "should walk each directory in PATH ignoring PATHEXT" do
-          ENV.stubs(:[]).with('PATH').returns(%w[/bar /bin].map{|dir| File.expand_path(dir)}.join(File::PATH_SEPARATOR))
+          Puppet::Util.stubs(:get_env).with('PATH').returns(%w[/bar /bin].map{|dir| File.expand_path(dir)}.join(File::PATH_SEPARATOR))
+          Puppet::Util.stubs(:get_env).with('PATHEXT').returns('.FOOBAR')
 
           FileTest.expects(:file?).with(File.join(File.expand_path('/bar'), 'foo.CMD')).returns false
 
-          ENV.expects(:[]).with('PATHEXT').never
           expect(Puppet::Util.which('foo.CMD')).to eq(path)
         end
       end
@@ -333,8 +537,8 @@ describe Puppet::Util do
       describe "when a file extension is not specified" do
         it "should walk each extension in PATHEXT until an executable is found" do
           bar = File.expand_path('/bar')
-          ENV.stubs(:[]).with('PATH').returns("#{bar}#{File::PATH_SEPARATOR}#{base}")
-          ENV.stubs(:[]).with('PATHEXT').returns(".EXE#{File::PATH_SEPARATOR}.CMD")
+          Puppet::Util.stubs(:get_env).with('PATH').returns("#{bar}#{File::PATH_SEPARATOR}#{base}")
+          Puppet::Util.stubs(:get_env).with('PATHEXT').returns(".EXE#{File::PATH_SEPARATOR}.CMD")
 
           exts = sequence('extensions')
           FileTest.expects(:file?).in_sequence(exts).with(File.join(bar, 'foo.EXE')).returns false
@@ -346,8 +550,8 @@ describe Puppet::Util do
         end
 
         it "should walk the default extension path if the environment variable is not defined" do
-          ENV.stubs(:[]).with('PATH').returns(base)
-          ENV.stubs(:[]).with('PATHEXT').returns(nil)
+          Puppet::Util.stubs(:get_env).with('PATH').returns(base)
+          Puppet::Util.stubs(:get_env).with('PATHEXT').returns(nil)
 
           exts = sequence('extensions')
           %w[.COM .EXE .BAT].each do |ext|
@@ -359,8 +563,8 @@ describe Puppet::Util do
         end
 
         it "should fall back if no extension matches" do
-          ENV.stubs(:[]).with('PATH').returns(base)
-          ENV.stubs(:[]).with('PATHEXT').returns(".EXE")
+          Puppet::Util.stubs(:get_env).with('PATH').returns(base)
+          Puppet::Util.stubs(:get_env).with('PATHEXT').returns(".EXE")
 
           FileTest.stubs(:file?).with(File.join(base, 'foo.EXE')).returns false
           FileTest.stubs(:file?).with(File.join(base, 'foo')).returns true

data/spec/unit/version_spec.rb

@@ -4,6 +4,7 @@ require 'pathname'
 
 describe "Puppet.version Public API" do
   before :each do
+    @current_ver = Puppet.version
     Puppet.instance_eval do
       if @puppet_version
         @puppet_version = nil
@@ -11,6 +12,10 @@ describe "Puppet.version Public API" do
     end
   end
 
+  after :each do
+    Puppet.version = @current_ver
+  end
+
   context "without a VERSION file" do
     before :each do
       Puppet.stubs(:read_version_file).returns(nil)
@@ -22,6 +27,7 @@ describe "Puppet.version Public API" do
     it "respects the version= setter" do
       Puppet.version = '1.2.3'
       expect(Puppet.version).to eq('1.2.3')
+      expect(Puppet.minor_version).to eq('1.2')
     end
   end
 
@@ -33,10 +39,23 @@ describe "Puppet.version Public API" do
       end.returns('3.0.1-260-g9ca4e54')
 
       expect(Puppet.version).to eq('3.0.1-260-g9ca4e54')
+      expect(Puppet.minor_version).to eq('3.0')
     end
     it "respects the version= setter" do
       Puppet.version = '1.2.3'
       expect(Puppet.version).to eq('1.2.3')
+      expect(Puppet.minor_version).to eq('1.2')
+    end
+  end
+
+  context "Using version setter" do
+    it "does not read VERSION file if using set version" do
+      Puppet.expects(:read_version_file).never
+      Puppet.version = '1.2.3'
+      expect(Puppet.version).to eq('1.2.3')
+      expect(Puppet.minor_version).to eq('1.2')
     end
   end
 end
+
+

data/tasks/cfpropertylist.rake

@@ -0,0 +1,15 @@
+task 'cfpropertylist' do
+  if defined? Pkg::Config and Pkg::Config.project_root
+    cfp_version = "2.2.7"
+    libdir = File.join(Pkg::Config.project_root, "lib")
+    source = "https://github.com/ckruse/CFPropertyList/archive/cfpropertylist-#{cfp_version}.tar.gz"
+    target_dir = Pkg::Util::File.mktemp
+    target = File.join(target_dir, "cfpropertylist")
+    Pkg::Util::Net.fetch_uri(source, target)
+    Pkg::Util::File.untar_into(target, target_dir, "--strip-components 1")
+    mv(Dir.glob("#{File.join(target_dir, "lib")}/cfpropertylist*"), libdir)
+    mv(Dir.glob("#{target_dir}/{LICENSE,README,THANKS}"), File.join(libdir, "cfpropertylist"))
+  else
+    warn "It looks like the packaging tasks have not been loaded. You'll need to `rake package:bootstrap` before using this task"
+  end
+end