puppet 4.10.12-universal-darwin → 5.0.0-universal-darwin

data/spec/unit/util/run_mode_spec.rb

@@ -2,6 +2,13 @@
 require 'spec_helper'
 
 describe Puppet::Util::RunMode do
+
+  # Discriminator for tests that attempts to unset HOME since that, for reasons currently unknown,
+  # doesn't work in Ruby >= 2.4.0
+  def self.gte_ruby_2_4
+    @gte_ruby_2_4 ||= SemanticPuppet::Version.parse(RUBY_VERSION) >= SemanticPuppet::Version.parse('2.4.0')
+  end
+
   before do
     @run_mode = Puppet::Util::RunMode.new('fake')
   end
@@ -29,7 +36,7 @@ describe Puppet::Util::RunMode do
         end
       end
 
-      it "fails when asking for the conf_dir as non-root and there is no $HOME" do
+      it "fails when asking for the conf_dir as non-root and there is no $HOME", :unless => gte_ruby_2_4 || Puppet.features.microsoft_windows? do
         as_non_root do
           without_home do
             expect { @run_mode.conf_dir }.to raise_error ArgumentError, /couldn't find HOME/
@@ -57,7 +64,7 @@ describe Puppet::Util::RunMode do
         end
       end
 
-      it "fails when asking for the code_dir as non-root and there is no $HOME" do
+      it "fails when asking for the code_dir as non-root and there is no $HOME", :unless => gte_ruby_2_4 || Puppet.features.microsoft_windows? do
         as_non_root do
           without_home do
             expect { @run_mode.code_dir }.to raise_error ArgumentError, /couldn't find HOME/
@@ -75,7 +82,7 @@ describe Puppet::Util::RunMode do
         as_non_root { expect(@run_mode.var_dir).to eq(File.expand_path('~/.puppetlabs/opt/puppet/cache')) }
       end
 
-      it "fails when asking for the var_dir as non-root and there is no $HOME" do
+      it "fails when asking for the var_dir as non-root and there is no $HOME", :unless => gte_ruby_2_4 || Puppet.features.microsoft_windows? do
         as_non_root do
           without_home do
             expect { @run_mode.var_dir }.to raise_error ArgumentError, /couldn't find HOME/
@@ -96,7 +103,7 @@ describe Puppet::Util::RunMode do
           as_non_root { expect(@run_mode.log_dir).to eq(File.expand_path('~/.puppetlabs/var/log')) }
         end
 
-        it "fails when asking for the log_dir and there is no $HOME" do
+        it "fails when asking for the log_dir and there is no $HOME", :unless => gte_ruby_2_4 || Puppet.features.microsoft_windows? do
           as_non_root do
             without_home do
               expect { @run_mode.log_dir }.to raise_error ArgumentError, /couldn't find HOME/
@@ -118,7 +125,7 @@ describe Puppet::Util::RunMode do
           as_non_root { expect(@run_mode.run_dir).to eq(File.expand_path('~/.puppetlabs/var/run')) }
         end
 
-        it "fails when asking for the run_dir and there is no $HOME" do
+        it "fails when asking for the run_dir and there is no $HOME", :unless => gte_ruby_2_4 || Puppet.features.microsoft_windows? do
           as_non_root do
             without_home do
               expect { @run_mode.run_dir }.to raise_error ArgumentError, /couldn't find HOME/
@@ -153,7 +160,7 @@ describe Puppet::Util::RunMode do
         as_non_root { expect(@run_mode.conf_dir).to eq(File.expand_path("~/.puppetlabs/etc/puppet")) }
       end
 
-      it "fails when asking for the conf_dir as non-root and there is no %HOME%, %HOMEDRIVE%, and %USERPROFILE%" do
+      it "fails when asking for the conf_dir as non-root and there is no %HOME%, %HOMEDRIVE%, and %USERPROFILE%", :unless => gte_ruby_2_4 do
         as_non_root do
           without_env('HOME') do
             without_env('HOMEDRIVE') do
@@ -175,7 +182,7 @@ describe Puppet::Util::RunMode do
         as_non_root { expect(@run_mode.code_dir).to eq(File.expand_path("~/.puppetlabs/etc/code")) }
       end
 
-      it "fails when asking for the code_dir as non-root and there is no %HOME%, %HOMEDRIVE%, and %USERPROFILE%" do
+      it "fails when asking for the code_dir as non-root and there is no %HOME%, %HOMEDRIVE%, and %USERPROFILE%", :unless => gte_ruby_2_4 do
         as_non_root do
           without_env('HOME') do
             without_env('HOMEDRIVE') do
@@ -197,7 +204,7 @@ describe Puppet::Util::RunMode do
         as_non_root { expect(@run_mode.var_dir).to eq(File.expand_path("~/.puppetlabs/opt/puppet/cache")) }
       end
 
-      it "fails when asking for the conf_dir as non-root and there is no %HOME%, %HOMEDRIVE%, and %USERPROFILE%" do
+      it "fails when asking for the conf_dir as non-root and there is no %HOME%, %HOMEDRIVE%, and %USERPROFILE%", :unless => gte_ruby_2_4 do
         as_non_root do
           without_env('HOME') do
             without_env('HOMEDRIVE') do
@@ -222,7 +229,7 @@ describe Puppet::Util::RunMode do
           as_non_root { expect(@run_mode.log_dir).to eq(File.expand_path('~/.puppetlabs/var/log')) }
         end
 
-        it "fails when asking for the log_dir and there is no $HOME" do
+        it "fails when asking for the log_dir and there is no $HOME", :unless => gte_ruby_2_4 do
           as_non_root do
             without_env('HOME') do
               without_env('HOMEDRIVE') do
