puppet 4.5.3-universal-darwin → 4.6.1-universal-darwin

data/spec/unit/type/file_spec.rb

@@ -342,6 +342,18 @@ describe Puppet::Type.type(:file) do
       expect(file[:path]).to eq(title)
     end
 
+    it "should allow a single slash for a title and create the path" do
+      title = File.expand_path("/")
+      file = described_class.new(:title => title)
+      expect(file[:path]).to eq(title)
+    end
+
+    it "should allow multiple slashes for a title and create the path" do
+      title = File.expand_path("/") + "//"
+      file = described_class.new(:title => title)
+      expect(file[:path]).to eq(File.expand_path("/"))
+    end
+
     it "should set a desired 'ensure' value if none is set and 'content' is set" do
       file = described_class.new(:path => path, :content => "/foo/bar")
       expect(file[:ensure]).to eq(:file)
@@ -351,6 +363,22 @@ describe Puppet::Type.type(:file) do
       file = described_class.new(:path => path, :target => File.expand_path(__FILE__))
       expect(file[:ensure]).to eq(:link)
     end
+
+    describe "marking parameters as sensitive" do
+      it "marks sensitive, content, and ensure as sensitive when source is sensitive" do
+        resource = Puppet::Resource.new(:file, make_absolute("/tmp/foo"), :parameters => {:source => make_absolute('/tmp/bar')}, :sensitive_parameters => [:source])
+        file = described_class.new(resource)
+        expect(file.parameter(:source).sensitive).to eq true
+        expect(file.property(:content).sensitive).to eq true
+        expect(file.property(:ensure).sensitive).to eq true
+      end
+
+      it "marks ensure as sensitive when content is sensitive" do
+        resource = Puppet::Resource.new(:file, make_absolute("/tmp/foo"), :parameters => {:content => 'hello world!'}, :sensitive_parameters => [:content])
+        file = described_class.new(resource)
+        expect(file.property(:ensure).sensitive).to eq true
+      end
+    end
   end
 
   describe "#mark_children_for_purging" do

data/spec/unit/type/mount_spec.rb

@@ -577,9 +577,10 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
     let(:var_file) { create_file_resource('/var') }
     let(:log_file) { create_file_resource('/var/log') }
     let(:puppet_file) { create_file_resource('/var/log/puppet') }
+    let(:opt_file) { create_file_resource('/opt/var/puppet') }
 
     before do
-      create_catalog(root_mount, var_mount, log_mount, var_file, log_file, puppet_file)
+      create_catalog(root_mount, var_mount, log_mount, var_file, log_file, puppet_file, opt_file)
     end
 
     it "adds no autorequires for the root mount" do
@@ -588,32 +589,24 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
 
     it "adds the parent autorequire and the file autorequire for a mount with one parent" do
       parent_relationship = var_mount.autorequire[0]
-      file_relationship = var_mount.autorequire[1]
 
-      expect(var_mount.autorequire).to have_exactly(2).items
+      expect(var_mount.autorequire).to have_exactly(1).item
 
       expect(parent_relationship.source).to eq root_mount
       expect(parent_relationship.target).to eq var_mount
-
-      expect(file_relationship.source).to eq var_file
-      expect(file_relationship.target).to eq var_mount
     end
 
     it "adds both parent autorequires and the file autorequire for a mount with two parents" do
       grandparent_relationship = log_mount.autorequire[0]
       parent_relationship = log_mount.autorequire[1]
-      file_relationship = log_mount.autorequire[2]
 
-      expect(log_mount.autorequire).to have_exactly(3).items
+      expect(log_mount.autorequire).to have_exactly(2).items
 
       expect(grandparent_relationship.source).to eq root_mount
       expect(grandparent_relationship.target).to eq log_mount
 
       expect(parent_relationship.source).to eq var_mount
       expect(parent_relationship.target).to eq log_mount
-
-      expect(file_relationship.source).to eq log_file
-      expect(file_relationship.target).to eq log_mount
     end
 
     it "adds the child autobefore for a mount with one file child" do
@@ -625,7 +618,7 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
       expect(child_relationship.target).to eq puppet_file
     end
 
-    it "adds both child autobefores for a mount with two file childs" do
+    it "adds both child autobefores for a mount with two file children" do
       child_relationship = var_mount.autobefore[0]
       grandchild_relationship = var_mount.autobefore[1]
 

