puppet 4.3.0 → 4.4.0

data/spec/unit/util/network_device/transport/telnet_spec.rb

@@ -1,84 +1,86 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
-require 'puppet/util/network_device/transport/telnet'
+if Puppet.features.telnet?
+  require 'puppet/util/network_device/transport/telnet'
 
-describe Puppet::Util::NetworkDevice::Transport::Telnet do
+  describe Puppet::Util::NetworkDevice::Transport::Telnet do
 
-  before(:each) do
-    TCPSocket.stubs(:open).returns stub_everything('tcp')
-    @transport = Puppet::Util::NetworkDevice::Transport::Telnet.new()
-  end
-
-  it "should not handle login through the transport" do
-    expect(@transport).not_to be_handles_login
-  end
-
-  it "should not open any files" do
-    File.expects(:open).never
-    @transport.host = "localhost"
-    @transport.port = 23
-
-    @transport.connect
-  end
+    before(:each) do
+      TCPSocket.stubs(:open).returns stub_everything('tcp')
+      @transport = Puppet::Util::NetworkDevice::Transport::Telnet.new()
+    end
 
-  it "should connect to the given host and port" do
-    Net::Telnet.expects(:new).with { |args| args["Host"] == "localhost" && args["Port"] == 23 }.returns stub_everything
-    @transport.host = "localhost"
-    @transport.port = 23
+    it "should not handle login through the transport" do
+      expect(@transport).not_to be_handles_login
+    end
 
-    @transport.connect
-  end
+    it "should not open any files" do
+      File.expects(:open).never
+      @transport.host = "localhost"
+      @transport.port = 23
 
-  it "should connect and specify the default prompt" do
-    @transport.default_prompt = "prompt"
-    Net::Telnet.expects(:new).with { |args| args["Prompt"] == "prompt" }.returns stub_everything
-    @transport.host = "localhost"
-    @transport.port = 23
+      @transport.connect
+    end
 
-    @transport.connect
-  end
+    it "should connect to the given host and port" do
+      Net::Telnet.expects(:new).with { |args| args["Host"] == "localhost" && args["Port"] == 23 }.returns stub_everything
+      @transport.host = "localhost"
+      @transport.port = 23
 
-  describe "when connected" do
-    before(:each) do
-      @telnet = stub_everything 'telnet'
-      Net::Telnet.stubs(:new).returns(@telnet)
       @transport.connect
     end
 
-    it "should send line to the telnet session" do
-      @telnet.expects(:puts).with("line")
-      @transport.send("line")
+    it "should connect and specify the default prompt" do
+      @transport.default_prompt = "prompt"
+      Net::Telnet.expects(:new).with { |args| args["Prompt"] == "prompt" }.returns stub_everything
+      @transport.host = "localhost"
+      @transport.port = 23
+
+      @transport.connect
     end
 
-    describe "when expecting output" do
-      it "should waitfor output on the telnet session" do
-        @telnet.expects(:waitfor).with(/regex/)
-        @transport.expect(/regex/)
+    describe "when connected" do
+      before(:each) do
+        @telnet = stub_everything 'telnet'
+        Net::Telnet.stubs(:new).returns(@telnet)
+        @transport.connect
       end
 
-      it "should return telnet session output" do
-        @telnet.expects(:waitfor).returns("output")
-        expect(@transport.expect(/regex/)).to eq("output")
+      it "should send line to the telnet session" do
+        @telnet.expects(:puts).with("line")
+        @transport.send("line")
       end
 
-      it "should yield telnet session output to the given block" do
-        @telnet.expects(:waitfor).yields("output")
-        @transport.expect(/regex/) { |out| expect(out).to eq("output") }
+      describe "when expecting output" do
+        it "should waitfor output on the telnet session" do
+          @telnet.expects(:waitfor).with(/regex/)
+          @transport.expect(/regex/)
+        end
+
+        it "should return telnet session output" do
+          @telnet.expects(:waitfor).returns("output")
+          expect(@transport.expect(/regex/)).to eq("output")
+        end
+
+        it "should yield telnet session output to the given block" do
+          @telnet.expects(:waitfor).yields("output")
+          @transport.expect(/regex/) { |out| expect(out).to eq("output") }
+        end
       end
     end
