puppet 5.5.22 → 6.0.0

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

@@ -1,7 +1,8 @@
+#!/usr/bin/env ruby
 require 'spec_helper'
 
-describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows? do
-  if Puppet.features.microsoft_windows?
+describe "Puppet::Util::Windows::SID", :if => Puppet::Util::Platform.windows? do
+  if Puppet::Util::Platform.windows?
     require 'puppet/util/windows'
   end
 
@@ -71,12 +72,12 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
     end
 
     it "should return a SID for a passed user or group name" do
-      expect(subject).to receive(:name_to_principal).with('testers').and_return(double(:sid => 'S-1-5-32-547'))
+      subject.expects(:name_to_principal).with('testers').returns stub(:sid => 'S-1-5-32-547')
       expect(subject.name_to_sid('testers')).to eq('S-1-5-32-547')
     end
 
     it "should return a SID for a passed fully-qualified user or group name" do
-      expect(subject).to receive(:name_to_principal).with('MACHINE\testers').and_return(double(:sid => 'S-1-5-32-547'))
+      subject.expects(:name_to_principal).with('MACHINE\testers').returns stub(:sid => 'S-1-5-32-547')
       expect(subject.name_to_sid('MACHINE\testers')).to eq('S-1-5-32-547')
     end
 
@@ -99,6 +100,7 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
     end
 
     describe "with non-US languages" do
+
       UMLAUT = [195, 164].pack('c*').force_encoding(Encoding::UTF_8)
       let(:username) { SecureRandom.uuid.to_s.gsub(/\-/, '')[0..13] + UMLAUT }
 
@@ -163,20 +165,20 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
   context "#ads_to_principal" do
     it "should raise an error for non-WIN32OLE input" do
       expect {
-        subject.ads_to_principal(double('WIN32OLE', { :Name => 'foo' }))
+        subject.ads_to_principal(stub('WIN32OLE', { :Name => 'foo' }))
       }.to raise_error(Puppet::Error, /ads_object must be an IAdsUser or IAdsGroup instance/)
     end
 
     it "should raise an error for an empty byte array in the objectSID property" do
       expect {
-        subject.ads_to_principal(double('WIN32OLE', { :objectSID => [], :Name => '', :ole_respond_to? => true }))
+        subject.ads_to_principal(stub('WIN32OLE', { :objectSID => [], :Name => '', :ole_respond_to? => true }))
       }.to raise_error(Puppet::Error, /Octet string must be an array of bytes/)
     end
 
     it "should raise an error for a malformed byte array" do
       expect {
         invalid_octet = [2]
-        subject.ads_to_principal(double('WIN32OLE', { :objectSID => invalid_octet, :Name => '', :ole_respond_to? => true }))
+        subject.ads_to_principal(stub('WIN32OLE', { :objectSID => invalid_octet, :Name => '', :ole_respond_to? => true }))
       }.to raise_error do |error|
         expect(error).to be_a(Puppet::Util::Windows::Error)
         expect(error.code).to eq(87) # ERROR_INVALID_PARAMETER
@@ -187,7 +189,7 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
       expect {
         # S-1-1-1 is a valid SID that will not resolve
         valid_octet_invalid_user = [1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0]
-        subject.ads_to_principal(double('WIN32OLE', { :objectSID => valid_octet_invalid_user, :Name => unknown_name, :ole_respond_to? => true }))
+        subject.ads_to_principal(stub('WIN32OLE', { :objectSID => valid_octet_invalid_user, :Name => unknown_name, :ole_respond_to? => true }))
       }.to raise_error do |error|
         expect(error).to be_a(Puppet::Error)
         expect(error.cause.code).to eq(1332) # ERROR_NONE_MAPPED
@@ -197,13 +199,13 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
     it "should return a Principal object even when the SID is unresolvable, as long as the Name matches" do
       # S-1-1-1 is a valid SID that will not resolve
       valid_octet_invalid_user = [1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0]
-      unresolvable_user = double('WIN32OLE', { :objectSID => valid_octet_invalid_user, :Name => 'S-1-1-1', :ole_respond_to? => true })
+      unresolvable_user = stub('WIN32OLE', { :objectSID => valid_octet_invalid_user, :Name => 'S-1-1-1', :ole_respond_to? => true })
       principal = subject.ads_to_principal(unresolvable_user)
 
       expect(principal).to be_an_instance_of(Puppet::Util::Windows::SID::Principal)
-      expect(principal.account).to eq('S-1-1-1')
+      expect(principal.account).to eq('S-1-1-1 (unresolvable)')
       expect(principal.domain).to eq(nil)
-      expect(principal.domain_account).to eq('S-1-1-1')
+      expect(principal.domain_account).to eq('S-1-1-1 (unresolvable)')
       expect(principal.sid).to eq('S-1-1-1')
       expect(principal.sid_bytes).to eq(valid_octet_invalid_user)
       expect(principal.account_type).to eq(:SidTypeUnknown)