data/spec/unit/type/yumrepo_spec.rb

@@ -42,13 +42,9 @@ shared_examples_for "a yumrepo parameter that expects a natural value" do |param
 end
 
 shared_examples_for "a yumrepo parameter that expects a boolean parameter" do |param|
-  valid_values = %w[True False 0 1 No Yes]
+  valid_values = %w[true false 0 1 no yes]
 
   valid_values.each do |value|
-    it "accepts a valid value of #{value}" do
-      instance = described_class.new(:name => 'puppetlabs', param => value)
-      expect(instance[param]).to eq value
-    end
     it "accepts #{value} downcased to #{value.downcase} and capitalizes it" do
       instance = described_class.new(:name => 'puppetlabs', param => value.downcase)
       expect(instance[param]).to eq value.downcase.capitalize

data/spec/unit/type_spec.rb

@@ -556,6 +556,38 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
         expect(params[:fstype]).to eq("boo")
         expect(params[:atboot]).to eq(:yes)
       end
+
+      it "copies sensitive parameters to the appropriate properties" do
+        resource = Puppet::Resource.new(:mount, "/foo",
+                                        :parameters => {:atboot => :yes, :fstype => "boo"},
+                                        :sensitive_parameters => [:fstype])
+        type = Puppet::Type.type(:mount).new(resource)
+        expect(type.property(:fstype).sensitive).to eq true
+      end
+
+      it "logs a warning when a parameter is marked as sensitive" do
+        resource = Puppet::Resource.new(:mount, "/foo",
+                                        :parameters => {:atboot => :yes, :fstype => "boo", :remounts => true},
+                                        :sensitive_parameters => [:remounts])
+        Puppet::Type.type(:mount).any_instance.expects(:warning).with(regexp_matches(/Unable to mark 'remounts' as sensitive: remounts is a parameter and not a property/))
+        Puppet::Type.type(:mount).new(resource)
+      end
+
+      it "logs a warning when a property is not set but is marked as sensitive" do
+        resource = Puppet::Resource.new(:mount, "/foo",
+                                        :parameters => {:atboot => :yes, :fstype => "boo"},
+                                        :sensitive_parameters => [:device])
+        Puppet::Type.type(:mount).any_instance.expects(:warning).with("Unable to mark 'device' as sensitive: the property itself was not assigned a value.")
+        Puppet::Type.type(:mount).new(resource)
+      end
+
+      it "logs an error when a property is not defined on the type but is marked as sensitive" do
+        resource = Puppet::Resource.new(:mount, "/foo",
+                                        :parameters => {:atboot => :yes, :fstype => "boo"},
+                                        :sensitive_parameters => [:content])
+        Puppet::Type.type(:mount).any_instance.expects(:err).with("Unable to mark 'content' as sensitive: the property itself is not defined on mount.")
+        Puppet::Type.type(:mount).new(resource)
+      end
     end
 
     describe "and passed a Hash" do

data/spec/unit/util/command_line_spec.rb

@@ -66,6 +66,17 @@ describe Puppet::Util::CommandLine do
         end.to have_printed(/^#{Regexp.escape(Puppet.version)}$/)
       end
     end
+
+    %w{--help -h}.each do|arg|
+      it "should print help" do
+        commandline = Puppet::Util::CommandLine.new("puppet", [arg])
+        commandline.expects(:exec).never
+
+        expect {
+          commandline.execute
+        }.to have_printed(/Usage: puppet <subcommand> \[options\] <action> \[options\]/).and_exit_with(0)
+      end
+    end
   end
 
   describe "when dealing with puppet commands" do

data/spec/unit/util/execution_spec.rb

@@ -311,7 +311,7 @@ describe Puppet::Util::Execution do
 
           Puppet::Util::Execution.stubs(:execute_windows).returns(proc_info_stub)
           stub_process_wait(real_exit_status)
-          $CHILD_STATUS.stubs(:exitstatus).returns(real_exit_status % 256) # The exitstatus is changed to be mod 256 so that ruby can fit it into 8 bits.
+          Puppet::Util::Execution.stubs(:exitstatus).returns(real_exit_status % 256) # The exitstatus is changed to be mod 256 so that ruby can fit it into 8 bits.
 
           expect(Puppet::Util::Execution.execute('test command', :failonfail => false).exitstatus).to eq(real_exit_status)
         end

data/spec/unit/util/plist_spec.rb

@@ -1,9 +1,7 @@
 require 'spec_helper'
-require 'puppet/util/plist' if Puppet.features.cfpropertylist?
+require 'puppet/util/plist'
 require 'puppet_spec/files'
 
-module Puppet::Util::Plist; end
-
 describe Puppet::Util::Plist, :if => Puppet.features.cfpropertylist? do
   include PuppetSpec::Files
 
@@ -54,6 +52,12 @@ describe Puppet::Util::Plist, :if => Puppet.features.cfpropertylist? do
     </dict>
     </plist>'
   end
+  let(:non_plist_data) do
+    "Take my love, take my land
+     Take me where I cannot stand
+     I don't care, I'm still free
+     You can't take the sky from me."
+   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' }
@@ -89,6 +93,15 @@ describe Puppet::Util::Plist, :if => Puppet.features.cfpropertylist? do
                                                      {:failonfail => true, :combine => true}).returns(valid_xml_plist)
       expect(subject.read_plist_file(plist_path)).to eq(valid_xml_plist_hash)
     end