-  end
 
-  describe "when closing" do
-    before(:each) do
-      @telnet = stub_everything 'telnet'
-      Net::Telnet.stubs(:new).returns(@telnet)
-      @transport.connect
-    end
+    describe "when closing" do
+      before(:each) do
+        @telnet = stub_everything 'telnet'
+        Net::Telnet.stubs(:new).returns(@telnet)
+        @transport.connect
+      end
 
-    it "should close the telnet session" do
-      @telnet.expects(:close)
-      @transport.close
+      it "should close the telnet session" do
+        @telnet.expects(:close)
+        @transport.close
+      end
     end
   end
 end

data/spec/unit/util/plist_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+require 'puppet/util/plist' if Puppet.features.cfpropertylist?
+require 'puppet_spec/files'
+
+module Puppet::Util::Plist; end
+
+describe Puppet::Util::Plist, :if => Puppet.features.cfpropertylist? do
+  include PuppetSpec::Files
+
+  let(:valid_xml_plist) do
+    '<?xml version="1.0" encoding="UTF-8"?>
+     <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+     <plist version="1.0">
+     <dict>
+       <key>LastUsedPrinters</key>
+       <array>
+         <dict>
+                 <key>Network</key>
+                 <string>10.85.132.1</string>
+                 <key>PrinterID</key>
+                 <string>baskerville_corp_puppetlabs_net</string>
+         </dict>
+         <dict>
+                 <key>Network</key>
+                 <string>10.14.96.1</string>
+                 <key>PrinterID</key>
+                 <string>Statler</string>
+         </dict>
+       </array>
+    </dict>
+    </plist>'
+  end
+  let(:invalid_xml_plist) do
+    '<?xml version="1.0" encoding="UTF-8"?>
+     <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+     <plist version="1.0">
+     <dict>
+       <key>LastUsedPrinters</key>
+       <array>
+         <dict>
+                 <!-- this comment is --terrible -->
+                 <key>Network</key>
+                 <string>10.85.132.1</string>
+                 <key>PrinterID</key>
+                 <string>baskerville_corp_puppetlabs_net</string>
+         </dict>
+         <dict>
+                 <key>Network</key>
+                 <string>10.14.96.1</string>
+                 <key>PrinterID</key>
+                 <string>Statler</string>
+         </dict>
+       </array>
+    </dict>
+    </plist>'
+  end
+  let(:valid_xml_plist_hash) { {"LastUsedPrinters"=>[{"Network"=>"10.85.132.1", "PrinterID"=>"baskerville_corp_puppetlabs_net"}, {"Network"=>"10.14.96.1", "PrinterID"=>"Statler"}]} }
+  let(:plist_path) { file_containing('sample.plist', valid_xml_plist) }
+  let(:binary_plist_magic_number) { 'bplist00' }
+  let(:bad_xml_doctype) { '<!DOCTYPE plist PUBLIC -//Apple Computer' }
+  let(:good_xml_doctype) { '<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">' }
+
+  describe "#read_plist_file" do
+    it "calls #convert_cfpropertylist_to_native_types on a plist object when a valid binary plist is read" do
+      subject.stubs(:read_file_with_offset).with(plist_path, 8).returns(binary_plist_magic_number)
+      subject.stubs(:new_cfpropertylist).with({:file => plist_path}).returns('plist_object')
+      subject.expects(:convert_cfpropertylist_to_native_types).with('plist_object').returns('plist_hash')
+      expect(subject.read_plist_file(plist_path)).to eq('plist_hash')
+    end
+    it "returns a valid hash when a valid XML plist is read" do
+      subject.stubs(:read_file_with_offset).with(plist_path, 8).returns('notbinary')
+      subject.stubs(:open_file_with_args).with(plist_path, 'r:UTF-8').returns(valid_xml_plist)
+      expect(subject.read_plist_file(plist_path)).to eq(valid_xml_plist_hash)
+    end
+    it "raises a debug message and replaces a bad XML plist doctype should one be encountered" do
+      subject.stubs(:read_file_with_offset).with(plist_path, 8).returns('notbinary')
+      subject.stubs(:open_file_with_args).with(plist_path, 'r:UTF-8').returns(bad_xml_doctype)
+      subject.expects(:new_cfpropertylist).with({:data => good_xml_doctype}).returns('plist_object')
+      subject.stubs(:convert_cfpropertylist_to_native_types).with('plist_object').returns('plist_hash')
+      Puppet.expects(:debug).with("Had to fix plist with incorrect DOCTYPE declaration: #{plist_path}")
+      expect(subject.read_plist_file(plist_path)).to eq('plist_hash')
+    end
+    it "attempts to read pure xml using plutil when reading an improperly formatted service plist" do
+      subject.stubs(:read_file_with_offset).with(plist_path, 8).returns('notbinary')
+      subject.stubs(:open_file_with_args).with(plist_path, 'r:UTF-8').returns(invalid_xml_plist)
+      Puppet.expects(:debug).with(regexp_matches(/^Failed with CFFormatError/))
+      Puppet.expects(:debug).with("Plist #{plist_path} ill-formatted, converting with plutil")
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '/dev/stdout', plist_path],
+                                                     {:failonfail => true, :combine => true}).returns(valid_xml_plist)
+      expect(subject.read_plist_file(plist_path)).to eq(valid_xml_plist_hash)
+    end
+  end
+
+  describe "#parse_plist" do
+    it "returns a valid hash when a valid XML plist is provided" do
+      expect(subject.parse_plist(valid_xml_plist)).to eq(valid_xml_plist_hash)
+    end
+    it "raises a debug message and replaces a bad XML plist doctype should one be encountered" do
+      subject.expects(:new_cfpropertylist).with({:data => good_xml_doctype}).returns('plist_object')
+      subject.stubs(:convert_cfpropertylist_to_native_types).with('plist_object')
+      Puppet.expects(:debug).with("Had to fix plist with incorrect DOCTYPE declaration: #{plist_path}")
+      subject.parse_plist(bad_xml_doctype, plist_path)
+    end
+    it "raises a debug message with malformed plist" do
+      subject.stubs(:convert_cfpropertylist_to_native_types).with('plist_object')
+      Puppet.expects(:debug).with(regexp_matches(/^Failed with CFFormatError/))
+      subject.parse_plist("<plist><dict><key>Foo</key>")
+    end
+  end
+end

