puppet 4.0.0 → 4.10.0

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

@@ -7,28 +7,23 @@ 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(:null_sid)     { 'S-1-0-0' }
   let(:unknown_name) { 'chewbacca' }
 
   context "#octet_string_to_sid_object" do
-    it "should properly convert an array of bytes for the local Administrator SID" do
-      host = '.'
-      username = 'Administrator'
-      admin = WIN32OLE.connect("WinNT://#{host}/#{username},user")
-      converted = subject.octet_string_to_sid_object(admin.objectSID)
-
-      expect(converted).to eq(Win32::Security::SID.new(username, host))
-      expect(converted).to be_an_instance_of Win32::Security::SID
-    end
-
-    it "should properly convert an array of bytes for a well-known SID" do
-      bytes = [1, 1, 0, 0, 0, 0, 0, 5, 18, 0, 0, 0]
+    it "should properly convert an array of bytes for a well-known non-localized SID" do
+      bytes = [1, 1, 0, 0, 0, 0, 0, 0, 0, 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(null_sid)
+
+      # carefully select a SID here that is not localized on international Windows
+      expect(converted.account).to eq('NULL SID')
     end
 
     it "should raise an error for non-array input" do
@@ -43,11 +38,25 @@ 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 do |error|
+        expect(error).to be_a(Puppet::Util::Windows::Error)
+        expect(error.code).to eq(1332) # ERROR_NONE_MAPPED
+      end
+    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 do |error|
+        expect(error).to be_a(Puppet::Util::Windows::Error)
+        expect(error.code).to eq(87) # ERROR_INVALID_PARAMETER
+      end
     end
   end
 
@@ -57,16 +66,18 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
     end
 
     it "should accept unqualified account name" do
+      # NOTE: lookup by name works in localized environments only for a few instances
+      # this works in French Windows, even though the account is really Syst\u00E8me
       expect(subject.name_to_sid('SYSTEM')).to eq(sid)
     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
 
@@ -79,12 +90,42 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
     end
 
     it "should accept domain qualified account names" do
+      # NOTE: lookup by name works in localized environments only for a few instances
+      # this works in French Windows, even though the account is really AUTORITE NT\\Syst\u00E8me
       expect(subject.name_to_sid('NT AUTHORITY\SYSTEM')).to eq(sid)
     end
 
     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.SetPassword('PUPPET_RULeZ_123!')
+        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
@@ -92,24 +133,32 @@ 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)
+      # NOTE: lookup by name works in localized environments only for a few instances
+      # this works in French Windows, even though the account is really Syst\u00E8me
+      expect(subject.name_to_sid_object('SYSTEM').sid).to eq(sid)
     end
 
     it "should be case-insensitive" do
+      # NOTE: lookup by name works in localized environments only for a few instances
+      # this works in French Windows, even though the account is really Syst\u00E8me
       expect(subject.name_to_sid_object('SYSTEM')).to eq(subject.name_to_sid_object('system'))
     end
 
     it "should be leading and trailing whitespace-insensitive" do
+      # NOTE: lookup by name works in localized environments only for a few instances
+      # this works in French Windows, even though the account is really Syst\u00E8me
       expect(subject.name_to_sid_object('SYSTEM')).to eq(subject.name_to_sid_object(' SYSTEM '))
     end
 
     it "should accept domain qualified account names" do
-      expect(subject.name_to_sid_object('NT AUTHORITY\SYSTEM').to_s).to eq(sid)
+      # NOTE: lookup by name works in localized environments only for a few instances
+      # this works in French Windows, even though the account is really AUTORITE NT\\Syst\u00E8me
+      expect(subject.name_to_sid_object('NT AUTHORITY\SYSTEM').sid).to eq(sid)
     end
   end
 
@@ -119,7 +168,10 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
     end
 
     it "should accept a sid" do
-      expect(subject.sid_to_name(sid)).to eq("NT AUTHORITY\\SYSTEM")
+      # choose a value that is not localized, for instance
+      # S-1-5-18 can be NT AUTHORITY\\SYSTEM or AUTORITE NT\\Syst\u00E8me
+      # but NULL SID appears universal
+      expect(subject.sid_to_name(null_sid)).to eq('NULL SID')
     end
   end
 

data/spec/unit/util/yaml_spec.rb

@@ -47,8 +47,20 @@ describe Puppet::Util::Yaml do
     end
   end
 
+  it "should allow one to strip ruby tags that would otherwise not parse" do
+    write_file(filename, "---\nweirddata: !ruby/hash:Not::A::Valid::Class {}")
+
+    expect(Puppet::Util::Yaml.load_file(filename, {}, true)).to eq({"weirddata" => {}})
+  end
+
+  it "should not strip non-ruby tags" do
+    write_file(filename, "---\nweirddata: !binary |-\n          e21kNX04MTE4ZGY2NmM5MTc3OTg4ZWE4Y2JiOWEzMjMyNzFkYg==")
+
+    expect(Puppet::Util::Yaml.load_file(filename, {}, true)).to eq({"weirddata" => "{md5}8118df66c9177988ea8cbb9a323271db"})
+  end
+
   def write_file(name, contents)
-    File.open(name, "w") do |fh|
+    File.open(name, "w:UTF-8") do |fh|
       fh.write(contents)
     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,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