puppet 5.3.7-x86-mingw32 → 5.4.0-x86-mingw32

data/spec/unit/type/file/checksum_spec.rb

@@ -36,6 +36,18 @@ describe checksum do
     expect(@checksum.sum("foobar")).to eq("{sha256}#{sum}")
   end
 
+  it "when using digest_algorithm 'sha512' should return the summed contents with a checksum label" do
+    sum = Digest::SHA512.hexdigest("foobar")
+    @resource[:checksum] = :sha512
+    expect(@checksum.sum("foobar")).to eq("{sha512}#{sum}")
+  end
+
+  it "when using digest_algorithm 'sha384' should return the summed contents with a checksum label" do
+    sum = Digest::SHA384.hexdigest("foobar")
+    @resource[:checksum] = :sha384
+    expect(@checksum.sum("foobar")).to eq("{sha384}#{sum}")
+  end
+
   it "should use :md5 as its default type" do
     expect(@checksum.default).to eq(:md5)
   end
@@ -82,4 +94,12 @@ describe checksum do
     Puppet.settings[:supported_checksum_types] = values
     expect(Puppet.settings[:supported_checksum_types]).to eq(values)
   end
+
+  it 'rejects md5 checksums in FIPS mode' do
+    Puppet::Util::Platform.stubs(:fips_enabled?).returns true
+    expect {
+      @resource[:checksum] = :md5
+    }.to raise_error(Puppet::ResourceError,
+                     /Parameter checksum failed.* MD5 is not supported in FIPS mode/)
+  end
 end

data/spec/unit/type/file_spec.rb

@@ -1469,6 +1469,8 @@ describe Puppet::Type.type(:file) do
   describe "when using source" do
     before do
       file[:source] = File.expand_path('/one')
+      # Contents of an empty file generate the below hash values
+      # in case you need to add support for additional algorithms in future
       @checksum_values = {
         :md5 => 'd41d8cd98f00b204e9800998ecf8427e',
         :md5lite => 'd41d8cd98f00b204e9800998ecf8427e',
@@ -1476,6 +1478,9 @@ describe Puppet::Type.type(:file) do
         :sha256lite => 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
         :sha1 => 'da39a3ee5e6b4b0d3255bfef95601890afd80709',
         :sha1lite => 'da39a3ee5e6b4b0d3255bfef95601890afd80709',
+        :sha224 => 'd14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f',
+        :sha384 => '38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b',
+        :sha512 => 'cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e',
         :mtime => 'Jan 26 13:59:49 2016',
         :ctime => 'Jan 26 13:59:49 2016'
       }
@@ -1569,6 +1574,9 @@ describe Puppet::Type.type(:file) do
         :sha256lite => 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
         :sha1 => 'da39a3ee5e6b4b0d3255bfef95601890afd80709',
         :sha1lite => 'da39a3ee5e6b4b0d3255bfef95601890afd80709',
+        :sha224 => 'd14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f',
+        :sha384 => '38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b',
+        :sha512 => 'cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e',
       }
     end
 

data/spec/unit/type/group_spec.rb

@@ -10,6 +10,14 @@ describe Puppet::Type.type(:group) do
     expect(@class.provider_feature(:system_groups)).not_to be_nil
   end
 
+  it 'should default to `present`' do
+    expect(@class.new(:name => "foo")[:ensure]).to eq(:present)
+  end
+
+  it 'should set ensure to whatever is passed in' do
+    expect(@class.new(:name => "foo", :ensure => 'absent')[:ensure]).to eq(:absent)
+  end
+
   describe "when validating attributes" do
     [:name, :allowdupe].each do |param|
       it "should have a #{param} parameter" do

data/spec/unit/type/k5login_spec.rb

@@ -12,6 +12,10 @@ describe Puppet::Type.type(:k5login), :unless => Puppet.features.microsoft_windo
     it { is_expected.to be_validattr :path }
     it { is_expected.to be_validattr :principals }
     it { is_expected.to be_validattr :mode }