data/spec/unit/util/resource_template_spec.rb

@@ -20,7 +20,7 @@ describe Puppet::Util::ResourceTemplate do
   describe "when evaluating" do
     before do
       Puppet::FileSystem.stubs(:exist?).returns true
-      File.stubs(:read).returns "eh"
+      Puppet::FileSystem.stubs(:read).returns "eh"
 
       @template = stub 'template', :result => nil
       ERB.stubs(:new).returns @template
@@ -38,7 +38,7 @@ describe Puppet::Util::ResourceTemplate do
     end
 
     it "should create a template instance with the contents of the file" do
-      File.expects(:read).with("/my/template").returns "yay"
+      Puppet::FileSystem.expects(:read).with("/my/template", :encoding => 'utf-8').returns "yay"
       ERB.expects(:new).with("yay", 0, "-").returns(@template)
 
       @wrapper.stubs :set_resource_variables

data/spec/unit/util/run_mode_spec.rb

@@ -261,6 +261,30 @@ describe Puppet::Util::RunMode do
         end
       end
     end
+
+    describe "#without_env internal helper with UTF8 characters" do
+      let(:varname) { "\u16A0\u16C7\u16BB\u16EB\u16D2\u16E6\u16A6\u16EB\u16A0\u16B1\u16A9\u16A0\u16A2\u16B1\u16EB\u16A0\u16C1\u16B1\u16AA\u16EB\u16B7\u16D6\u16BB\u16B9\u16E6\u16DA\u16B3\u16A2\u16D7" }
+      let(:rune_utf8) { "\u16A0\u16C7\u16BB\u16EB\u16D2\u16E6\u16A6\u16EB\u16A0\u16B1\u16A9\u16A0\u16A2\u16B1\u16EB\u16A0\u16C1\u16B1\u16AA\u16EB\u16B7\u16D6\u16BB\u16B9\u16E6\u16DA\u16B3\u16A2\u16D7" }
+
+      before do
+        Puppet::Util::Windows::Process.set_environment_variable(varname, rune_utf8)
+      end
+
+      it "removes environment variables within the block with UTF8 name" do
+        without_env(varname) do
+          expect(ENV[varname]).to be(nil)
+        end
+      end
+
+      it "restores UTF8 characters in environment variable values" do
+        without_env(varname) do
+          Puppet::Util::Windows::Process.set_environment_variable(varname, 'bad value')
+        end
+
+        envhash = Puppet::Util::Windows::Process.get_environment_strings
+        expect(envhash[varname]).to eq(rune_utf8)
+      end
+    end
   end
 
   def as_root
