puppet 7.27.0-universal-darwin → 7.29.0-universal-darwin

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

@@ -1,184 +0,0 @@
-# encoding: UTF-8
-
-require 'spec_helper'
-
-describe "FFI::MemoryPointer", :if => Puppet::Util::Platform.windows? do
-  # use 2 bad bytes at end so we have even number of bytes / characters
-  let(:bad_string) { "hello invalid world".encode(Encoding::UTF_16LE) + "\xDD\xDD".force_encoding(Encoding::UTF_16LE) }
-  let(:bad_string_bytes) { bad_string.bytes.to_a }
-  let(:a_wide_bytes) { "A".encode(Encoding::UTF_16LE).bytes.to_a }
-  let(:b_wide_bytes) { "B".encode(Encoding::UTF_16LE).bytes.to_a }
-
-  context "read_wide_string" do
-    let (:string) { "foo_bar" }
-
-    it "should properly roundtrip a given string" do
-      FFI::MemoryPointer.from_string_to_wide_string(string) do |ptr|
-        expect(ptr.read_wide_string(string.length)).to eq(string)
-      end
-    end
-
-    it "should return a given string in UTF-8" do
-      FFI::MemoryPointer.from_string_to_wide_string(string) do |ptr|
-        read_string = ptr.read_wide_string(string.length)
-        expect(read_string.encoding).to eq(Encoding::UTF_8)
-      end
-    end
-
-    it "should raise an error and emit a debug message when receiving a string containing invalid bytes in the destination encoding" do
-      Puppet[:log_level] = 'debug'
-
-      expect {
-        FFI::MemoryPointer.new(:byte, bad_string_bytes.count) do |ptr|
-          # uchar here is synonymous with byte
-          ptr.put_array_of_uchar(0, bad_string_bytes)
-
-          ptr.read_wide_string(bad_string.length)
-        end
-      }.to raise_error(Encoding::InvalidByteSequenceError)
-
-      expect(@logs.last.message).to eq("Unable to convert value #{bad_string.dump} to encoding UTF-8 due to #<Encoding::InvalidByteSequenceError: \"\\xDD\\xDD\" on UTF-16LE>")
-    end
-
-    it "should not raise an error when receiving a string containing invalid bytes in the destination encoding, when specifying :invalid => :replace" do
-      FFI::MemoryPointer.new(:byte, bad_string_bytes.count) do |ptr|
-        # uchar here is synonymous with byte
-        ptr.put_array_of_uchar(0, bad_string_bytes)
-
-        read_string = ptr.read_wide_string(bad_string.length, Encoding::UTF_8, false, :invalid => :replace)
-        expect(read_string).to eq("hello invalid world\uFFFD")
-      end
-    end
-
-    it "raises an IndexError if asked to read more characters than there are bytes allocated" do
-      expect {
-        FFI::MemoryPointer.new(:byte, 1) do |ptr|
-          ptr.read_wide_string(1) # 1 wchar = 2 bytes
-        end
-      }.to raise_error(IndexError, /out of bounds/)
-    end
-
-    it "raises an IndexError if asked to read a negative number of characters" do
-      expect {
-        FFI::MemoryPointer.new(:byte, 1) do |ptr|
-          ptr.read_wide_string(-1)
-        end
-      }.to raise_error(IndexError, /out of bounds/)
-    end
-
-    it "returns an empty string if asked to read 0 characters" do
-      FFI::MemoryPointer.new(:byte, 1) do |ptr|
-        expect(ptr.read_wide_string(0)).to eq("")
-      end
-    end
-
-    it "returns a substring if asked to read fewer characters than are in the byte array" do
-      FFI::MemoryPointer.new(:byte, 4) do |ptr|
-        ptr.write_array_of_uint8("AB".encode('UTF-16LE').bytes.to_a)
-        expect(ptr.read_wide_string(1)).to eq("A")
-      end
-    end
-
-    it "preserves wide null characters in the string" do
-      FFI::MemoryPointer.new(:byte, 6) do |ptr|
-        ptr.write_array_of_uint8(a_wide_bytes + [0, 0] + b_wide_bytes)
-        expect(ptr.read_wide_string(3)).to eq("A\x00B")
-      end
-    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
-      FFI::MemoryPointer.from_string_to_wide_string(single_null_string) do |ptr|
-        expect(ptr.read_arbitrary_wide_string_up_to).to eq(string)
-      end
-    end
-
-    it "should read a short double null terminated string" do
-      FFI::MemoryPointer.from_string_to_wide_string(double_null_string) do |ptr|
-        expect(ptr.read_arbitrary_wide_string_up_to(512, :double_null)).to eq(string)
-      end
-    end
-
-    it "detects trailing single null wchar" do
-      FFI::MemoryPointer.from_string_to_wide_string(single_null_string) do |ptr|
-        expect(ptr).to receive(:read_wide_string).with(string.length, anything, anything, anything).and_call_original
-
-        expect(ptr.read_arbitrary_wide_string_up_to).to eq(string)
-      end
-    end
-
-    it "detects trailing double null wchar" do
-      FFI::MemoryPointer.from_string_to_wide_string(double_null_string) do |ptr|
-        expect(ptr).to receive(:read_wide_string).with(string.length, anything, anything, anything).and_call_original
-
-        expect(ptr.read_arbitrary_wide_string_up_to(512, :double_null)).to eq(string)
-      end
-    end
-
-    it "should raises an IndexError if max_length is negative" do
-      FFI::MemoryPointer.from_string_to_wide_string(single_null_string) do |ptr|
-        expect {
-          ptr.read_arbitrary_wide_string_up_to(-1)
-        }.to raise_error(IndexError, /out of bounds/)
-      end
-    end
-
-    it "should return an empty string when the max_length is 0" do
-      FFI::MemoryPointer.from_string_to_wide_string(single_null_string) do |ptr|
-        expect(ptr.read_arbitrary_wide_string_up_to(0)).to eq("")
-      end
-    end
-
-    it "should return a string of max_length characters when specified" do
-      FFI::MemoryPointer.from_string_to_wide_string(single_null_string) do |ptr|
-        expect(ptr.read_arbitrary_wide_string_up_to(3)).to eq(string[0..2])
-      end
-    end
-
-    it "should return wide strings in UTF-8" do
-      FFI::MemoryPointer.from_string_to_wide_string(string) do |ptr|
-        read_string = ptr.read_arbitrary_wide_string_up_to
-        expect(read_string.encoding).to eq(Encoding::UTF_8)
-      end
-    end
-
-    it "should not raise an error when receiving a string containing invalid bytes in the destination encoding, when specifying :invalid => :replace" do
-      FFI::MemoryPointer.new(:byte, bad_string_bytes.count) do |ptr|
-        # uchar here is synonymous with byte
-        ptr.put_array_of_uchar(0, bad_string_bytes)
-
-        read_string = ptr.read_arbitrary_wide_string_up_to(ptr.size / 2, :single_null, :invalid => :replace)
-        expect(read_string).to eq("hello invalid world\uFFFD")
-      end
-    end
-
-    it "should raise an IndexError if there isn't a null terminator" do
-      # This only works when using a memory pointer with a known number of cells
-      # and size per cell, but not arbitrary Pointers
-      FFI::MemoryPointer.new(:wchar, 1) do |ptr|
-        ptr.write_array_of_uint8(a_wide_bytes)
-
-        expect {
-          ptr.read_arbitrary_wide_string_up_to(42)
-        }.to raise_error(IndexError, /out of bounds/)
-      end
-    end
-
-    it "should raise an IndexError if there isn't a double null terminator" do
-      # This only works when using a memory pointer with a known number of cells
-      # and size per cell, but not arbitrary Pointers
-      FFI::MemoryPointer.new(:wchar, 1) do |ptr|
-        ptr.write_array_of_uint8(a_wide_bytes)
-
-        expect {
-          ptr.read_arbitrary_wide_string_up_to(42, :double_null)
-        }.to raise_error(IndexError, /out of bounds/)
-      end
-    end
-  end
-end

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