@@ -211,13 +213,13 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
 
     it "should return a Puppet::Util::Windows::SID::Principal instance for any valid sid" do
       system_bytes = [1, 1, 0, 0, 0, 0, 0, 5, 18, 0, 0, 0]
-      adsuser = double('WIN32OLE', { :objectSID => system_bytes, :Name => 'SYSTEM', :ole_respond_to? => true })
+      adsuser = stub('WIN32OLE', { :objectSID => system_bytes, :Name => 'SYSTEM', :ole_respond_to? => true })
       expect(subject.ads_to_principal(adsuser)).to be_an_instance_of(Puppet::Util::Windows::SID::Principal)
     end
 
     it "should properly convert an array of bytes for a well-known non-localized SID, ignoring the Name from the WIN32OLE object" do
       bytes = [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-      adsuser = double('WIN32OLE', { :objectSID => bytes, :Name => unknown_name, :ole_respond_to? => true })
+      adsuser = stub('WIN32OLE', { :objectSID => bytes, :Name => unknown_name, :ole_respond_to? => true })
       converted = subject.ads_to_principal(adsuser)
 
       expect(converted).to be_an_instance_of Puppet::Util::Windows::SID::Principal
@@ -286,8 +288,8 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
     end
 
     it "should raise if the conversion fails" do
-      expect(subject).to receive(:string_to_sid_ptr).with(sid).
-        and_raise(Puppet::Util::Windows::Error.new("Failed to convert string SID: #{sid}", Puppet::Util::Windows::Error::ERROR_ACCESS_DENIED))
+      subject.expects(:string_to_sid_ptr).with(sid).
+        raises(Puppet::Util::Windows::Error.new("Failed to convert string SID: #{sid}", Puppet::Util::Windows::Error::ERROR_ACCESS_DENIED))
 
       expect {
         subject.string_to_sid_ptr(sid) {|ptr| }

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

@@ -1,9 +1,10 @@
 # encoding: UTF-8
+#!/usr/bin/env ruby
 
 require 'spec_helper'
 require 'puppet/util/windows'
 
-describe "Puppet::Util::Windows::String", :if => Puppet.features.microsoft_windows? do
+describe "Puppet::Util::Windows::String", :if => Puppet::Util::Platform.windows? do
   UTF16_NULL = [0, 0]
 
   def wide_string(str)

data/spec/unit/util/yaml_spec.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 require 'spec_helper'
 
 require 'puppet/util/yaml'
@@ -7,56 +8,189 @@ describe Puppet::Util::Yaml do
 
   let(:filename) { tmpfile("yaml") }
 
-  it "reads a YAML file from disk" do
-    write_file(filename, YAML.dump({ "my" => "data" }))
+  shared_examples_for 'yaml file loader' do |load_method|
+    it 'returns false when the file is empty' do
+      Puppet::FileSystem.touch(filename)
 
-    expect(Puppet::Util::Yaml.load_file(filename)).to eq({ "my" => "data" })
-  end
+      expect(load_method.call(filename)).to eq(false)
+    end
 
-  it "writes data formatted as YAML to disk" do
-    Puppet::Util::Yaml.dump({ "my" => "data" }, filename)
+    it 'reads a YAML file from disk' do
+      write_file(filename, YAML.dump({ "my" => "data" }))
 
-    expect(Puppet::Util::Yaml.load_file(filename)).to eq({ "my" => "data" })
-  end
+      expect(load_method.call(filename)).to eq({ "my" => "data" })
+    end
 
-  it "raises an error when the file is invalid YAML" do
-    write_file(filename, "{ invalid")
+    it 'reads YAML as UTF-8' do
+      write_file(filename, YAML.dump({ "my" => "𠜎" }))
 
-    expect { Puppet::Util::Yaml.load_file(filename) }.to raise_error(Puppet::Util::Yaml::YamlLoadError)
+      expect(load_method.call(filename)).to eq({ "my" => "𠜎" })
+    end
   end
 
-  it "raises an error when the file does not exist" do
-    expect { Puppet::Util::Yaml.load_file("no") }.to raise_error(Puppet::Util::Yaml::YamlLoadError, /No such file or directory/)
+  context "#safe_load" do
+    it 'raises an error if YAML is invalid' do
+      expect {
+        Puppet::Util::Yaml.safe_load('{ invalid')
+      }.to raise_error(Puppet::Util::Yaml::YamlLoadError, %r[\(<unknown>\): .* at line \d+ column \d+])
+    end
+
+    it 'raises if YAML contains classes not in the list' do
+      expect {
+        Puppet::Util::Yaml.safe_load(<<FACTS, [])
+--- !ruby/object:Puppet::Node::Facts
+name: localhost
+FACTS
+      }.to raise_error(Puppet::Util::Yaml::YamlLoadError, "(<unknown>): Tried to load unspecified class: Puppet::Node::Facts")
+    end
+
+    it 'includes the filename if YAML contains classes not in the list' do
+      expect {
+        Puppet::Util::Yaml.safe_load(<<FACTS, [], 'foo.yaml')
+--- !ruby/object:Puppet::Node::Facts
+name: localhost
+FACTS
+      }.to raise_error(Puppet::Util::Yaml::YamlLoadError, "(foo.yaml): Tried to load unspecified class: Puppet::Node::Facts")
+    end
+
+    it 'allows classes to be loaded' do
+      facts = Puppet::Util::Yaml.safe_load(<<FACTS, [Puppet::Node::Facts])
+--- !ruby/object:Puppet::Node::Facts
+name: localhost
+values:
+  puppetversion: 6.0.0
+FACTS
+      expect(facts.name).to eq('localhost')
+    end
+
+    it 'returns false if the content is empty' do
+      expect(Puppet::Util::Yaml.safe_load('')).to eq(false)
+    end
+
+    it 'loads true' do
+      expect(Puppet::Util::Yaml.safe_load('true')).to eq(true)
+    end
+
+    it 'loads false' do
+      expect(Puppet::Util::Yaml.safe_load('false')).to eq(false)
+    end
+
+    it 'loads nil' do
+      expect(Puppet::Util::Yaml.safe_load(<<~YAML)).to eq('a' => nil)
+        ---
+        a: null
+      YAML
+    end
+
+    it 'loads a numeric' do
+      expect(Puppet::Util::Yaml.safe_load('42')).to eq(42)
+    end
+
+    it 'loads a string' do
+      expect(Puppet::Util::Yaml.safe_load('puppet')).to eq('puppet')
+    end
+
+    it 'loads an array' do
+      expect(Puppet::Util::Yaml.safe_load(<<~YAML)).to eq([1, 2])
+        ---
+        - 1
+        - 2
+      YAML
+    end
+
+    it 'loads a hash' do
+      expect(Puppet::Util::Yaml.safe_load(<<~YAML)).to eq('a' => 1, 'b' => 2)
+        ---
+        a: 1
+        b: 2
+      YAML
+    end
+
+    it 'loads an alias' do
+      expect(Puppet::Util::Yaml.safe_load(<<~YAML)).to eq('a' => [], 'b' => [])
+        ---
+        a: &1 []
+        b: *1
+      YAML
+    end
   end
 
-  it "raises an error when the filename is illegal" do
-    expect { Puppet::Util::Yaml.load_file("not\0allowed") }.to raise_error(Puppet::Util::Yaml::YamlLoadError, /null byte/)
+  context "#safe_load_file" do
+    it_should_behave_like 'yaml file loader', Puppet::Util::Yaml.method(:safe_load_file)
+
+    it 'raises an error when the file is invalid YAML' do
+      write_file(filename, '{ invalid')
+
+      expect {
+        Puppet::Util::Yaml.safe_load_file(filename)
+      }.to raise_error(Puppet::Util::Yaml::YamlLoadError, %r[\(#{filename}\): .* at line \d+ column \d+])
+    end
+
+    it 'raises an error when the filename is illegal' do
+      expect {
+        Puppet::Util::Yaml.safe_load_file("not\0allowed")
+      }.to raise_error(ArgumentError, /pathname contains null byte/)
+    end
+
+    it 'raises an error when the file does not exist' do
+      expect {
+        Puppet::Util::Yaml.safe_load_file('does/not/exist.yaml')
+      }.to raise_error(Errno::ENOENT, /No such file or directory/)
+    end
   end
 
-  context "when the file is empty" do
-    it "returns false" do
-      Puppet::FileSystem.touch(filename)
+  context '#load_file' do
+    it_should_behave_like 'yaml file loader', Puppet::Util::Yaml.method(:load_file)
+
+    it 'raises an error when the file is invalid YAML' do
+      write_file(filename, '{ invalid')
 
-      expect(Puppet::Util::Yaml.load_file(filename)).to be_falsey
+      expect {
+        Puppet::Util::Yaml.load_file(filename)
+      }.to raise_error(Puppet::Util::Yaml::YamlLoadError, %r{\(#{filename}\): .* at line \d+ column \d+})
     end
 
-    it "allows return value to be overridden" do
+    it 'raises an error when the filename is illegal' do
+      expect {
+        Puppet::Util::Yaml.load_file("not\0allowed")
+      }.to raise_error(Puppet::Util::Yaml::YamlLoadError, /null byte/)
+    end
+
+    it 'raises an error when the file does not exist' do
+      expect {
+        Puppet::Util::Yaml.load_file('does/not/exist.yaml')
+      }.to raise_error(Puppet::Util::Yaml::YamlLoadError, /No such file or directory/)
+    end
+
+    it 'allows return value to be overridden' do
       Puppet::FileSystem.touch(filename)
 
       expect(Puppet::Util::Yaml.load_file(filename, {})).to eq({})
     end
-  end
 
-  it "should allow one to strip ruby tags that would otherwise not parse" do
-    write_file(filename, "---\nweirddata: !ruby/hash:Not::A::Valid::Class {}")
+    it 'loads arbitrary objects' do
+      write_file(filename, "--- !ruby/object {}\n")
 
-    expect(Puppet::Util::Yaml.load_file(filename, {}, true)).to eq({"weirddata" => {}})
-  end
+      expect(Puppet::Util::Yaml.load_file(filename, {})).to be_instance_of(Object)
+    end
 
-  it "should not strip non-ruby tags" do
-    write_file(filename, "---\nweirddata: !binary |-\n          e21kNX04MTE4ZGY2NmM5MTc3OTg4ZWE4Y2JiOWEzMjMyNzFkYg==")
+    it 'should allow one to strip ruby tags that would otherwise not parse' do
+      write_file(filename, "---\nweirddata: !ruby/hash:Not::A::Valid::Class {}")
 
-    expect(Puppet::Util::Yaml.load_file(filename, {}, true)).to eq({"weirddata" => "{md5}8118df66c9177988ea8cbb9a323271db"})
+      expect(Puppet::Util::Yaml.load_file(filename, {}, true)).to eq({"weirddata" => {}})
+    end
+
+    it 'should not strip non-ruby tags' do
+      write_file(filename, "---\nweirddata: !binary |-\n          e21kNX04MTE4ZGY2NmM5MTc3OTg4ZWE4Y2JiOWEzMjMyNzFkYg==")
+
+      expect(Puppet::Util::Yaml.load_file(filename, {}, true)).to eq({"weirddata" => "{md5}8118df66c9177988ea8cbb9a323271db"})
+    end
+
+    it 'writes data formatted as YAML to disk' do
+      Puppet::Util::Yaml.dump({ "my" => "data" }, filename)
+
+      expect(Puppet::Util::Yaml.load_file(filename)).to eq({ "my" => "data" })
+    end
   end
 
   def write_file(name, contents)

data/spec/unit/util_spec.rb

@@ -1,3 +1,5 @@
+#!/usr/bin/env ruby
+
 require 'spec_helper'
 
 describe Puppet::Util do
@@ -9,7 +11,7 @@ describe Puppet::Util do
     @gte_ruby_2_4 ||= SemanticPuppet::Version.parse(RUBY_VERSION) >= SemanticPuppet::Version.parse('2.4.0')
   end
 
-  if Puppet.features.microsoft_windows?
+  if Puppet::Util::Platform.windows?
     def set_mode(mode, file)
       Puppet::Util::Windows::Security.set_mode(mode, file)
     end
@@ -28,7 +30,7 @@ describe Puppet::Util do
   end
 
   describe "#withenv" do
-    let(:mode) { Puppet.features.microsoft_windows? ? :windows : :posix }
+    let(:mode) { Puppet::Util::Platform.windows? ? :windows : :posix }
 
     before :each do
       @original_path = ENV["PATH"]
@@ -73,7 +75,7 @@ describe Puppet::Util do
     end
   end
 
-  describe "#withenv on POSIX", :unless => Puppet.features.microsoft_windows? do
+  describe "#withenv on POSIX", :unless => Puppet::Util::Platform.windows? do
     it "should preserve case" do
       # start with lower case key,
       env_key = SecureRandom.uuid.downcase
@@ -96,7 +98,8 @@ describe Puppet::Util do
     end
   end
 
-  describe "#withenv on Windows", :if => Puppet.features.microsoft_windows? do
+  describe "#withenv on Windows", :if => Puppet::Util::Platform.windows? do
+
     let(:process) { Puppet::Util::Windows::Process }
 
     it "should ignore case" do
@@ -120,6 +123,7 @@ describe Puppet::Util do
       end
     end
 
+
     def withenv_utf8(&block)
       env_var_name = SecureRandom.uuid
       utf_8_bytes = [225, 154, 160] # rune ᚠ
@@ -145,45 +149,10 @@ describe Puppet::Util do
     # document buggy Ruby behavior here for https://bugs.ruby-lang.org/issues/8822
     # Ruby retrieves / stores ENV names in the current codepage
     # when these tests no longer pass, Ruby has fixed its bugs and workarounds can be removed
-    # interestingly we would expect some of these tests to fail when codepage is 65001
-    # but instead the env values are in Encoding::ASCII_8BIT!
-    it "works around Ruby bug 8822 (which fails to preserve UTF-8 properly when accessing ENV) (Ruby <= 2.1) ",
-      :if => ((RUBY_VERSION =~ /^(1\.|2\.0\.|2\.1\.)/) && Puppet.features.microsoft_windows?) do
-
-      withenv_utf8 do |utf_8_key, utf_8_value, codepage_key|
-        # both a string in UTF-8 and current codepage are deemed valid keys to the hash
-        # which is because Ruby compares the BINARY versions of the string, but ignores encoding
-        expect(ENV.key?(codepage_key)).to eq(true)
-        expect(ENV.key?(utf_8_key)).to eq(true)
 
-        # Ruby's ENV.keys has slightly different behavior than ENV.key?(key)
-        # the keys collection in 2.1 has a string with the correct bytes
-        # (codepage_key / utf_8_key have same bytes for the sake of searching)
-        found = ENV.keys.find { |k| k.bytes == codepage_key.bytes }
-        # but the string is actually a binary string
-        expect(found.encoding).to eq(Encoding::BINARY)
-        # meaning we can't use include? to find it in either UTF-8 or codepage encoding
-        expect(ENV.keys.include?(codepage_key)).to eq(false)
-        expect(ENV.keys.include?(utf_8_key)).to eq(false)
-
-        # and can only search with a BINARY encoded string
-        expect(ENV.keys.include?(utf_8_key.dup.force_encoding(Encoding::BINARY))).to eq(true)
-
-        # similarly the value stored at the real key is in current codepage
-        # but won't match real UTF-8 value
-        env_value = ENV[utf_8_key]
-        expect(env_value).to_not eq(utf_8_value)
-        expect(env_value.encoding).to_not eq(Encoding::UTF_8)
-
-        # but it can be forced back to UTF-8 to make it match.. ugh
-        converted_value = ENV[utf_8_key].dup.force_encoding(Encoding::UTF_8)
-        expect(converted_value).to eq(utf_8_value)
-      end
-    end
-
-    # but in 2.3, the behavior is mostly correct when external codepage is 65001 / UTF-8
+    # In 2.3, the behavior is mostly correct when external codepage is 65001 / UTF-8
     it "works around Ruby bug 8822 (which fails to preserve UTF-8 properly when accessing ENV) (Ruby >= 2.3.x) ",
-      :if => ((match = RUBY_VERSION.match(/^2\.(\d+)\./)) && match.captures[0].to_i >= 3 && Puppet.features.microsoft_windows?) do
+      :if => Puppet::Util::Platform.windows? do
 
       raise 'This test requires a non-UTF8 codepage' if Encoding.default_external == Encoding::UTF_8
 
@@ -260,7 +229,7 @@ describe Puppet::Util do
       end
     end
 
-    describe "on windows", :if => Puppet.features.microsoft_windows? do
+    describe "on windows", :if => Puppet::Util::Platform.windows? do
       it "should default to the platform of the local system" do
         expect(Puppet::Util).to be_absolute_path('C:/foo')
         expect(Puppet::Util).not_to be_absolute_path('/foo')
@@ -330,17 +299,14 @@ describe Puppet::Util do
       path = "/foo+foo bar?foo+foo bar"
       uri = Puppet::Util.path_to_uri(path)
 
-      # Ruby 1.9.3 URI#to_s has a bug that returns ASCII always
-      # despite parts being UTF-8 strings
-      expected_encoding = RUBY_VERSION == '1.9.3' ? Encoding::ASCII : Encoding::UTF_8
-
+      expected_encoding = Encoding::UTF_8
       expect(uri.to_s.encoding).to eq(expected_encoding)
       expect(uri.path).to eq("/foo+foo%20bar")
       # either + or %20 is correct for an encoded space in query
       # + is usually used for backward compatibility, but %20 is preferred for compat with Uri.unescape
       expect(uri.query).to eq("foo%2Bfoo%20bar")
       # complete roundtrip
-      expect(URI.unescape(uri.to_s)).to eq("file:#{path}")
+      expect(URI.unescape(uri.to_s).sub(%r{^file:(//)?}, '')).to eq(path)
       expect(URI.unescape(uri.to_s).encoding).to eq(expected_encoding)
     end
 
@@ -353,8 +319,8 @@ describe Puppet::Util do
 
     describe "when using platform :posix" do
       before :each do
-        allow(Puppet.features).to receive(:posix).and_return(true)
-        allow(Puppet.features).to receive(:microsoft_windows?).and_return(false)
+        Puppet.features.stubs(:posix).returns true
+        Puppet::Util::Platform.stubs(:windows?).returns false
       end
 
       %w[/ /foo /foo/../bar].each do |path|
@@ -366,8 +332,8 @@ describe Puppet::Util do
 
     describe "when using platform :windows" do
       before :each do
-        allow(Puppet.features).to receive(:posix).and_return(false)
-        allow(Puppet.features).to receive(:microsoft_windows?).and_return(true)
+        Puppet.features.stubs(:posix).returns false
+        Puppet::Util::Platform.stubs(:windows?).returns true
       end
 
       it "should normalize backslashes" do
@@ -500,8 +466,8 @@ describe Puppet::Util do
 
     describe "when using platform :posix" do
       before :each do
-        allow(Puppet.features).to receive(:posix).and_return(true)
-        allow(Puppet.features).to receive(:microsoft_windows?).and_return(false)
+        Puppet.features.stubs(:posix).returns true
+        Puppet::Util::Platform.stubs(:windows?).returns false
       end
 
       %w[/ /foo /foo/../bar].each do |path|
@@ -539,8 +505,8 @@ describe Puppet::Util do
 
     describe "when using platform :windows" do
       before :each do
-        allow(Puppet.features).to receive(:posix).and_return(false)
-        allow(Puppet.features).to receive(:microsoft_windows?).and_return(true)
+        Puppet.features.stubs(:posix).returns false
+        Puppet::Util::Platform.stubs(:windows?).returns true
       end
 
       it "should url encode \\ as %5C, but not replace : as %3F" do
@@ -608,7 +574,7 @@ describe Puppet::Util do
       end
     end
 
-    describe "when using platform :windows", :if => Puppet.features.microsoft_windows? do
+    describe "when using platform :windows", :if => Puppet::Util::Platform.windows? do
       it "should accept root" do
         expect(Puppet::Util.uri_to_path(URI.parse('file:/C:/'))).to eq('C:/')
       end
@@ -632,14 +598,14 @@ describe Puppet::Util do
 
     before :each do
       # Most of the things this method does are bad to do during specs. :/
-      allow(Kernel).to receive(:fork).and_return(pid).and_yield
+      Kernel.stubs(:fork).returns(pid).yields
 
-      allow($stdin).to receive(:reopen)
-      allow($stdout).to receive(:reopen)
-      allow($stderr).to receive(:reopen)
+      $stdin.stubs(:reopen)
+      $stdout.stubs(:reopen)
+      $stderr.stubs(:reopen)
 
       # ensure that we don't really close anything!
-      allow(IO).to receive(:new)
+      (0..256).each {|n| IO.stubs(:new) }
     end
 
     it "should close all open file descriptors except stdin/stdout/stderr when /proc/self/fd exists" do
@@ -650,32 +616,28 @@ describe Puppet::Util do
         if fd == '.' || fd == '..'
           next
         elsif ['0', '1', '2'].include? fd
-          expect(IO).not_to receive(:new).with(fd.to_i)
+          IO.expects(:new).with(fd.to_i).never
         else
-          expect(IO).to receive(:new).with(fd.to_i).and_return(double('io', close: nil))
+          IO.expects(:new).with(fd.to_i).returns mock('io', :close)
         end
       end
 
-      dir_expectation = receive(:foreach).with('/proc/self/fd')
-      fds.each do |fd|
-        dir_expectation = dir_expectation.and_yield(fd)
-      end
-      allow(Dir).to dir_expectation
+      Dir.stubs(:foreach).with('/proc/self/fd').multiple_yields(*fds)
       Puppet::Util.safe_posix_fork
     end
 
     it "should close all open file descriptors except stdin/stdout/stderr when /proc/self/fd doesn't exists" do
       # This is ugly, but I can't really think of a better way to do it without
       # letting it actually close fds, which seems risky
-      (0..2).each {|n| expect(IO).not_to receive(:new).with(n)}
-      (3..256).each {|n| expect(IO).to receive(:new).with(n).and_return(double('io', close: nil))  }
-      allow(Dir).to receive(:foreach).with('/proc/self/fd').and_raise(Errno::ENOENT)
+      (0..2).each {|n| IO.expects(:new).with(n).never}
+      (3..256).each { |n| IO.expects(:new).with(n).returns mock('io', :close)  }
+      Dir.stubs(:foreach).with('/proc/self/fd') { raise Errno::ENOENT }
 
       Puppet::Util.safe_posix_fork
     end
 
     it "should fork a child process to execute the block" do
-      expect(Kernel).to receive(:fork).and_return(pid).and_yield
+      Kernel.expects(:fork).returns(pid).yields
 
       Puppet::Util.safe_posix_fork do
         "Fork this!"
@@ -692,11 +654,11 @@ describe Puppet::Util do
     let(:path) { File.join(base, 'foo') }
 
     before :each do
-      allow(FileTest).to receive(:file?).and_return(false)
-      allow(FileTest).to receive(:file?).with(path).and_return(true)
+      FileTest.stubs(:file?).returns false
+      FileTest.stubs(:file?).with(path).returns true
 
-      allow(FileTest).to receive(:executable?).and_return(false)
-      allow(FileTest).to receive(:executable?).with(path).and_return(true)
+      FileTest.stubs(:executable?).returns false
+      FileTest.stubs(:executable?).with(path).returns true
     end
 
     it "should accept absolute paths" do
@@ -711,10 +673,10 @@ describe Puppet::Util do
       env_path = %w[~/bin /usr/bin /bin].join(File::PATH_SEPARATOR)
 
       env = {:HOME => nil, :PATH => env_path}
-      env.merge!({:HOMEDRIVE => nil, :USERPROFILE => nil}) if Puppet.features.microsoft_windows?
+      env.merge!({:HOMEDRIVE => nil, :USERPROFILE => nil}) if Puppet::Util::Platform.windows?
 
-      expect(Puppet::Util::Warnings).to receive(:warnonce).once
       Puppet::Util.withenv(env) do
+        Puppet::Util::Warnings.expects(:warnonce).once
         Puppet::Util.which('foo')
       end
     end
@@ -736,13 +698,13 @@ describe Puppet::Util do
 
     describe "on POSIX systems" do
       before :each do
-        allow(Puppet.features).to receive(:posix?).and_return(true)
-        allow(Puppet.features).to receive(:microsoft_windows?).and_return(false)
+        Puppet.features.stubs(:posix?).returns true
+        Puppet::Util::Platform.stubs(:windows?).returns false
       end
 
       it "should walk the search PATH returning the first executable" do
-        allow(Puppet::Util).to receive(:get_env).with('PATH').and_return(File.expand_path('/bin'))
-        allow(Puppet::Util).to receive(:get_env).with('PATHEXT').and_return(nil)
+        Puppet::Util.stubs(:get_env).with('PATH').returns(File.expand_path('/bin'))
+        Puppet::Util.stubs(:get_env).with('PATHEXT').returns(nil)
 
         expect(Puppet::Util.which('foo')).to eq(path)
       end
@@ -752,16 +714,16 @@ describe Puppet::Util do
       let(:path) { File.expand_path(File.join(base, 'foo.CMD')) }
 
       before :each do
-        allow(Puppet.features).to receive(:posix?).and_return(false)
-        allow(Puppet.features).to receive(:microsoft_windows?).and_return(true)
+        Puppet.features.stubs(:posix?).returns false
+        Puppet::Util::Platform.stubs(:windows?).returns true
       end
 
       describe "when a file extension is specified" do
         it "should walk each directory in PATH ignoring PATHEXT" do
-          allow(Puppet::Util).to receive(:get_env).with('PATH').and_return(%w[/bar /bin].map{|dir| File.expand_path(dir)}.join(File::PATH_SEPARATOR))
-          allow(Puppet::Util).to receive(:get_env).with('PATHEXT').and_return('.FOOBAR')
+          Puppet::Util.stubs(:get_env).with('PATH').returns(%w[/bar /bin].map{|dir| File.expand_path(dir)}.join(File::PATH_SEPARATOR))
+          Puppet::Util.stubs(:get_env).with('PATHEXT').returns('.FOOBAR')
 
-          expect(FileTest).to receive(:file?).with(File.join(File.expand_path('/bar'), 'foo.CMD')).and_return(false)
+          FileTest.expects(:file?).with(File.join(File.expand_path('/bar'), 'foo.CMD')).returns false
 
           expect(Puppet::Util.which('foo.CMD')).to eq(path)
         end
@@ -770,36 +732,38 @@ describe Puppet::Util do
       describe "when a file extension is not specified" do
         it "should walk each extension in PATHEXT until an executable is found" do
           bar = File.expand_path('/bar')
-          allow(Puppet::Util).to receive(:get_env).with('PATH').and_return("#{bar}#{File::PATH_SEPARATOR}#{base}")
-          allow(Puppet::Util).to receive(:get_env).with('PATHEXT').and_return(".EXE#{File::PATH_SEPARATOR}.CMD")
+          Puppet::Util.stubs(:get_env).with('PATH').returns("#{bar}#{File::PATH_SEPARATOR}#{base}")
+          Puppet::Util.stubs(:get_env).with('PATHEXT').returns(".EXE#{File::PATH_SEPARATOR}.CMD")
 
-          expect(FileTest).to receive(:file?).ordered().with(File.join(bar, 'foo.EXE')).and_return(false)
-          expect(FileTest).to receive(:file?).ordered().with(File.join(bar, 'foo.CMD')).and_return(false)
-          expect(FileTest).to receive(:file?).ordered().with(File.join(base, 'foo.EXE')).and_return(false)
-          expect(FileTest).to receive(:file?).ordered().with(path).and_return(true)
+          exts = sequence('extensions')
+          FileTest.expects(:file?).in_sequence(exts).with(File.join(bar, 'foo.EXE')).returns false
+          FileTest.expects(:file?).in_sequence(exts).with(File.join(bar, 'foo.CMD')).returns false
+          FileTest.expects(:file?).in_sequence(exts).with(File.join(base, 'foo.EXE')).returns false
+          FileTest.expects(:file?).in_sequence(exts).with(path).returns true
 
           expect(Puppet::Util.which('foo')).to eq(path)
         end
 
         it "should walk the default extension path if the environment variable is not defined" do
-          allow(Puppet::Util).to receive(:get_env).with('PATH').and_return(base)
-          allow(Puppet::Util).to receive(:get_env).with('PATHEXT').and_return(nil)
+          Puppet::Util.stubs(:get_env).with('PATH').returns(base)
+          Puppet::Util.stubs(:get_env).with('PATHEXT').returns(nil)
 
+          exts = sequence('extensions')
           %w[.COM .EXE .BAT].each do |ext|
-            expect(FileTest).to receive(:file?).ordered().with(File.join(base, "foo#{ext}")).and_return(false)
+            FileTest.expects(:file?).in_sequence(exts).with(File.join(base, "foo#{ext}")).returns false
           end
-          expect(FileTest).to receive(:file?).ordered().with(path).and_return(true)
+          FileTest.expects(:file?).in_sequence(exts).with(path).returns true
 
           expect(Puppet::Util.which('foo')).to eq(path)
         end
 
         it "should fall back if no extension matches" do
-          allow(Puppet::Util).to receive(:get_env).with('PATH').and_return(base)
-          allow(Puppet::Util).to receive(:get_env).with('PATHEXT').and_return(".EXE")
+          Puppet::Util.stubs(:get_env).with('PATH').returns(base)
+          Puppet::Util.stubs(:get_env).with('PATHEXT').returns(".EXE")
 
-          allow(FileTest).to receive(:file?).with(File.join(base, 'foo.EXE')).and_return(false)
-          allow(FileTest).to receive(:file?).with(File.join(base, 'foo')).and_return(true)
-          allow(FileTest).to receive(:executable?).with(File.join(base, 'foo')).and_return(true)
+          FileTest.stubs(:file?).with(File.join(base, 'foo.EXE')).returns false
+          FileTest.stubs(:file?).with(File.join(base, 'foo')).returns true
+          FileTest.stubs(:executable?).with(File.join(base, 'foo')).returns true
 
           expect(Puppet::Util.which('foo')).to eq(File.join(base, 'foo'))
         end
@@ -821,7 +785,6 @@ describe Puppet::Util do
 
   context "#replace_file" do
     subject { Puppet::Util }
-
     it { is_expected.to respond_to :replace_file }
 
     let :target do
@@ -854,7 +817,7 @@ describe Puppet::Util do
     # Windows collapses the owner and group modes into a single ACE, resulting
     # in set(0600) => get(0660) and so forth. --daniel 2012-03-30
     modes = [0555, 0660, 0770]
-    modes += [0600, 0700] unless Puppet.features.microsoft_windows?
+    modes += [0600, 0700] unless Puppet::Util::Platform.windows?
     modes.each do |mode|
       it "should copy 0#{mode.to_s(8)} permissions from the target file by default" do
         set_mode(mode, target.path)
@@ -868,7 +831,7 @@ describe Puppet::Util do
       end
     end
 
-    it "should copy the permissions of the source file after yielding on Unix", :if => !Puppet.features.microsoft_windows? do
+    it "should copy the permissions of the source file after yielding on Unix", :if => !Puppet::Util::Platform.windows? do
       set_mode(0555, target.path)
       inode = Puppet::FileSystem.stat(target.path).ino
 
@@ -892,7 +855,7 @@ describe Puppet::Util do
       subject.replace_file(temp_path, 0440) do |fh|
         fh.puts('some text in there')
       end
-
+      
       expect(File.read(temp_path)).to eq("some text in there\n")
       expect(get_mode(temp_path)).to eq(0440)
     end
@@ -969,6 +932,7 @@ describe Puppet::Util do
   end
 
   describe "#deterministic_rand" do
+
     it "should not fiddle with future rand calls" do
       Puppet::Util.deterministic_rand(123,20)
       rand_one = rand()
@@ -976,19 +940,10 @@ describe Puppet::Util do
       expect(rand()).not_to eql(rand_one)
     end
 
-    if defined?(Random) == 'constant' && Random.class == Class
-      it "should not fiddle with the global seed" do
-        srand(1234)
-        Puppet::Util.deterministic_rand(123,20)
-        expect(srand()).to eql(1234)
-      end
-    # ruby below 1.9.2 variant
-    else
-      it "should set a new global seed" do
-        srand(1234)
-        Puppet::Util.deterministic_rand(123,20)
-        expect(srand()).not_to eql(1234)
-      end
+    it "should not fiddle with the global seed" do
+      srand(1234)
+      Puppet::Util.deterministic_rand(123,20)
+      expect(srand()).to eql(1234)
     end
   end
 end