@@ -274,11 +298,11 @@ describe Puppet::Util::RunMode do
   end
 
   def without_env(name, &block)
-    saved = ENV[name]
-    ENV.delete name
+    saved = Puppet::Util.get_env(name)
+    Puppet::Util.set_env(name, nil)
     yield
   ensure
-    ENV[name] = saved
+    Puppet::Util.set_env(name, saved)
   end
 
   def without_home(&block)

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

@@ -40,16 +40,16 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
   end
 
   describe ".sid_uri" do
-    it "should raise an error when the input is not a SID object" do
+    it "should raise an error when the input is not a SID Principal" do
       [Object.new, {}, 1, :symbol, '', nil].each do |input|
         expect {
           Puppet::Util::Windows::ADSI.sid_uri(input)
-        }.to raise_error(Puppet::Error, /Must use a valid SID object/)
+        }.to raise_error(Puppet::Error, /Must use a valid SID::Principal/)
       end
     end
 
     it "should return a SID uri for a well-known SID (SYSTEM)" do
-      sid = Win32::Security::SID.new('SYSTEM')
+      sid = Puppet::Util::Windows::SID::Principal.lookup_account_name('SYSTEM')
       expect(Puppet::Util::Windows::ADSI.sid_uri(sid)).to eq('WinNT://S-1-5-18')
     end
   end
@@ -60,12 +60,10 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
     let(:domain_username) { "#{domain}\\#{username}"}
 
     it "should generate the correct URI" do
-      Puppet::Util::Windows::ADSI.stubs(:sid_uri_safe).returns(nil)
       expect(Puppet::Util::Windows::ADSI::User.uri(username)).to eq("WinNT://./#{username},user")
     end
 
     it "should generate the correct URI for a user with a domain" do
-      Puppet::Util::Windows::ADSI.stubs(:sid_uri_safe).returns(nil)
       expect(Puppet::Util::Windows::ADSI::User.uri(username, domain)).to eq("WinNT://#{domain}/#{username},user")
     end
 
@@ -96,25 +94,33 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
     end
 
     it "should be able to check the existence of a user" do
-      Puppet::Util::Windows::ADSI.stubs(:sid_uri_safe).returns(nil)
+      Puppet::Util::Windows::SID.expects(:name_to_sid_object).with(username).returns nil
       Puppet::Util::Windows::ADSI.expects(:connect).with("WinNT://./#{username},user").returns connection
+      connection.expects(:Class).returns('User')
       expect(Puppet::Util::Windows::ADSI::User.exists?(username)).to be_truthy
     end
 
     it "should be able to check the existence of a domain user" do
-      Puppet::Util::Windows::ADSI.stubs(:sid_uri_safe).returns(nil)
+      Puppet::Util::Windows::SID.expects(:name_to_sid_object).with("#{domain}\\#{username}").returns nil
       Puppet::Util::Windows::ADSI.expects(:connect).with("WinNT://#{domain}/#{username},user").returns connection
+      connection.expects(:Class).returns('User')
       expect(Puppet::Util::Windows::ADSI::User.exists?(domain_username)).to be_truthy
     end
 
     it "should be able to confirm the existence of a user with a well-known SID" do
-
-      system_user = Win32::Security::SID::LocalSystem
+      system_user = Puppet::Util::Windows::SID::LocalSystem
       # ensure that the underlying OS is queried here
       Puppet::Util::Windows::ADSI.unstub(:connect)
       expect(Puppet::Util::Windows::ADSI::User.exists?(system_user)).to be_truthy
     end
 