+    it { is_expected.to be_validattr :selrange }
+    it { is_expected.to be_validattr :selrole }
+    it { is_expected.to be_validattr :seltype }
+    it { is_expected.to be_validattr :seluser }
     # We have one, inline provider implemented.
     it { is_expected.to be_validattr :provider }
   end
@@ -22,7 +26,11 @@ describe Puppet::Type.type(:k5login), :unless => Puppet.features.microsoft_windo
     attrs = {
       :ensure     => 'present',
       :path       => path,
-      :principals => 'fred@EXAMPLE.COM'
+      :principals => 'fred@EXAMPLE.COM',
+      :seluser    => 'user_u',
+      :selrole    => 'role_r',
+      :seltype    => 'type_t',
+      :selrange   => 's0',
     }.merge(attrs)
 
     if content = attrs.delete(:content)
@@ -69,6 +77,19 @@ describe Puppet::Type.type(:k5login), :unless => Puppet.features.microsoft_windo
           end
         end
 
+        context "with selinux" do
+          subject { resource(:content => "daniel@EXAMPLE.COM\n",).retrieve }
+          it "should return correct values based on SELinux state" do
+            Puppet::Type::K5login::ProviderK5login.any_instance.stubs(:selinux_support?).returns true
+            Puppet::Type::K5login::ProviderK5login.any_instance.stubs(:get_selinux_current_context).returns "user_u:role_r:type_t:s0"
+
+            expect(subject[:seluser]).to eq("user_u")
+            expect(subject[:selrole]).to eq("role_r")
+            expect(subject[:seltype]).to eq("type_t")
+            expect(subject[:selrange]).to eq("s0")
+          end
+        end
+
         context "with two principals" do
           subject do
             content = ["daniel@EXAMPLE.COM", "george@EXAMPLE.COM"].join("\n")

data/spec/unit/type/scheduled_task_spec.rb

@@ -57,6 +57,21 @@ describe Puppet::Type.type(:scheduled_task), :if => Puppet.features.microsoft_wi
   end
 
   describe 'when setting whether the task is enabled or not' do
+    it 'should return true when enabled is set to true' do
+      expect(described_class.new(
+        :title   => 'Foo',
+        :command => 'C:\Windows\System32\notepad.exe',
+        :enabled => 'true',
+      )[:enabled]).to eq(:true)
+    end
+
+    it 'should return false when enabled is set to false' do
+      expect(described_class.new(
+        :title   => 'Foo',
+        :command => 'C:\Windows\System32\notepad.exe',
+        :enabled => 'false',
+      )[:enabled]).to eq(:false)
+    end
   end
 
   describe 'when setting the working directory' do

data/spec/unit/type/user_spec.rb

@@ -86,7 +86,7 @@ describe Puppet::Type.type(:user) do
     end
   end
 
-  properties = [:ensure, :uid, :gid, :home, :comment, :shell, :password, :password_min_age, :password_max_age, :groups, :roles, :auths, :profiles, :project, :keys, :expiry]
+  properties = [:ensure, :uid, :gid, :home, :comment, :shell, :password, :password_min_age, :password_max_age, :password_warn_days, :groups, :roles, :auths, :profiles, :project, :keys, :expiry]
 
   properties.each do |property|
     it "should have a #{property} property" do
@@ -314,6 +314,16 @@ describe Puppet::Type.type(:user) do
     end
   end
 
+  describe "when managing warning password days" do
+    it "should accept a negative warning days" do
+      expect { described_class.new(:name => 'foo', :password_warn_days => '-1') }.to_not raise_error
+    end
+
+    it "should fail with an empty warning days" do
+      expect { described_class.new(:name => 'foo', :password_warn_days => '') }.to raise_error(Puppet::Error, /warning days must be provided as a number/)
+    end
+  end
+
   describe "when managing passwords" do
     before do
       @password = described_class.new(:name => 'foo', :password => 'mypass').parameter(:password)

data/spec/unit/type/yumrepo_spec.rb

@@ -174,6 +174,11 @@ describe Puppet::Type.type(:yumrepo) do
       it_behaves_like "a yumrepo parameter that can be absent", :gpgcheck
     end
 