@@ -1,120 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/util/windows'
-
-describe Puppet::Util::Windows::EventLog, :if => Puppet::Util::Platform.windows? do
-
-  before(:each) { @event_log = Puppet::Util::Windows::EventLog.new }
-  after(:each) { @event_log.close }
-
-  describe "class constants" do
-    it "should define NULL_HANDLE as 0" do
-      expect(Puppet::Util::Windows::EventLog::NULL_HANDLE).to eq(0)
-    end
-
-    it "should define WIN32_FALSE as 0" do
-      expect(Puppet::Util::Windows::EventLog::WIN32_FALSE).to eq(0)
-    end
-  end
-
-  describe "self.open" do
-    it "sets a handle to the event log" do
-      default_name = Puppet::Util::Windows::String.wide_string('Puppet')
-      # return nil explicitly just to reinforce that we're not leaking eventlog handle
-      expect_any_instance_of(Puppet::Util::Windows::EventLog).to receive(:RegisterEventSourceW).with(anything, default_name).and_return(nil)
-      Puppet::Util::Windows::EventLog.new
-    end
-
-    context "when it fails to open the event log" do
-      before do
-        # RegisterEventSourceW will return NULL on failure
-        # Stubbing prevents leaking eventlog handle
-        allow_any_instance_of(Puppet::Util::Windows::EventLog).to receive(:RegisterEventSourceW).and_return(Puppet::Util::Windows::EventLog::NULL_HANDLE)
-      end
-
-      it "raises an exception warning that the event log failed to open" do
-        expect { Puppet::Util::Windows::EventLog.open('foo') }.to raise_error(Puppet::Util::Windows::EventLog::EventLogError, /failed to open Windows eventlog/)
-      end
-
-      it "passes the exit code to the exception constructor" do
-        fake_error = Puppet::Util::Windows::EventLog::EventLogError.new('foo', 87)
-        allow(FFI).to receive(:errno).and_return(87)
-        # All we're testing here is that the constructor actually receives the exit code from FFI.errno (87)
-        # We do so because `expect to...raise_error` doesn't support multiple parameter match arguments
-        # We return fake_error just because `raise` expects an exception class
-        expect(Puppet::Util::Windows::EventLog::EventLogError).to receive(:new).with(/failed to open Windows eventlog/, 87).and_return(fake_error)
-        expect { Puppet::Util::Windows::EventLog.open('foo') }.to raise_error(Puppet::Util::Windows::EventLog::EventLogError)
-      end
-    end
-  end
-
-  describe "#close" do
-    it "closes the handle to the event log" do
-      @handle = "12345"
-      allow_any_instance_of(Puppet::Util::Windows::EventLog).to receive(:RegisterEventSourceW).and_return(@handle)
-      event_log = Puppet::Util::Windows::EventLog.new
-      expect(event_log).to receive(:DeregisterEventSource).with(@handle).and_return(1)
-      event_log.close
-    end
-  end
-
-  describe "#report_event" do
-    it "raises an exception if the message passed is not a string" do
-      expect { @event_log.report_event(:data => 123, :event_type => nil, :event_id => nil) }.to raise_error(ArgumentError, /data must be a string/)
-    end
-
-    context "when an event report fails" do
-      before do
-        # ReportEventW returns 0 on failure, which is mapped to WIN32_FALSE
-        allow(@event_log).to receive(:ReportEventW).and_return(Puppet::Util::Windows::EventLog::WIN32_FALSE)
-      end
-
-      it "raises an exception warning that the event report failed" do
-        expect { @event_log.report_event(:data => 'foo', :event_type => Puppet::Util::Windows::EventLog::EVENTLOG_ERROR_TYPE, :event_id => 0x03) }.to raise_error(Puppet::Util::Windows::EventLog::EventLogError, /failed to report event/)
-      end
-
-      it "passes the exit code to the exception constructor" do
-        fake_error = Puppet::Util::Windows::EventLog::EventLogError.new('foo', 5)
-        allow(FFI).to receive(:errno).and_return(5)
-        # All we're testing here is that the constructor actually receives the exit code from FFI.errno (5)
-        # We do so because `expect to...raise_error` doesn't support multiple parameter match arguments
-        # We return fake_error just because `raise` expects an exception class
-        expect(Puppet::Util::Windows::EventLog::EventLogError).to receive(:new).with(/failed to report event/, 5).and_return(fake_error)
-        expect { @event_log.report_event(:data => 'foo', :event_type => Puppet::Util::Windows::EventLog::EVENTLOG_ERROR_TYPE, :event_id => 0x03) }.to raise_error(Puppet::Util::Windows::EventLog::EventLogError)
-      end
-    end
-  end
-
-  describe "self.to_native" do
-    it "raises an exception if the log level is not supported" do
-      expect { Puppet::Util::Windows::EventLog.to_native(:foo) }.to raise_error(ArgumentError)
-    end
-
-    # This is effectively duplicating the data assigned to the constants in
-    # Puppet::Util::Windows::EventLog but since these are public constants we
-    # ensure their values don't change lightly.
-    log_levels_to_type_and_id = {
-      :debug    => [0x0004, 0x01],
-      :info     => [0x0004, 0x01],
-      :notice   => [0x0004, 0x01],
-      :warning  => [0x0002, 0x02],
-      :err      => [0x0001, 0x03],
-      :alert    => [0x0001, 0x03],
-      :emerg    => [0x0001, 0x03],
-      :crit     => [0x0001, 0x03],
-    }
-
-    shared_examples_for "#to_native" do |level|
-      it "should return the correct INFORMATION_TYPE and ID" do
-        result = Puppet::Util::Windows::EventLog.to_native(level)
-        expect(result).to eq(log_levels_to_type_and_id[level])
-      end
-    end
-
-    log_levels_to_type_and_id.each_key do |level|
-      describe "logging at #{level}" do
-        it_should_behave_like "#to_native", level
-      end
-    end
-  end
-end

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