+    it "should return false with a well-known Group SID" do
+      group = Puppet::Util::Windows::SID::BuiltinAdministrators
+      # ensure that the underlying OS is queried here
+      Puppet::Util::Windows::ADSI.unstub(:connect)
+      expect(Puppet::Util::Windows::ADSI::User.exists?(group)).to be_falsey
+    end
+
     it "should return nil with an unknown SID" do
 
       bogus_sid = 'S-1-2-3-4'
@@ -130,8 +136,6 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
     end
 
     it "should return an enumeration of IADsUser wrapped objects" do
-      Puppet::Util::Windows::ADSI.stubs(:sid_uri_safe).returns(nil)
-
       name = 'Administrator'
       wmi_users = [stub('WMI', :name => name)]
       Puppet::Util::Windows::ADSI.expects(:execquery).with('select name from win32_useraccount where localaccount = "TRUE"').returns(wmi_users)
@@ -203,20 +207,20 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
 
       describe "when given a set of groups to which to add the user" do
         let(:existing_groups) { ['group2','group3'] }
-        let(:group_sids) { existing_groups.each_with_index.map{|n,i| stub(:Name => n, :objectSID => [i])} }
+        let(:group_sids) { existing_groups.each_with_index.map{|n,i| stub(:Name => n, :objectSID => stub(:sid => i))} }
 
         let(:groups_to_set) { 'group1,group2' }
-        let(:desired_sids) { groups_to_set.split(',').each_with_index.map{|n,i| stub(:Name => n, :objectSID => [i-1])} }
+        let(:desired_sids) { groups_to_set.split(',').each_with_index.map{|n,i| stub(:Name => n, :objectSID => stub(:sid => i-1))} }
 
         before(:each) do
-          user.expects(:group_sids).returns(group_sids.map {|s| s.objectSID})
+          user.expects(:group_sids).returns(group_sids.map {|s| s.objectSID })
         end
 
         describe "if membership is specified as inclusive" do
           it "should add the user to those groups, and remove it from groups not in the list" do
-            Puppet::Util::Windows::ADSI::User.expects(:name_sid_hash).returns(Hash[ desired_sids.map { |s| [s.objectSID.to_s, s.objectSID] }])
-            user.expects(:add_group_sids).with([-1])
-            user.expects(:remove_group_sids).with([1])
+            Puppet::Util::Windows::ADSI::User.expects(:name_sid_hash).returns(Hash[ desired_sids.map { |s| [s.objectSID.sid, s.objectSID] }])
+            user.expects(:add_group_sids).with { |value| value.sid == -1 }
+            user.expects(:remove_group_sids).with { |value| value.sid == 1 }
 
             user.set_groups(groups_to_set, false)
           end
@@ -224,7 +228,7 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
           it "should remove all users from a group if desired is empty" do
             Puppet::Util::Windows::ADSI::User.expects(:name_sid_hash).returns({})
             user.expects(:add_group_sids).never
-            user.expects(:remove_group_sids).with([0], [1])
+            user.expects(:remove_group_sids).with { |user1, user2| user1.sid == 0 && user2.sid == 1 }
 
             user.set_groups('', false)
           end
@@ -232,8 +236,8 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
 
         describe "if membership is specified as minimum" do
           it "should add the user to the specified groups without affecting its other memberships" do
-            Puppet::Util::Windows::ADSI::User.expects(:name_sid_hash).returns(Hash[ desired_sids.map { |s| [s.objectSID.to_s, s.objectSID] }])
-            user.expects(:add_group_sids).with([-1])
+            Puppet::Util::Windows::ADSI::User.expects(:name_sid_hash).returns(Hash[ desired_sids.map { |s| [s.objectSID.sid, s.objectSID] }])
+            user.expects(:add_group_sids).with { |value| value.sid == -1 }
             user.expects(:remove_group_sids).never
 
             user.set_groups(groups_to_set, true)
@@ -270,7 +274,7 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
         end
 
         it "and raise when passed a non-SID object to add" do