+    describe "payload_gpgcheck" do
+      it_behaves_like "a yumrepo parameter that expects a boolean parameter", :payload_gpgcheck
+      it_behaves_like "a yumrepo parameter that can be absent", :payload_gpgcheck
+    end
+
     describe "repo_gpgcheck" do
       it_behaves_like "a yumrepo parameter that expects a boolean parameter", :repo_gpgcheck
       it_behaves_like "a yumrepo parameter that can be absent", :repo_gpgcheck

data/spec/unit/util/checksums_spec.rb

@@ -10,7 +10,7 @@ describe Puppet::Util::Checksums do
     @summer = Puppet::Util::Checksums
   end
 
-  content_sums = [:md5, :md5lite, :sha1, :sha1lite, :sha256, :sha256lite]
+  content_sums = [:md5, :md5lite, :sha1, :sha1lite, :sha256, :sha256lite, :sha512, :sha384, :sha224]
   file_only = [:ctime, :mtime, :none]
 
   content_sums.each do |sumtype|
@@ -42,7 +42,7 @@ describe Puppet::Util::Checksums do
   end
 
   %w{{md5}asdfasdf {sha1}asdfasdf {ctime}asdasdf {mtime}asdfasdf 
-     {sha256}asdfasdf {sha256lite}asdfasdf}.each do |sum|
+     {sha256}asdfasdf {sha256lite}asdfasdf {sha512}asdfasdf {sha384}asdfasdf {sha224}asdfasdf}.each do |sum|
     it "should consider #{sum} to be a checksum" do
       expect(@summer).to be_checksum(sum)
     end
@@ -66,7 +66,7 @@ describe Puppet::Util::Checksums do
     expect(@summer.sumtype("asdfasdfa")).to be_nil
   end
 
-  {:md5 => Digest::MD5, :sha1 => Digest::SHA1, :sha256 => Digest::SHA256}.each do |sum, klass|
+  {:md5 => Digest::MD5, :sha1 => Digest::SHA1, :sha256 => Digest::SHA256, :sha512 => Digest::SHA512, :sha384 => Digest::SHA384}.each do |sum, klass|
     describe("when using #{sum}") do
       it "should use #{klass} to calculate string checksums" do
         klass.expects(:hexdigest).with("mycontent").returns "whatever"

data/spec/unit/util/log/destinations_spec.rb

@@ -207,6 +207,20 @@ describe ":eventlog", :if => Puppet::Util::Platform.windows? do
     expect(Puppet.features.eventlog?).to be_truthy
   end
 
+  it "should truncate extremely long log messages" do
+    long_msg = "x" * 32000
+    expected_truncated_msg = "#{'x' * 31785}...Message exceeds character length limit, truncating."
+    expected_data = "a vogon ship: " + expected_truncated_msg
+
+    eventlog = stub('eventlog')
+    eventlog.expects(:report_event).with(has_entries(:event_type => 2, :event_id => 2, :data => expected_data))
+    msg = Puppet::Util::Log.new(:level => :warning, :message => long_msg, :source => "a vogon ship")
+    Puppet::Util::Windows::EventLog.stubs(:open).returns(eventlog)
+
+    dest = klass.new
+    dest.handle(msg)
+  end
+  
   it "logs to the Puppet Application event log" do
     Puppet::Util::Windows::EventLog.expects(:open).with('Puppet').returns(stub('eventlog'))
 

data/spec/unit/util/network_device/cisco/device_spec.rb

@@ -184,7 +184,7 @@ eos
       "VLAN99" => "VLAN99"
     }.each do |input,expected|
       it "should canonicalize #{input} to #{expected}" do
-        expect(@cisco.canonalize_ifname(input)).to eq(expected)
+        expect(@cisco.canonicalize_ifname(input)).to eq(expected)
       end
     end
 

data/spec/unit/util/plist_spec.rb

@@ -92,7 +92,7 @@ describe Puppet::Util::Plist, :if => Puppet.features.cfpropertylist? do
       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', '-', plist_path],