@@ -1,88 +0,0 @@
-require 'spec_helper'
-require 'puppet/util/windows'
-
-describe Puppet::Util::Windows::File, :if => Puppet::Util::Platform.windows? do
-  include PuppetSpec::Files
-
-  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
-    it "should raise an error for files that do not exist by default" do
-      expect {
-        described_class.get_attributes(nonexist_file)
-      }.to raise_error(Puppet::Error, /GetFileAttributes/)
-    end
-
-    it "should raise an error for files that do not exist when specified" do
-      expect {
-        described_class.get_attributes(nonexist_file, true)
-      }.to raise_error(Puppet::Error, /GetFileAttributes/)
-    end
-
-    it "should not raise an error for files that do not exist when specified" do
-      expect {
-        described_class.get_attributes(nonexist_file, false)
-      }.not_to raise_error
-    end
-
-    it "should return INVALID_FILE_ATTRIBUTES for files that do not exist when specified" 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/root_certs_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-require 'puppet/util/windows'
-
-describe "Puppet::Util::Windows::RootCerts", :if => Puppet::Util::Platform.windows? do
-  let(:x509_store) { Puppet::Util::Windows::RootCerts.instance.to_a }
-
-  it "should return at least one X509 certificate" do
-    expect(x509_store.to_a.size).to be >= 1
-  end
-
-  it "should return an X509 certificate with a subject" do
-    x509 = x509_store.first
-
-    expect(x509.subject.to_utf8).to match(/CN=.*/)
-  end
-end

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