-          expect{ group.add_member_sids(invalid)}.to raise_error(Puppet::Error, /Must use a valid SID object/)
+          expect{ group.add_member_sids(invalid)}.to raise_error(Puppet::Error, /Must use a valid SID::Principal/)
         end
 
         it "to remove a member" do
@@ -280,7 +284,7 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
         end
 
         it "and raise when passed a non-SID object to remove" do
-          expect{ group.remove_member_sids(invalid)}.to raise_error(Puppet::Error, /Must use a valid SID object/)
+          expect{ group.remove_member_sids(invalid)}.to raise_error(Puppet::Error, /Must use a valid SID::Principal/)
         end
       end
 
@@ -298,9 +302,9 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
         it "should set the members of a group to only desired_members when inclusive" do
           names = ['DOMAIN\user1', 'user2']
           sids = [
-              stub(:account => 'user1', :domain => 'DOMAIN'),
-              stub(:account => 'user2', :domain => 'testcomputername'),
-              stub(:account => 'user3', :domain => 'DOMAIN2'),
+              stub(:account => 'user1', :domain => 'DOMAIN', :sid => 1),
+              stub(:account => 'user2', :domain => 'testcomputername', :sid => 2),
+              stub(:account => 'user3', :domain => 'DOMAIN2', :sid => 3),
           ]
 
           # use stubbed objectSid on member to return stubbed SID
@@ -325,9 +329,9 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
         it "should add the desired_members to an existing group when not inclusive" do
           names = ['DOMAIN\user1', 'user2']
           sids = [
-              stub(:account => 'user1', :domain => 'DOMAIN'),
-              stub(:account => 'user2', :domain => 'testcomputername'),
-              stub(:account => 'user3', :domain => 'DOMAIN2'),
+              stub(:account => 'user1', :domain => 'DOMAIN', :sid => 1),
+              stub(:account => 'user2', :domain => 'testcomputername', :sid => 2),
+              stub(:account => 'user3', :domain => 'DOMAIN2', :sid => 3),
           ]
 
           # use stubbed objectSid on member to return stubbed SID
@@ -361,8 +365,8 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
         it "should remove all members when desired_members is empty and inclusive" do
           names = ['DOMAIN\user1', 'user2']
           sids = [
-              stub(:account => 'user1', :domain => 'DOMAIN'),
-              stub(:account => 'user2', :domain => 'testcomputername')
+              stub(:account => 'user1', :domain => 'DOMAIN', :sid => 1 ),
+              stub(:account => 'user2', :domain => 'testcomputername', :sid => 2 ),
           ]
 
           # use stubbed objectSid on member to return stubbed SID
@@ -384,8 +388,8 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
         it "should do nothing when desired_members is empty and not inclusive" do
           names = ['DOMAIN\user1', 'user2']
           sids = [
-              stub(:account => 'user1', :domain => 'DOMAIN'),
-              stub(:account => 'user2', :domain => 'testcomputername')
+              stub(:account => 'user1', :domain => 'DOMAIN', :sid => 1 ),
+              stub(:account => 'user2', :domain => 'testcomputername', :sid => 2 ),
           ]
           # use stubbed objectSid on member to return stubbed SID
           Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([0]).returns(sids[0])
@@ -409,7 +413,6 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
       end
 
       it "should generate the correct URI" do
-        Puppet::Util::Windows::ADSI.stubs(:sid_uri_safe).returns(nil)
         adsi_group.expects(:objectSID).returns([0])
         Socket.expects(:gethostname).returns('testcomputername')
         Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([0]).returns(stub(:account => groupname,:domain => 'testcomputername'))
@@ -418,7 +421,6 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
     end
 
     it "should generate the correct URI" do
-      Puppet::Util::Windows::ADSI.stubs(:sid_uri_safe).returns(nil)
       expect(Puppet::Util::Windows::ADSI::Group.uri("people")).to eq("WinNT://./people,group")
     end
 
@@ -435,20 +437,28 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
     end
 
     it "should be able to confirm the existence of a group" do
-      Puppet::Util::Windows::ADSI.stubs(:sid_uri_safe).returns(nil)
+      Puppet::Util::Windows::SID.expects(:name_to_sid_object).with(groupname).returns nil
       Puppet::Util::Windows::ADSI.expects(:connect).with("WinNT://./#{groupname},group").returns connection