+      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
@@ -101,7 +101,7 @@ describe Puppet::Util::Plist, :if => Puppet.features.cfpropertylist? do
       subject.stubs(:open_file_with_args).with(plist_path, 'r:UTF-8').returns(non_plist_data)
       Puppet.expects(:debug).with(regexp_matches(/^Failed with (CFFormatError|NoMethodError)/))
       Puppet.expects(:debug).with("Plist #{plist_path} ill-formatted, converting with plutil")
-      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '-', plist_path],
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '/dev/stdout', plist_path],
                                                      {:failonfail => true, :combine => true}).raises(Puppet::ExecutionFailure, 'boom')
       expect(subject.read_plist_file(plist_path)).to eq(nil)
     end
@@ -110,7 +110,7 @@ describe Puppet::Util::Plist, :if => Puppet.features.cfpropertylist? do
       subject.stubs(:open_file_with_args).with(plist_path, 'r:UTF-8').returns(binary_data)
       Puppet.expects(:debug).with(regexp_matches(/^Failed with (CFFormatError|ArgumentError)/))
       Puppet.expects(:debug).with("Plist #{plist_path} ill-formatted, converting with plutil")
-      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '-', plist_path],
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '/dev/stdout', plist_path],
                                                      {:failonfail => true, :combine => true}).raises(Puppet::ExecutionFailure, 'boom')
       expect(subject.read_plist_file(plist_path)).to eq(nil)
     end

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

@@ -106,14 +106,14 @@ 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::SID.expects(:name_to_principal).with(username).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::SID.expects(:name_to_principal).with("#{domain}\\#{username}").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
@@ -213,7 +213,7 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
       end
 
       it "should generate the correct URI" do
-        Puppet::Util::Windows::SID.stubs(:octet_string_to_principal).returns(sid)
+        Puppet::Util::Windows::SID.stubs(:octet_string_to_sid_object).returns(sid)
         expect(user.uri).to eq("WinNT://testcomputername/#{username},user")
       end
 
@@ -276,8 +276,8 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
       let(:someone_sid){ stub(:account => 'someone', :domain => 'testcomputername')}
 
       describe "should be able to use SID objects" do
-        let(:system)     { Puppet::Util::Windows::SID.name_to_principal('SYSTEM') }
-        let(:invalid)    { Puppet::Util::Windows::SID.name_to_principal('foobar') }
+        let(:system)     { Puppet::Util::Windows::SID.name_to_sid_object('SYSTEM') }
+        let(:invalid)    { Puppet::Util::Windows::SID.name_to_sid_object('foobar') }
 
         it "to add a member" do
           adsi_group.expects(:Add).with("WinNT://S-1-5-18")
@@ -303,14 +303,11 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
       it "should provide its groups as a list of names" do
         names = ['user1', 'user2']
 
-        users = names.map { |name| stub('user', :Name => name, :objectSID => name, :ole_respond_to? => true) }
+        users = names.map { |name| stub('user', :Name => name) }
 
         adsi_group.expects(:Members).returns(users)
 
-        Puppet::Util::Windows::SID.expects(:octet_string_to_principal).with('user1').returns(stub(:domain_account => 'HOSTNAME\user1'))
-        Puppet::Util::Windows::SID.expects(:octet_string_to_principal).with('user2').returns(stub(:domain_account => 'HOSTNAME\user2'))
-
-        expect(group.members.map(&:domain_account)).to match(['HOSTNAME\user1', 'HOSTNAME\user2'])
+        expect(group.members).to match(names)
       end
 
       context "calling .set_members" do
@@ -323,16 +320,16 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
           ]
 
           # use stubbed objectSid on member to return stubbed SID
-          Puppet::Util::Windows::SID.expects(:octet_string_to_principal).with([0]).returns(sids[0])
-          Puppet::Util::Windows::SID.expects(:octet_string_to_principal).with([1]).returns(sids[1])
+          Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([0]).returns(sids[0])
+          Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([1]).returns(sids[1])
 
