puppet 4.3.0 → 4.4.0

data/spec/unit/util/windows/sid_spec.rb

@@ -7,7 +7,7 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
   end
 
   let(:subject)      { Puppet::Util::Windows::SID }
-  let(:sid)          { Win32::Security::SID::LocalSystem }
+  let(:sid)          { Puppet::Util::Windows::SID::LocalSystem }
   let(:invalid_sid)  { 'bogus' }
   let(:unknown_sid)  { 'S-0-0-0' }
   let(:unknown_name) { 'chewbacca' }
@@ -17,8 +17,10 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
       bytes = [1, 1, 0, 0, 0, 0, 0, 5, 18, 0, 0, 0]
       converted = subject.octet_string_to_sid_object(bytes)
 
-      expect(converted).to eq(Win32::Security::SID.new('SYSTEM'))
-      expect(converted).to be_an_instance_of Win32::Security::SID
+      expect(converted).to be_an_instance_of Puppet::Util::Windows::SID::Principal
+      expect(converted.sid_bytes).to eq(bytes)
+      expect(converted.sid).to eq(sid)
+      expect(converted.account).to eq('SYSTEM')
     end
 
     it "should raise an error for non-array input" do
@@ -33,11 +35,19 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
       }.to raise_error(Puppet::Error, /Octet string must be an array of bytes/)
     end
 
+    it "should raise an error for a valid byte array with no mapping to a user" do
+      expect {
+        # S-1-1-1 which is not a valid account
+        valid_octet_invalid_user =[1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0]
+        subject.octet_string_to_sid_object(valid_octet_invalid_user)
+      }.to raise_error(Puppet::Util::Windows::Error, /Failed to call LookupAccountSidW:  No mapping between account names and security IDs was done./)
+    end
+
     it "should raise an error for a malformed byte array" do
       expect {
-        invalid_octet = [1]
+        invalid_octet = [2]
         subject.octet_string_to_sid_object(invalid_octet)
-      }.to raise_error(SystemCallError, /No mapping between account names and security IDs was done./)
+      }.to raise_error(Puppet::Util::Windows::Error, /Failed to call LookupAccountSidW:  The parameter is incorrect./)
     end
   end
 
@@ -51,12 +61,12 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
     end
 
     it "should return a SID for a passed user or group name" do
-      subject.expects(:name_to_sid_object).with('testers').returns 'S-1-5-32-547'
+      subject.expects(:name_to_sid_object).with('testers').returns stub(:sid => 'S-1-5-32-547')
       expect(subject.name_to_sid('testers')).to eq('S-1-5-32-547')
     end
 
     it "should return a SID for a passed fully-qualified user or group name" do
-      subject.expects(:name_to_sid_object).with('MACHINE\testers').returns 'S-1-5-32-547'
+      subject.expects(:name_to_sid_object).with('MACHINE\testers').returns stub(:sid => 'S-1-5-32-547')
       expect(subject.name_to_sid('MACHINE\testers')).to eq('S-1-5-32-547')
     end
 
@@ -75,6 +85,33 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
     it "should be the identity function for any sid" do
       expect(subject.name_to_sid(sid)).to eq(sid)
     end
+
+    describe "with non-US languages" do
+
+      UMLAUT = [195, 164].pack('c*').force_encoding(Encoding::UTF_8)
+      let(:username) { SecureRandom.uuid.to_s.gsub(/\-/, '')[0..13] + UMLAUT }
+
+      after(:each) {
+        Puppet::Util::Windows::ADSI::User.delete(username)
+      }
+
+      it "should properly resolve a username with an umlaut" do
+        # Ruby seems to use the local codepage when making COM calls
+        # if this fails, might want to use Windows API directly instead to ensure bytes
+        user = Puppet::Util::Windows::ADSI.create(username, 'user')
+        user.SetInfo()
+
+        # compare the new SID to the name_to_sid result
+        sid_bytes = user.objectSID.to_a
+        sid_string = ''
+        FFI::MemoryPointer.new(:byte, sid_bytes.length) do |sid_byte_ptr|
+          sid_byte_ptr.write_array_of_uchar(sid_bytes)
+          sid_string = Puppet::Util::Windows::SID.sid_ptr_to_string(sid_byte_ptr)
+        end
+
+        expect(subject.name_to_sid(username)).to eq(sid_string)
+      end
+    end
   end
 
   context "#name_to_sid_object" do
@@ -82,12 +119,12 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
       expect(subject.name_to_sid_object(unknown_name)).to be_nil
     end
 
-    it "should return a Win32::Security::SID instance for any valid sid" do
-      expect(subject.name_to_sid_object(sid)).to be_an_instance_of(Win32::Security::SID)
+    it "should return a Puppet::Util::Windows::SID::Principal instance for any valid sid" do
+      expect(subject.name_to_sid_object(sid)).to be_an_instance_of(Puppet::Util::Windows::SID::Principal)
     end
 
     it "should accept unqualified account name" do
-      expect(subject.name_to_sid_object('SYSTEM').to_s).to eq(sid)
+      expect(subject.name_to_sid_object('SYSTEM').sid).to eq(sid)
     end
 
     it "should be case-insensitive" do
@@ -99,7 +136,7 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
     end
 
     it "should accept domain qualified account names" do
-      expect(subject.name_to_sid_object('NT AUTHORITY\SYSTEM').to_s).to eq(sid)
+      expect(subject.name_to_sid_object('NT AUTHORITY\SYSTEM').sid).to eq(sid)
     end
   end
 

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,119 @@ 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
+
+    it "works around Ruby bug 8822 (which fails to preserve UTF-8 properly when accessing ENV)" 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)
 
+      Puppet::Util.withenv({utf_8_str => utf_8_str}, :windows) do
+        # the true Windows environemnt APIs see the variables correctly
+        expect(process.get_environment_strings[utf_8_str]).to eq(utf_8_str)
+
+        # 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!
+
+        # both a string in UTF-8 and current codepage are deemed valid keys to the hash
+        # which in a sane world shouldn't be true
+        codepage_key = utf_8_str.dup.force_encoding(Encoding.default_external)
+        expect(ENV.key?(codepage_key)).to eq(true)
+        expect(ENV.key?(utf_8_str)).to eq(true)
+        # similarly the value stored at the key is in current codepage and won't match UTF-8 value
+        env_value = ENV[utf_8_str]
+        expect(env_value).to_not eq(utf_8_str)
+        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_str].dup.force_encoding(Encoding::UTF_8)
+        expect(converted_value).to eq(utf_8_str)
+      end
+
+      # real environment shouldn't have env var anymore
+      expect(process.get_environment_strings[utf_8_str]).to eq(nil)
+    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
@@ -324,7 +433,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
@@ -340,11 +450,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
@@ -352,8 +462,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
@@ -365,8 +475,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|
@@ -378,8 +488,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/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