puppet 4.10.12-x86-mingw32 → 5.0.0-x86-mingw32

data/spec/unit/util/execution_spec.rb

@@ -675,8 +675,9 @@ describe Puppet::Util::Execution do
     it "should fail if asked to fail, and the child does" do
       Puppet::Util::Execution.stubs(:open).with('| echo hello 2>&1').returns('error message')
       Puppet::Util::Execution.expects(:exitstatus).returns(1)
-      expect { Puppet::Util::Execution.execpipe('echo hello') }.
-        to raise_error Puppet::ExecutionFailure, /error message/
+      expect {
+        Puppet::Util::Execution.execpipe('echo hello')
+      }.to raise_error Puppet::ExecutionFailure, /error message/
     end
 
     it "should not fail if asked not to fail, and the child does" do
@@ -684,4 +685,32 @@ describe Puppet::Util::Execution do
       expect(Puppet::Util::Execution.execpipe('echo hello', false)).to eq('error message')
     end
   end
+
+  describe "execfail" do
+    it "returns the executed command output" do
+      Puppet::Util::Execution.stubs(:execute).returns("process output")
+      expect(Puppet::Util::Execution.execfail('echo hello', Puppet::Error)).to eq('process output')
+    end
+
+    it "raises a caller-specified exception on failure with the backtrace" do
+      Puppet::Util::Execution.stubs(:execute).raises(Puppet::ExecutionFailure, "failed to execute")
+      expect {
+        Puppet::Util::Execution.execfail("this will fail", Puppet::Error)
+      }.to raise_error(Puppet::Error, /failed to execute/)
+    end
+
+    it "raises exceptions that don't extend ExecutionFailure" do
+      Puppet::Util::Execution.stubs(:execute).raises(ArgumentError, "failed to execute")
+      expect {
+        Puppet::Util::Execution.execfail("this will fail", Puppet::Error)
+      }.to raise_error(ArgumentError, /failed to execute/)
+    end
+
+    it "raises a TypeError if the exception class is nil" do
+      Puppet::Util::Execution.stubs(:execute).raises(Puppet::ExecutionFailure, "failed to execute")
+      expect {
+        Puppet::Util::Execution.execfail('echo hello', nil)
+      }.to raise_error(TypeError), /exception class\/object expected/
+    end
+  end
 end

data/spec/unit/util/http_proxy_spec.rb

@@ -213,41 +213,4 @@ describe Puppet::Util::HttpProxy do
       end
     end
   end
-
-  describe '.request_with_redirects' do
-    let(:dest) { URI.parse('http://mydomain.com/some/path') }
-    let(:http_ok) { stub('http ok', :code => 200, :message => 'HTTP OK') }
-
-    it 'generates accept and accept-encoding headers' do
-      Net::HTTP.any_instance.stubs(:head).returns(http_ok)
-      Net::HTTP.any_instance.expects(:get).with do |_, headers|
-        expect(headers)
-          .to match({'Accept' => '*/*',
-                     'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
-                     'User-Agent' => /Puppet/})
-      end.returns(http_ok)
-
-      subject.request_with_redirects(dest, :get, 0)
-    end
-
-    it 'generates accept and accept-encoding headers when a block is provided' do
-      Net::HTTP.any_instance.stubs(:head).returns(http_ok)
-      Net::HTTP.any_instance.expects(:request_get).with do |_, headers, &block|
-        expect(headers)
-          .to match({'Accept' => '*/*',
-                     'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
-                     'User-Agent' => /Puppet/})
-      end.returns(http_ok)
-
-      subject.request_with_redirects(dest, :get, 0) do
-        # unused
-      end
-    end
-
-    it 'only makes a single HEAD request' do
-      Net::HTTP.any_instance.expects(:head).with(anything, anything).returns(http_ok)
-
-      subject.request_with_redirects(dest, :head, 0)
-    end
-  end
 end

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

@@ -133,7 +133,7 @@ describe Puppet::Util::Log.desttypes[:logstash_event] do
       dest = described_class.new
       result = dest.format(@msg)
       expect(result["version"]).to eq(1)
-      expect(result["level"]).to   eq(:info)
+      expect(result["level"]).to   eq('info')
       expect(result["message"]).to eq("So long, and thanks for all the fish.")
       expect(result["source"]).to  eq("a dolphin")
       # timestamp should be within 10 seconds
@@ -195,8 +195,8 @@ describe ":eventlog", :if => Puppet::Util::Platform.windows? do
 
   def expects_message_with_type(klass, level, eventlog_type, eventlog_id)
     eventlog = stub('eventlog')
-    eventlog.expects(:report_event).with(has_entries(:source => "Puppet", :event_type => eventlog_type, :event_id => eventlog_id, :data => "a hitchhiker: don't panic"))
-    Win32::EventLog.stubs(:open).returns(eventlog)
+    eventlog.expects(:report_event).with(has_entries(:event_type => eventlog_type, :event_id => eventlog_id, :data => "a hitchhiker: don't panic"))
+    Puppet::Util::Windows::EventLog.stubs(:open).returns(eventlog)
 
     msg = Puppet::Util::Log.new(:level => level, :message => "don't panic", :source => "a hitchhiker")
     dest = klass.new
@@ -207,9 +207,8 @@ describe ":eventlog", :if => Puppet::Util::Platform.windows? do
     expect(Puppet.features.eventlog?).to be_truthy
   end
 
-  it "logs to the Application event log" do
-    eventlog = stub('eventlog')
-    Win32::EventLog.expects(:open).with('Application').returns(stub('eventlog'))
+  it "logs to the Puppet Application event log" do
+    Puppet::Util::Windows::EventLog.expects(:open).with('Puppet').returns(stub('eventlog'))
 
     klass.new
   end

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