-          Puppet::Util::Windows::SID.expects(:name_to_principal).with('user2').returns(sids[1])
-          Puppet::Util::Windows::SID.expects(:name_to_principal).with('DOMAIN2\user3').returns(sids[2])
+          Puppet::Util::Windows::SID.expects(:name_to_sid_object).with('user2').returns(sids[1])
+          Puppet::Util::Windows::SID.expects(:name_to_sid_object).with('DOMAIN2\user3').returns(sids[2])
 
           Puppet::Util::Windows::ADSI.expects(:sid_uri).with(sids[0]).returns("WinNT://DOMAIN/user1,user")
           Puppet::Util::Windows::ADSI.expects(:sid_uri).with(sids[2]).returns("WinNT://DOMAIN2/user3,user")
 
-          members = names.each_with_index.map{|n,i| stub(:Name => n, :objectSID => [i], :ole_respond_to? => true)}
+          members = names.each_with_index.map{|n,i| stub(:Name => n, :objectSID => [i])}
           adsi_group.expects(:Members).returns members
 
           adsi_group.expects(:Remove).with('WinNT://DOMAIN/user1,user')
@@ -350,15 +347,15 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
           ]
 
           # use stubbed objectSid on member to return stubbed SID
-          Puppet::Util::Windows::SID.expects(:octet_string_to_principal).with([0]).returns(sids[0])
-          Puppet::Util::Windows::SID.expects(:octet_string_to_principal).with([1]).returns(sids[1])
+          Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([0]).returns(sids[0])
+          Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([1]).returns(sids[1])
 
-          Puppet::Util::Windows::SID.expects(:name_to_principal).with('user2').returns(sids[1])
-          Puppet::Util::Windows::SID.expects(:name_to_principal).with('DOMAIN2\user3').returns(sids[2])
+          Puppet::Util::Windows::SID.expects(:name_to_sid_object).with('user2').returns(sids[1])
+          Puppet::Util::Windows::SID.expects(:name_to_sid_object).with('DOMAIN2\user3').returns(sids[2])
 
           Puppet::Util::Windows::ADSI.expects(:sid_uri).with(sids[2]).returns("WinNT://DOMAIN2/user3,user")
 
-          members = names.each_with_index.map{|n,i| stub(:Name => n, :objectSID => [i], :ole_respond_to? => true)}
+          members = names.each_with_index.map{|n,i| stub(:Name => n, :objectSID => [i])}
           adsi_group.expects(:Members).returns members
 
           adsi_group.expects(:Remove).with('WinNT://DOMAIN/user1,user').never
@@ -385,13 +382,13 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
           ]
 
           # use stubbed objectSid on member to return stubbed SID
-          Puppet::Util::Windows::SID.expects(:octet_string_to_principal).with([0]).returns(sids[0])
-          Puppet::Util::Windows::SID.expects(:octet_string_to_principal).with([1]).returns(sids[1])
+          Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([0]).returns(sids[0])
+          Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([1]).returns(sids[1])
 
           Puppet::Util::Windows::ADSI.expects(:sid_uri).with(sids[0]).returns("WinNT://DOMAIN/user1,user")
           Puppet::Util::Windows::ADSI.expects(:sid_uri).with(sids[1]).returns("WinNT://testcomputername/user2,user")
 
-          members = names.each_with_index.map{|n,i| stub(:Name => n, :objectSID => [i], :ole_respond_to? => true)}
+          members = names.each_with_index.map{|n,i| stub(:Name => n, :objectSID => [i])}
           adsi_group.expects(:Members).returns members
 
           adsi_group.expects(:Remove).with('WinNT://DOMAIN/user1,user')
@@ -407,10 +404,10 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
               stub(:account => 'user2', :domain => 'testcomputername', :sid => 2 ),
           ]
           # use stubbed objectSid on member to return stubbed SID
-          Puppet::Util::Windows::SID.expects(:octet_string_to_principal).with([0]).returns(sids[0])
-          Puppet::Util::Windows::SID.expects(:octet_string_to_principal).with([1]).returns(sids[1])
+          Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([0]).returns(sids[0])
+          Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([1]).returns(sids[1])
 