+      connection.expects(:Class).returns('Group')
 
       expect(Puppet::Util::Windows::ADSI::Group.exists?(groupname)).to be_truthy
     end
 
     it "should be able to confirm the existence of a group with a well-known SID" do
 
-      service_group = Win32::Security::SID::Service
+      service_group = Puppet::Util::Windows::SID::Service
       # ensure that the underlying OS is queried here
       Puppet::Util::Windows::ADSI.unstub(:connect)
       expect(Puppet::Util::Windows::ADSI::Group.exists?(service_group)).to be_truthy
     end
 
+    it "will return true with a well-known User SID, as there is no way to resolve it with a WinNT:// style moniker" do
+      user = Puppet::Util::Windows::SID::NtLocal
+      # ensure that the underlying OS is queried here
+      Puppet::Util::Windows::ADSI.unstub(:connect)
+      expect(Puppet::Util::Windows::ADSI::Group.exists?(user)).to be_truthy
+    end
+
     it "should return nil with an unknown SID" do
 
       bogus_sid = 'S-1-2-3-4'
@@ -464,8 +474,6 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
     end
 
     it "should return an enumeration of IADsGroup wrapped objects" do
-      Puppet::Util::Windows::ADSI.stubs(:sid_uri_safe).returns(nil)
-
       name = 'Administrators'
       wmi_groups = [stub('WMI', :name => name)]
       Puppet::Util::Windows::ADSI.expects(:execquery).with('select name from win32_group where localaccount = "TRUE"').returns(wmi_groups)

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

@@ -25,4 +25,46 @@ describe "FFI::MemoryPointer", :if => Puppet.features.microsoft_windows? do
       expect(read_string.encoding).to eq(Encoding::UTF_8)
     end
   end
+
+  context "read_arbitrary_wide_string_up_to" do
+    let (:string) { "foo_bar" }
+    let (:single_null_string) { string + "\x00" }
+    let (:double_null_string) { string + "\x00\x00" }
+
+    it "should read a short single null terminated string" do
+      read_string = nil
+      FFI::MemoryPointer.from_string_to_wide_string(single_null_string) do |ptr|
+        read_string = ptr.read_arbitrary_wide_string_up_to()
+      end
+
+      expect(read_string).to eq(string)
+    end
+
+    it "should read a short double null terminated string" do
+      read_string = nil
+      FFI::MemoryPointer.from_string_to_wide_string(double_null_string) do |ptr|
+        read_string = ptr.read_arbitrary_wide_string_up_to(512, :double_null)
+      end
+
+      expect(read_string).to eq(string)
+    end
+
+    it "should return a string of max_length characters when specified" do
+      read_string = nil
+      FFI::MemoryPointer.from_string_to_wide_string(single_null_string) do |ptr|
+        read_string = ptr.read_arbitrary_wide_string_up_to(3)
+      end
+
+      expect(read_string).to eq(string[0..2])
+    end
+
+    it "should return wide strings in UTF-8" do
+      read_string = nil
+      FFI::MemoryPointer.from_string_to_wide_string(string) do |ptr|
+        read_string = ptr.read_arbitrary_wide_string_up_to()
+      end
+
+      expect(read_string.encoding).to eq(Encoding::UTF_8)
+    end
+  end
 end

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

@@ -4,9 +4,9 @@ require 'spec_helper'
 require 'puppet/util/windows'
 
 describe "Puppet::Util::Windows::SecurityDescriptor", :if => Puppet.features.microsoft_windows? do
-  let(:system_sid) { Win32::Security::SID::LocalSystem }
-  let(:admins_sid) { Win32::Security::SID::BuiltinAdministrators }
-  let(:group_sid) { Win32::Security::SID::Nobody }
+  let(:system_sid) { Puppet::Util::Windows::SID::LocalSystem }
+  let(:admins_sid) { Puppet::Util::Windows::SID::BuiltinAdministrators }
+  let(:group_sid) { Puppet::Util::Windows::SID::Nobody }
   let(:new_sid)   { 'S-1-5-32-500-1-2-3' }
 
   def empty_dacl