puppet 4.10.0 → 5.0.0

data/spec/unit/util/log_spec.rb

@@ -18,6 +18,46 @@ describe Puppet::Util::Log do
     expect(message).to eq("foo")
   end
 
+  context "given a message with invalid encoding" do
+    let(:logs) { [] }
+    let(:invalid_message) { "\xFD\xFBfoo".force_encoding(Encoding::Shift_JIS) }
+
+    before do
+      Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(logs))
+      Puppet::Util::Log.new(:level => :notice, :message => invalid_message)
+    end
+
+    it "does not raise an error" do
+      expect { Puppet::Util::Log.new(:level => :notice, :message => invalid_message) }.not_to raise_error
+    end
+
+    it "includes a backtrace in the log" do
+      expect(logs.last.message).to match(/Backtrace:\n.*in `initialize'/ )
+    end
+
+    it "warns that message included invalid encoding" do
+      expect(logs.last.message).to match(/Received a log message with invalid encoding/)
+    end
+
+    it "includes the 'dump' of the invalid message" do
+      expect(logs.last.message).to match(/\"\\xFD\\xFBfoo\"/)
+    end
+  end
+
+  it "converts a given non-UTF-8 message to UTF-8" do
+    logs = []
+    Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(logs))
+
+    # HIRAGANA LETTER SO
+    # In Windows_31J: \x82 \xbb - 130 187
+    # In Unicode: \u305d - \xe3 \x81 \x9d - 227 129 157
+    win_31j_msg = [130, 187].pack('C*').force_encoding(Encoding::Windows_31J)
+    utf_8_msg = "\u305d"
+
+    Puppet::Util::Log.new(:level => :notice, :message => win_31j_msg, :source => 'Puppet')
+    expect(logs.last.message).to eq(utf_8_msg)
+  end
+
   describe ".setup_default" do
     it "should default to :syslog" do
       Puppet.features.stubs(:syslog?).returns(true)
@@ -251,20 +291,20 @@ describe Puppet::Util::Log do
 
   describe Puppet::Util::Log::DestEventlog, :if => Puppet.features.eventlog? do
     before :each do
-      Win32::EventLog.stubs(:open).returns(stub 'mylog')
-      Win32::EventLog.stubs(:report_event)
-      Win32::EventLog.stubs(:close)
+      Puppet::Util::Windows::EventLog.stubs(:open).returns(stub 'mylog')
+      Puppet::Util::Windows::EventLog.stubs(:report_event)
+      Puppet::Util::Windows::EventLog.stubs(:close)
       Puppet.features.stubs(:eventlog?).returns(true)
     end
 
-    it "should restrict its suitability" do
-      Puppet.features.expects(:eventlog?).returns(false)
+    it "should restrict its suitability to Windows" do
+      Puppet.features.expects(:microsoft_windows?).returns(false)
 
       expect(Puppet::Util::Log::DestEventlog.suitable?('whatever')).to eq(false)
     end
 
-    it "should open the 'Application' event log" do
-      Win32::EventLog.expects(:open).with('Application')
+    it "should open the 'Puppet' event log" do
+      Puppet::Util::Windows::EventLog.expects(:open).with('Puppet')
 
       Puppet::Util::Log.newdestination(:eventlog)
     end
@@ -272,7 +312,7 @@ describe Puppet::Util::Log do
     it "should close the event log" do
       log = stub('myeventlog')
       log.expects(:close)
-      Win32::EventLog.expects(:open).returns(log)
+      Puppet::Util::Windows::EventLog.expects(:open).returns(log)
 
       Puppet::Util::Log.newdestination(:eventlog)
       Puppet::Util::Log.close(:eventlog)
@@ -471,24 +511,25 @@ describe Puppet::Util::Log do
   describe "to_yaml" do
     it "should not include the @version attribute" do
       log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :version => 100)
-      expect(log.to_yaml_properties).not_to include('@version')
+      expect(log.to_data_hash.keys).not_to include('version')
     end
 
-    it "should include attributes @level, @message, @source, @tags, and @time" do
+    it "should include attributes 'file', 'line', 'level', 'message', 'source', 'tags', and 'time'" do
       log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :version => 100)
-      expect(log.to_yaml_properties).to match_array([:@level, :@message, :@source, :@tags, :@time])
+      expect(log.to_data_hash.keys).to match_array(%w(file line level message source tags time))
     end
 
-    it "should include attributes @file and @line if specified" do
+    it "should include attributes 'file' and 'line' if specified" do
       log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :file => "foo", :line => 35)
-      expect(log.to_yaml_properties).to include(:@file)
-      expect(log.to_yaml_properties).to include(:@line)
+      expect(log.to_data_hash.keys).to include('file')
+      expect(log.to_data_hash.keys).to include('line')
     end
   end
 
-  it "should round trip through pson" do
-    log = Puppet::Util::Log.new(:level => 'notice', :message => 'hooray', :file => 'thefile', :line => 1729, :source => 'specs', :tags => ['a', 'b', 'c'])
-    tripped = Puppet::Util::Log.from_data_hash(PSON.parse(log.to_pson))
+  let(:log) { Puppet::Util::Log.new(:level => 'notice', :message => 'hooray', :file => 'thefile', :line => 1729, :source => 'specs', :tags => ['a', 'b', 'c']) }
+
+  it "should round trip through json" do
+    tripped = Puppet::Util::Log.from_data_hash(JSON.parse(log.to_json))
 
     expect(tripped.file).to eq(log.file)
     expect(tripped.line).to eq(log.line)
@@ -498,4 +539,8 @@ describe Puppet::Util::Log do
     expect(tripped.tags).to eq(log.tags)
     expect(tripped.time).to eq(log.time)
   end
+
+  it 'to_data_hash returns value that is instance of to Data' do
+    expect(Puppet::Pops::Types::TypeFactory.data.instance?(log.to_data_hash)).to be_truthy
+  end
 end

data/spec/unit/util/metric_spec.rb

@@ -69,15 +69,22 @@ describe Puppet::Util::Metric do
     expect(@metric["foo"]).to eq(0)
   end
 
-  it "should round trip through pson" do
+  let(:metric) do
     metric = Puppet::Util::Metric.new("foo", "mylabel")
     metric.newvalue("v1", 10.1, "something")
     metric.newvalue("v2", 20, "something else")
+    metric
+  end
 
-    tripped = Puppet::Util::Metric.from_data_hash(PSON.parse(metric.to_pson))
+  it "should round trip through json" do
+    tripped = Puppet::Util::Metric.from_data_hash(JSON.parse(metric.to_json))
 
     expect(tripped.name).to eq(metric.name)
     expect(tripped.label).to eq(metric.label)
     expect(tripped.values).to eq(metric.values)
   end
+
+  it 'to_data_hash returns value that is instance of to Data' do
+    expect(Puppet::Pops::Types::TypeFactory.data.instance?(metric.to_data_hash)).to be_truthy
+  end
 end

data/spec/unit/util/monkey_patches_spec.rb

@@ -29,194 +29,6 @@ describe Symbol do
     symbol = :foo
     expect(symbol).to equal symbol.intern
   end
-
-  describe "when :strict is off" do
-    before :each do
-      Puppet.settings[:strict] = :off
-    end
-
-    after :all do
-      Puppet.settings[:strict] = Puppet.settings.setting(:strict).default
-    end
-
-    it "should not warn if compared against another symbol" do
-      Puppet.expects(:warn_once).never
-      expect(:foo <=> :bar).to equal(1)
-    end
-
-    it "should not warn if compared against a non-symbol value" do
-      Puppet.expects(:warn_once).never
-      expect(:foo <=> "foo").to equal(0)
-    end
-  end
-
-  describe "when :strict is warning" do
-    before :each do
-      Puppet.settings[:strict] = :warning
-    end
-
-    after :all do
-      Puppet.settings[:strict] = Puppet.settings.setting(:strict).default
-    end
-
-    it "should not warn if compared against another symbol" do
-      Puppet.expects(:warn_once).never
-      expect(:foo <=> :bar).to equal(1)
-    end
-
-    it "should warn if compared against a non-symbol value" do
-      Puppet.expects(:warn_once).once
-      expect(:foo <=> "foo").to equal(0)
-    end
-  end
-
-  describe "when :strict is error" do
-    before :each do
-      Puppet.settings[:strict] = :error
-    end
-
-    after :all do
-      Puppet.settings[:strict] = Puppet.settings.setting(:strict).default
-    end
-
-    it "should not raise if compared against another symbol" do
-      Puppet.expects(:warn_once).never
-      expect(:foo <=> :bar).to equal(1)
-    end
-
-    it "should raise if compared against a non-symbol value" do
-      Puppet.expects(:warn_once).never
-      expect { :foo <=> "foo" }.to raise_error(ArgumentError, "Comparing Symbols to non-Symbol values is no longer allowed")
-    end
-  end
-end
-
-describe IO do
-  include PuppetSpec::Files
-
-  let(:file) { tmpfile('io-binary') }
-  let(:content) { "\x01\x02\x03\x04" }
-
-  describe "::binwrite" do
-    it "should write in binary mode" do
-      expect(IO.binwrite(file, content)).to eq(content.length)
-      File.open(file, 'rb') {|f| expect(f.read).to eq(content) }
-    end
-
-    (0..10).each do |offset|
-      it "should write correctly using an offset of #{offset}" do
-        expect(IO.binwrite(file, content, offset)).to eq(content.length)
-        File.open(file, 'rb') {|f| expect(f.read).to eq(("\x00" * offset) + content) }
-      end
-    end
-
-    context "truncation" do
-      let :input do "welcome to paradise, population ... YOU!" end
-      before :each do IO.binwrite(file, input) end
-
-      it "should truncate if no offset is given" do
-        expect(IO.binwrite(file, "boo")).to eq(3)
-        expect(File.read(file)).to eq("boo")
-      end
-
-      (0..10).each do |offset|
-        it "should not truncate if an offset of #{offset} is given" do
-          expect = input.dup
-          expect[offset, 3] = "BAM"
-
-          expect(IO.binwrite(file, "BAM", offset)).to eq(3)
-          expect(File.read(file)).to eq(expect)
-        end
-      end
-
-      it "should pad with NULL bytes if writing past EOF without truncate" do
-        expect = input + ("\x00" * 4) + "BAM"
-        expect(IO.binwrite(file, "BAM", input.length + 4)).to eq(3)
-        expect(File.read(file)).to eq(expect)
-      end
-    end
-
-    it "should raise an error if the directory containing the file doesn't exist" do
-      expect { IO.binwrite('/path/does/not/exist', 'foo') }.to raise_error(Errno::ENOENT)
-    end
-  end
-end
-
-describe Range do
-  def do_test( range, other, expected )
-    result = range.intersection(other)
-    expect(result).to eq(expected)
-  end
-
-  it "should return expected ranges for iterable things" do
-    iterable_tests = {
-      1  .. 4   => nil,          # before
-      11 .. 15  => nil,          # after
-      1  .. 6   => 5  ..  6,     # overlap_begin
-      9  .. 15  => 9  ..  10,    # overlap_end
-      1  .. 5   => 5  ..  5,     # overlap_begin_edge
-      10 .. 15  => 10 ..  10,    # overlap_end_edge
-      5  .. 10  => 5  ..  10,    # overlap_all
-      6  .. 9   => 6  ..  9,     # overlap_inner
-
-      1 ... 5   => nil,          # before             (exclusive range)
-      1 ... 7   => 5  ... 7,     # overlap_begin      (exclusive range)
-      1 ... 6   => 5  ... 6,     # overlap_begin_edge (exclusive range)
-      5 ... 11  => 5  ..  10,    # overlap_all        (exclusive range)
-      6 ... 10  => 6  ... 10,    # overlap_inner      (exclusive range)
-    }
-
-    iterable_tests.each do |other, expected|
-      do_test( 5..10, other, expected )
-      do_test( other, 5..10, expected )
-    end
-  end
-
-  it "should return expected ranges for noniterable things" do
-    inclusive_base_case = {
-      1.to_f  .. 4.to_f   => nil,                   # before
-      11.to_f .. 15.to_f  => nil,                   # after
-      1.to_f  .. 6.to_f   => 5.to_f  ..  6.to_f,    # overlap_begin
-      9.to_f  .. 15.to_f  => 9.to_f  ..  10.to_f,   # overlap_end
-      1.to_f  .. 5.to_f   => 5.to_f  ..  5.to_f,    # overlap_begin_edge
-      10.to_f .. 15.to_f  => 10.to_f ..  10.to_f,   # overlap_end_edge
-      5.to_f  .. 10.to_f  => 5.to_f  ..  10.to_f,   # overlap_all
-      6.to_f  .. 9.to_f   => 6.to_f  ..  9.to_f,    # overlap_inner
-
-      1.to_f ... 5.to_f   => nil,                   # before             (exclusive range)
-      1.to_f ... 7.to_f   => 5.to_f  ... 7.to_f,    # overlap_begin      (exclusive range)
-      1.to_f ... 6.to_f   => 5.to_f  ... 6.to_f,    # overlap_begin_edge (exclusive range)
-      5.to_f ... 11.to_f  => 5.to_f  ..  10.to_f,   # overlap_all        (exclusive range)
-      6.to_f ... 10.to_f  => 6.to_f  ... 10.to_f,   # overlap_inner      (exclusive range)
-    }
-
-    inclusive_base_case.each do |other, expected|
-      do_test( 5.to_f..10.to_f, other, expected )
-      do_test( other, 5.to_f..10.to_f, expected )
-    end
-
-    exclusive_base_case = {
-      1.to_f  .. 4.to_f   => nil,                   # before
-      11.to_f .. 15.to_f  => nil,                   # after
-      1.to_f  .. 6.to_f   => 5.to_f  ..  6.to_f,    # overlap_begin
-      9.to_f  .. 15.to_f  => 9.to_f  ... 10.to_f,   # overlap_end
-      1.to_f  .. 5.to_f   => 5.to_f  ..  5.to_f,    # overlap_begin_edge
-      10.to_f .. 15.to_f  => nil,                   # overlap_end_edge
-      5.to_f  .. 10.to_f  => 5.to_f  ... 10.to_f,   # overlap_all
-      6.to_f  .. 9.to_f   => 6.to_f  ..  9.to_f,    # overlap_inner
-
-      1.to_f ... 5.to_f   => nil,                   # before             (exclusive range)
-      1.to_f ... 7.to_f   => 5.to_f  ... 7.to_f,    # overlap_begin      (exclusive range)
-      1.to_f ... 6.to_f   => 5.to_f  ... 6.to_f,    # overlap_begin_edge (exclusive range)
-      5.to_f ... 11.to_f  => 5.to_f  ... 10.to_f,   # overlap_all        (exclusive range)
-      6.to_f ... 10.to_f  => 6.to_f  ... 10.to_f,   # overlap_inner      (exclusive range)
-    }
-
-    exclusive_base_case.each do |other, expected|
-      do_test( 5.to_f...10.to_f, other, expected )
-      do_test( other, 5.to_f...10.to_f, expected )
-    end
-  end
 end
 
 describe OpenSSL::SSL::SSLContext do
@@ -309,3 +121,9 @@ describe SecureRandom do
     expect(SecureRandom.uuid).to match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i)
   end
 end
+
+describe 'Enumerable' do
+  it 'expects uniq to work on an Enumerable' do
+    expect(['c', 'c', 'C'].reverse_each.uniq).to eql(['C', 'c'])
+  end
+end

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/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