+    it "returns nil when direct parsing and plutil conversion both fail" 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(non_plist_data)
+      Puppet.expects(:debug).with(regexp_matches(/^Failed with 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', '/dev/stdout', plist_path],
+                                                     {:failonfail => true, :combine => true}).raises(Puppet::ExecutionFailure, 'boom')
+      expect(subject.read_plist_file(plist_path)).to eq(nil)
+    end
   end
 
   describe "#parse_plist" do

data/spec/unit/util/storage_spec.rb

@@ -189,7 +189,10 @@ describe Puppet::Util::Storage do
       Puppet::Util::Storage.cache(:yayness)
 
       if Puppet.features.microsoft_windows?
-        expect { Puppet::Util::Storage.store }.to raise_error(Puppet::Util::Windows::Error, /Access is denied/)
+        expect { Puppet::Util::Storage.store }.to raise_error do |error|
+          expect(error).to be_a(Puppet::Util::Windows::Error)
+          expect(error.code).to eq(5) # ERROR_ACCESS_DENIED
+        end
       else
         expect { Puppet::Util::Storage.store }.to raise_error(Errno::EISDIR, /Is a directory/)
       end

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

@@ -6,6 +6,10 @@ require 'puppet/util/windows'
 
 describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows? do
   let(:connection) { stub 'connection' }
+  let(:builtin_localized) { Puppet::Util::Windows::SID.sid_to_name('S-1-5-32') }
+  # SYSTEM is special as English can retrieve it via Windows API
+  # but will return localized names
+  let(:ntauthority_localized) { Puppet::Util::Windows::SID::Principal.lookup_account_name('SYSTEM').domain }
 
   before(:each) do
     Puppet::Util::Windows::ADSI.instance_variable_set(:@computer_name, 'testcomputername')
@@ -67,6 +71,14 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
       expect(Puppet::Util::Windows::ADSI::User.uri(username, domain)).to eq("WinNT://#{domain}/#{username},user")
     end
 
+    it "should generate the correct URI for a BUILTIN user" do
+      expect(Puppet::Util::Windows::ADSI::User.uri(username, builtin_localized)).to eq("WinNT://./#{username},user")
+    end
+
+    it "should generate the correct URI for a NT AUTHORITY user" do
+      expect(Puppet::Util::Windows::ADSI::User.uri(username, ntauthority_localized)).to eq("WinNT://./#{username},user")
+    end
+
     it "should be able to parse a username without a domain" do
       expect(Puppet::Util::Windows::ADSI::User.parse_name(username)).to eq([username, '.'])
     end
@@ -414,8 +426,9 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
 
       it "should generate the correct URI" do
         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'))
+        Socket.expects(:gethostname).returns('TESTcomputerNAME')
+        computer_sid = stub(:account => groupname,:domain => 'testcomputername')
+        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
@@ -424,6 +437,14 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
       expect(Puppet::Util::Windows::ADSI::Group.uri("people")).to eq("WinNT://./people,group")
     end
 
+    it "should generate the correct URI for a BUILTIN group" do
+      expect(Puppet::Util::Windows::ADSI::Group.uri(groupname, builtin_localized)).to eq("WinNT://./#{groupname},group")
+    end
+
+    it "should generate the correct URI for a NT AUTHORITY group" do
+      expect(Puppet::Util::Windows::ADSI::Group.uri(groupname, ntauthority_localized)).to eq("WinNT://./#{groupname},group")
+    end
+
     it "should be able to create a group" do
       adsi_group = stub("adsi")
 

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

@@ -5,7 +5,8 @@ require 'puppet/util/windows'
 describe Puppet::Util::Windows::File, :if => Puppet::Util::Platform.windows? do
   include PuppetSpec::Files
 
-  let(:nonexist_file) { 'C:\somefile\that\wont\ever\exist' }
+  let(:nonexist_file) { 'C:\foo.bar' }
+  let(:nonexist_path) { 'C:\somefile\that\wont\ever\exist' }
   let(:invalid_file_attributes) { 0xFFFFFFFF } #define INVALID_FILE_ATTRIBUTES (DWORD (-1))
 
   describe "get_attributes" do
@@ -31,4 +32,58 @@ describe Puppet::Util::Windows::File, :if => Puppet::Util::Platform.windows? do
       expect(described_class.get_attributes(nonexist_file, false)).to eq(invalid_file_attributes)
     end
   end
+
+  describe "get_long_pathname" do
+    it "should raise an ERROR_FILE_NOT_FOUND for a file that does not exist in a valid path" do
+      expect {
+        described_class.get_long_pathname(nonexist_file)
+      }.to raise_error do |error|
+        expect(error).to be_a(Puppet::Util::Windows::Error)
+        expect(error.code).to eq(Puppet::Util::Windows::File::ERROR_FILE_NOT_FOUND)
+      end
+    end
+
+    it "should raise an ERROR_PATH_NOT_FOUND for a path that does not exist" do
+      expect {
+        described_class.get_long_pathname(nonexist_path)
+      }.to raise_error do |error|
+        expect(error).to be_a(Puppet::Util::Windows::Error)
+        expect(error.code).to eq(Puppet::Util::Windows::File::ERROR_PATH_NOT_FOUND)
+      end
+    end
+
+    it "should return the fully expanded path 'Program Files' given 'Progra~1'" do
+      # this test could be resolve some of these values at runtime rather than hard-coding
+      shortened = ENV['SystemDrive'] + '\\Progra~1'
+      expanded = ENV['SystemDrive'] + '\\Program Files'
+      expect(described_class.get_long_pathname(shortened)).to eq (expanded)
+    end
+  end
+
+  describe "get_short_pathname" do
+    it "should raise an ERROR_FILE_NOT_FOUND for a file that does not exist in a valid path" do
+      expect {
+        described_class.get_short_pathname(nonexist_file)
+      }.to raise_error do |error|
+        expect(error).to be_a(Puppet::Util::Windows::Error)
+        expect(error.code).to eq(Puppet::Util::Windows::File::ERROR_FILE_NOT_FOUND)
+      end
+    end
+
+    it "should raise an ERROR_PATH_NOT_FOUND for a path that does not exist" do
+      expect {
+        described_class.get_short_pathname(nonexist_path)
+      }.to raise_error do |error|
+        expect(error).to be_a(Puppet::Util::Windows::Error)
+        expect(error.code).to eq(Puppet::Util::Windows::File::ERROR_PATH_NOT_FOUND)
+      end
+    end
+
+    it "should return the shortened 'PROGRA~1' given fully expanded path 'Program Files'" do
+      # this test could be resolve some of these values at runtime rather than hard-coding
+      expanded = ENV['SystemDrive'] + '\\Program Files'
+      shortened = ENV['SystemDrive'] + '\\PROGRA~1'
+      expect(described_class.get_short_pathname(expanded)).to eq (shortened)
+    end
+  end
 end

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

@@ -10,17 +10,20 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
   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 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 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')
+      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
@@ -40,14 +43,20 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
         # 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./)
+      }.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 = [2]
         subject.octet_string_to_sid_object(invalid_octet)
-      }.to raise_error(Puppet::Util::Windows::Error, /Failed to call LookupAccountSidW:  The parameter is incorrect./)
+      }.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,6 +66,8 @@ 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
 
@@ -79,6 +90,8 @@ 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
 
@@ -125,18 +138,26 @@ 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_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
+      # 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
@@ -147,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