-          members = names.each_with_index.map{|n,i| stub(:Name => n, :objectSID => [i], :ole_respond_to? => true)}
+          members = names.each_with_index.map{|n,i| stub(:Name => n, :objectSID => [i])}
           adsi_group.expects(:Members).returns members
 
           adsi_group.expects(:Remove).never
@@ -431,7 +428,7 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
         adsi_group.expects(:objectSID).returns([0])
         Socket.expects(:gethostname).returns('TESTcomputerNAME')
         computer_sid = stub(:account => groupname,:domain => 'testcomputername')
-        Puppet::Util::Windows::SID.expects(:octet_string_to_principal).with([0]).returns(computer_sid)
+        Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([0]).returns(computer_sid)
         expect(group.uri).to eq("WinNT://./#{groupname},group")
       end
     end
@@ -461,7 +458,7 @@ 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::SID.expects(:name_to_principal).with(groupname).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')
 
@@ -503,14 +500,13 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
       Puppet::Util::Windows::ADSI.expects(:execquery).with('select name from win32_group where localaccount = "TRUE"').returns(wmi_groups)
 
       native_group = stub('IADsGroup')
-      Puppet::Util::Windows::SID.expects(:octet_string_to_principal).with([]).returns(stub(:domain_account => '.\Administrator'))
-      native_group.expects(:Members).returns([stub(:Name => 'Administrator', :objectSID => [], :ole_respond_to? => true)])
+      native_group.expects(:Members).returns([stub(:Name => 'Administrator')])
       Puppet::Util::Windows::ADSI.expects(:connect).with("WinNT://./#{name},group").returns(native_group)
 
       groups = Puppet::Util::Windows::ADSI::Group.to_a
       expect(groups.length).to eq(1)
       expect(groups[0].name).to eq(name)
-      expect(groups[0].members.map(&:domain_account)).to eq(['.\Administrator'])
+      expect(groups[0].members).to eq(['Administrator'])
     end
   end
 

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

@@ -13,10 +13,10 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
   let(:null_sid)     { 'S-1-0-0' }
   let(:unknown_name) { 'chewbacca' }
 
-  context "#octet_string_to_principal" do
+  context "#octet_string_to_sid_object" do
     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_principal(bytes)
+      converted = subject.octet_string_to_sid_object(bytes)
 
       expect(converted).to be_an_instance_of Puppet::Util::Windows::SID::Principal
       expect(converted.sid_bytes).to eq(bytes)
@@ -28,13 +28,13 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
 
     it "should raise an error for non-array input" do
       expect {
-        subject.octet_string_to_principal(invalid_sid)
+        subject.octet_string_to_sid_object(invalid_sid)
       }.to raise_error(Puppet::Error, /Octet string must be an array of bytes/)
     end
 
     it "should raise an error for an empty byte array" do
       expect {
-        subject.octet_string_to_principal([])
+        subject.octet_string_to_sid_object([])
       }.to raise_error(Puppet::Error, /Octet string must be an array of bytes/)
     end
 
@@ -42,7 +42,7 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
       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_principal(valid_octet_invalid_user)
+        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
@@ -52,7 +52,7 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
     it "should raise an error for a malformed byte array" do
       expect {
         invalid_octet = [2]
-        subject.octet_string_to_principal(invalid_octet)
+        subject.octet_string_to_sid_object(invalid_octet)
       }.to raise_error do |error|
         expect(error).to be_a(Puppet::Util::Windows::Error)
         expect(error.code).to eq(87) # ERROR_INVALID_PARAMETER
@@ -72,12 +72,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_principal).with('testers').returns stub(:sid => '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_principal).with('MACHINE\testers').returns stub(:sid => '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
 
@@ -128,108 +128,37 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
     end
   end
 
-  context "#name_to_principal" do
+  context "#name_to_sid_object" do
     it "should return nil if the account does not exist" do
-      expect(subject.name_to_principal(unknown_name)).to be_nil
+      expect(subject.name_to_sid_object(unknown_name)).to be_nil
     end
 
     it "should return a Puppet::Util::Windows::SID::Principal instance for any valid sid" do
-      expect(subject.name_to_principal(sid)).to be_an_instance_of(Puppet::Util::Windows::SID::Principal)
+      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
       # 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_principal('SYSTEM').sid).to eq(sid)
+      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_principal('SYSTEM')).to eq(subject.name_to_principal('system'))
+      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_principal('SYSTEM')).to eq(subject.name_to_principal(' SYSTEM '))
+      expect(subject.name_to_sid_object('SYSTEM')).to eq(subject.name_to_sid_object(' SYSTEM '))
     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_principal('NT AUTHORITY\SYSTEM').sid).to eq(sid)