@@ -248,7 +255,7 @@ describe Puppet::Util::RunMode do
           as_non_root { expect(@run_mode.run_dir).to eq(File.expand_path('~/.puppetlabs/var/run')) }
         end
 
-        it "fails when asking for the run_dir and there is no $HOME" do
+        it "fails when asking for the run_dir and there is no $HOME", :unless => gte_ruby_2_4 do
           as_non_root do
             without_env('HOME') do
               without_env('HOMEDRIVE') do

data/spec/unit/util/tag_set_spec.rb

@@ -29,11 +29,11 @@ describe Puppet::Util::TagSet do
     expect(Puppet::Util::TagSet.from_yaml(array.to_yaml)).to eq(Puppet::Util::TagSet.new(array))
   end
 
-  it 'round trips through pson' do
+  it 'round trips through json' do
     array = ['a', 'b', 1, 5.4]
     set.merge(array)
 
-    tes = Puppet::Util::TagSet.from_data_hash(PSON.parse(set.to_pson))
+    tes = Puppet::Util::TagSet.from_data_hash(JSON.parse(set.to_json))
     expect(tes).to eq(set)
   end
 

data/spec/unit/util/tagging_spec.rb

@@ -48,6 +48,61 @@ describe Puppet::Util::Tagging do
     expect { tagger.tag("good.tag") }.to_not raise_error
   end
 
+  # different UTF-8 widths
+  # 1-byte A
+  # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
+  # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
+  # 4-byte ܎ - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
+  let (:mixed_utf8) { "A\u06FF\u16A0\u{2070E}" } # Aۿᚠ܎
+
+  it "should allow UTF-8 alphanumeric characters" do
+    expect { tagger.tag(mixed_utf8) }.not_to raise_error
+  end
+
+  # completely non-exhaustive list of a few UTF-8 punctuation characters
+  # http://www.fileformat.info/info/unicode/block/general_punctuation/utf8test.htm
+  [
+    "\u2020", # dagger †
+    "\u203B", # reference mark ※
+    "\u204F", # reverse semicolon ⁏
+    "!",
+    "@",
+    "#",
+    "$",
+    "%",
+    "^",
+    "&",
+    "*",
+    "(",
+    ")",
+    "-",
+    "+",
+    "=",
+    "{",
+    "}",
+    "[",
+    "]",
+    "|",
+    "\\",
+    "/",
+    "?",
+    "<",
+    ">",
+    ",",
+    ".",
+    "~",
+    ",",
+    ":",
+    ";",
+    "\"",
+    "'",
+  ].each do |char|
+    it "should not allow UTF-8 punctuation characters" do
+      expect { tagger.tag(char) }.to raise_error(Puppet::ParseError)
+    end
+  end
+
+
   it "should add qualified classes as tags" do
     tagger.tag("one::two")
     expect(tagger.tags).to include("one::two")

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/api_types_spec.rb

@@ -4,10 +4,6 @@
 require 'spec_helper'
 
 describe "FFI::MemoryPointer", :if => Puppet.features.microsoft_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 }
-
   context "read_wide_string" do
     let (:string) { "foo_bar" }
 
@@ -28,40 +24,6 @@ describe "FFI::MemoryPointer", :if => Puppet.features.microsoft_windows? do
 
       expect(read_string.encoding).to eq(Encoding::UTF_8)
     end
-
-    it "should raise an error and emit a debug message when receiving a string containing invalid bytes in the destination encoding" do
-      # enable a debug output sink to local string array
-      Puppet.debug = true
-      arraydest = []
-      Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(arraydest))
-
-      read_string = nil
-
-      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)
-
-          read_string = ptr.read_wide_string(bad_string.length)
-        end
-      }.to raise_error(Encoding::InvalidByteSequenceError)
-
-      expect(read_string).to be_nil
-      expect(arraydest.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
-      read_string = nil
-
-      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, :invalid => :replace)
-      end
-
-      expect(read_string).to eq("hello invalid world\uFFFD")
-    end
   end
 
   context "read_arbitrary_wide_string_up_to" do
@@ -104,18 +66,5 @@ describe "FFI::MemoryPointer", :if => Puppet.features.microsoft_windows? do
 
       expect(read_string.encoding).to eq(Encoding::UTF_8)
     end
-
-    it "should not raise an error when receiving a string containing invalid bytes in the destination encoding, when specifying :invalid => :replace" do
-      read_string = nil
-
-      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)
-      end
-
-      expect(read_string).to eq("hello invalid world\uFFFD")
-    end
   end
 end

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

@@ -0,0 +1,123 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+
+require 'puppet/util/windows'
+
+describe Puppet::Util::Windows::EventLog, :if => Puppet.features.microsoft_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
+      Puppet::Util::Windows::EventLog.any_instance.expects(:RegisterEventSourceW).with(nil, default_name).returns(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
+        Puppet::Util::Windows::EventLog.any_instance.stubs(:RegisterEventSourceW).returns(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)
+        FFI.stubs(:errno).returns(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
+        Puppet::Util::Windows::EventLog::EventLogError.expects(:new).with(regexp_matches(/failed to open Windows eventlog/), 87).returns(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"
+      Puppet::Util::Windows::EventLog.any_instance.stubs(:RegisterEventSourceW).returns(@handle)
+      event_log = Puppet::Util::Windows::EventLog.new
+      event_log.expects(:DeregisterEventSource).with(@handle).returns(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
+        @event_log.stubs(:ReportEventW).returns(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)
+        FFI.stubs(:errno).returns(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
+        Puppet::Util::Windows::EventLog::EventLogError.expects(:new).with(regexp_matches(/failed to report event/), 5).returns(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