@@ -1,115 +0,0 @@
-require 'spec_helper'
-require 'puppet/util/windows'
-
-describe "Puppet::Util::Windows::SecurityDescriptor", :if => Puppet::Util::Platform.windows? do
-  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
-    Puppet::Util::Windows::AccessControlList.new
-  end
-
-  def system_ace_dacl
-    dacl = Puppet::Util::Windows::AccessControlList.new
-    dacl.allow(system_sid, 0x1)
-    dacl
-  end
-
-  context "owner" do
-    it "changes the owner" do
-      sd = Puppet::Util::Windows::SecurityDescriptor.new(system_sid, group_sid, system_ace_dacl)
-      sd.owner = new_sid
-
-      expect(sd.owner).to eq(new_sid)
-    end
-
-    it "performs a noop if the new owner is the same as the old one" do
-      dacl = system_ace_dacl
-      sd = Puppet::Util::Windows::SecurityDescriptor.new(system_sid, group_sid, dacl)
-      sd.owner = sd.owner
-
-      expect(sd.dacl.object_id).to eq(dacl.object_id)
-    end
-
-    it "prepends SYSTEM when security descriptor owner is no longer SYSTEM" do
-      sd = Puppet::Util::Windows::SecurityDescriptor.new(system_sid, group_sid, system_ace_dacl)
-      sd.owner = new_sid
-
-      aces = sd.dacl.to_a
-      expect(aces.size).to eq(2)
-      expect(aces[0].sid).to eq(system_sid)
-      expect(aces[1].sid).to eq(new_sid)
-    end
-
-    it "does not prepend SYSTEM when DACL already contains inherited SYSTEM ace" do
-      sd = Puppet::Util::Windows::SecurityDescriptor.new(admins_sid, system_sid, empty_dacl)
-      sd.dacl.allow(admins_sid, 0x1)
-      sd.dacl.allow(system_sid, 0x1, Puppet::Util::Windows::AccessControlEntry::INHERITED_ACE)
-      sd.owner = new_sid
-
-      aces = sd.dacl.to_a
-      expect(aces.size).to eq(2)
-      expect(aces[0].sid).to eq(new_sid)
-    end
-
-    it "does not prepend SYSTEM when security descriptor owner wasn't SYSTEM" do
-      sd = Puppet::Util::Windows::SecurityDescriptor.new(group_sid, group_sid, empty_dacl)
-      sd.dacl.allow(group_sid, 0x1)
-      sd.owner = new_sid
-
-      aces = sd.dacl.to_a
-      expect(aces.size).to eq(1)
-      expect(aces[0].sid).to eq(new_sid)
-    end
-  end
-
-  context "group" do
-    it "changes the group" do
-      sd = Puppet::Util::Windows::SecurityDescriptor.new(system_sid, group_sid, system_ace_dacl)
-      sd.group = new_sid
-
-      expect(sd.group).to eq(new_sid)
-    end
-
-    it "performs a noop if the new group is the same as the old one" do
-      dacl = system_ace_dacl
-      sd = Puppet::Util::Windows::SecurityDescriptor.new(system_sid, group_sid, dacl)
-      sd.group = sd.group
-
-      expect(sd.dacl.object_id).to eq(dacl.object_id)
-    end
-
-    it "prepends SYSTEM when security descriptor group is no longer SYSTEM" do
-      sd = Puppet::Util::Windows::SecurityDescriptor.new(new_sid, system_sid, system_ace_dacl)
-      sd.group = new_sid
-
-      aces = sd.dacl.to_a
-      expect(aces.size).to eq(2)
-      expect(aces[0].sid).to eq(system_sid)
-      expect(aces[1].sid).to eq(new_sid)
-    end
-
-    it "does not prepend SYSTEM when DACL already contains inherited SYSTEM ace" do
-      sd = Puppet::Util::Windows::SecurityDescriptor.new(admins_sid, admins_sid, empty_dacl)
-      sd.dacl.allow(admins_sid, 0x1)
-      sd.dacl.allow(system_sid, 0x1, Puppet::Util::Windows::AccessControlEntry::INHERITED_ACE)
-      sd.group = new_sid
-
-      aces = sd.dacl.to_a
-      expect(aces.size).to eq(2)
-      expect(aces[0].sid).to eq(new_sid)
-    end
-
-    it "does not prepend SYSTEM when security descriptor group wasn't SYSTEM" do
-      sd = Puppet::Util::Windows::SecurityDescriptor.new(group_sid, group_sid, empty_dacl)
-      sd.dacl.allow(group_sid, 0x1)
-      sd.group = new_sid
-
-      aces = sd.dacl.to_a
-      expect(aces.size).to eq(1)
-      expect(aces[0].sid).to eq(new_sid)
-    end
-  end
-end