-    end
-  end
-
-  context "#ads_to_principal" do
-    it "should raise an error for non-WIN32OLE input" do
-      expect {
-        subject.ads_to_principal(stub('WIN32OLE', { :Name => 'foo' }))
-      }.to raise_error(Puppet::Error, /ads_object must be an IAdsUser or IAdsGroup instance/)
-    end
-
-    it "should raise an error for an empty byte array in the objectSID property" do
-      expect {
-        subject.ads_to_principal(stub('WIN32OLE', { :objectSID => [], :Name => '', :ole_respond_to? => true }))
-      }.to raise_error(Puppet::Error, /Octet string must be an array of bytes/)
-    end
-
-    it "should raise an error for a malformed byte array" do
-      expect {
-        invalid_octet = [2]
-        subject.ads_to_principal(stub('WIN32OLE', { :objectSID => invalid_octet, :Name => '', :ole_respond_to? => true }))
-      }.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
-
-    it "should raise an error when a valid byte array for SID is unresolvable and its Name does not match" do
-      expect {
-        # S-1-1-1 is a valid SID that will not resolve
-        valid_octet_invalid_user = [1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0]
-        subject.ads_to_principal(stub('WIN32OLE', { :objectSID => valid_octet_invalid_user, :Name => unknown_name, :ole_respond_to? => true }))
-      }.to raise_error do |error|
-        expect(error).to be_a(Puppet::Error)
-        expect(error.cause.code).to eq(1332) # ERROR_NONE_MAPPED
-      end
-    end
-
-    it "should return a Principal object even when the SID is unresolvable, as long as the Name matches" do
-      # S-1-1-1 is a valid SID that will not resolve
-      valid_octet_invalid_user = [1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0]
-      unresolvable_user = stub('WIN32OLE', { :objectSID => valid_octet_invalid_user, :Name => 'S-1-1-1', :ole_respond_to? => true })
-      principal = subject.ads_to_principal(unresolvable_user)
-
-      expect(principal).to be_an_instance_of(Puppet::Util::Windows::SID::Principal)
-      expect(principal.account).to eq('S-1-1-1 (unresolvable)')
-      expect(principal.domain).to eq(nil)
-      expect(principal.domain_account).to eq('S-1-1-1 (unresolvable)')
-      expect(principal.sid).to eq('S-1-1-1')
-      expect(principal.sid_bytes).to eq(valid_octet_invalid_user)
-      expect(principal.account_type).to eq(:SidTypeUnknown)
-    end
-
-    it "should return a Puppet::Util::Windows::SID::Principal instance for any valid sid" do
-      system_bytes = [1, 1, 0, 0, 0, 0, 0, 5, 18, 0, 0, 0]
-      adsuser = stub('WIN32OLE', { :objectSID => system_bytes, :Name => 'SYSTEM', :ole_respond_to? => true })
-      expect(subject.ads_to_principal(adsuser)).to be_an_instance_of(Puppet::Util::Windows::SID::Principal)
-    end
-
-    it "should properly convert an array of bytes for a well-known non-localized SID, ignoring the Name from the WIN32OLE object" do
-      bytes = [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-      adsuser = stub('WIN32OLE', { :objectSID => bytes, :Name => unknown_name, :ole_respond_to? => true })
-      converted = subject.ads_to_principal(adsuser)
-
-      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')
-      # garbage name supplied does not carry forward as SID is looked up again
-      expect(converted.account).to_not eq(adsuser.Name)
+      expect(subject.name_to_sid_object('NT AUTHORITY\SYSTEM').sid).to eq(sid)
     end
   end