puppet 5.0.0 → 6.0.0

data/spec/unit/util/autoload_spec.rb

@@ -1,11 +1,14 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'fileutils'
 
 require 'puppet/util/autoload'
 
 describe Puppet::Util::Autoload do
   include PuppetSpec::Files
 
+  let(:env) { Puppet::Node::Environment.create(:foo, []) }
+
   before do
     @autoload = Puppet::Util::Autoload.new("foo", "tmp")
 
@@ -16,7 +19,21 @@ describe Puppet::Util::Autoload do
   describe "when building the search path" do
     before :each do
       ## modulepath/libdir can't be used until after app settings are initialized, so we need to simulate that:
-      Puppet.settings.expects(:app_defaults_initialized?).returns(true).at_least_once
+      Puppet.settings.stubs(:app_defaults_initialized?).returns(true)
+    end
+
+    def with_libdir(libdir)
+      begin
+        Puppet::Util::Autoload.instance_variable_set(:@initialized, false)
+        old_loadpath = $LOAD_PATH.dup
+        old_libdir = Puppet[:libdir]
+        Puppet[:libdir] = libdir
+        yield
+      ensure
+        Puppet[:libdir] = old_libdir
+        $LOAD_PATH.clear
+        $LOAD_PATH.concat(old_loadpath)
+      end
     end
 
     it "should collect all of the lib directories that exist in the current environment's module path" do
@@ -44,30 +61,47 @@ describe Puppet::Util::Autoload do
     it "ignores the configured environment when it doesn't exist" do
       Puppet[:environment] = 'nonexistent'
 
-      Puppet.override({ :environments => Puppet::Environments::Static.new() }) do
-        expect(@autoload.class.module_directories(nil)).to be_empty
+      env = Puppet::Node::Environment.create(:dev, [])
+      Puppet.override(environments: Puppet::Environments::Static.new(env)) do
+        expect(@autoload.class.module_directories(Puppet.lookup(:current_environment))).to be_empty
       end
     end
 
-    it "uses the configured environment when no environment is given" do
+    it "raises when no environment is given" do
       Puppet[:environment] = 'nonexistent'
 
-      Puppet.override({ :environments => Puppet::Environments::Static.new() }) do
-        expect(@autoload.class.module_directories(nil)).to be_empty
+      Puppet.override(environments: Puppet::Environments::Static.new) do
+        expect {
+          @autoload.class.module_directories(nil)
+        }.to raise_error(ArgumentError, /Autoloader requires an environment/)
       end
     end
 
-    it "should include the module directories, the Puppet libdir, and all of the Ruby load directories" do
-      Puppet[:libdir] = '/libdir1'
-      @autoload.class.expects(:gem_directories).returns %w{/one /two}
-      @autoload.class.expects(:module_directories).returns %w{/three /four}
-      expect(@autoload.class.search_directories(nil)).to eq(%w{/one /two /three /four} + [Puppet[:libdir]] + $LOAD_PATH)
+    it "should include the module directories, the Puppet libdir, Ruby load directories, and vendored modules" do
+      vendor_dir = tmpdir('vendor_modules')
+      module_libdir = File.join(vendor_dir, 'amodule_core', 'lib')
+      FileUtils.mkdir_p(module_libdir)
+
+      libdir = File.expand_path('/libdir1')
+      Puppet[:vendormoduledir] = vendor_dir
+
+      with_libdir(libdir) do
+        @autoload.class.expects(:gem_directories).returns %w{/one /two}
+        @autoload.class.expects(:module_directories).returns %w{/three /four}
+        dirs = @autoload.class.search_directories(nil)
+        expect(dirs[0..4]).to eq(%w{/one /two /three /four} + [libdir])
+        expect(dirs.last).to eq(module_libdir)
+      end
     end
 
     it "does not split the Puppet[:libdir]" do
-      Puppet[:libdir] = "/libdir1#{File::PATH_SEPARATOR}/libdir2"
-
-      expect(@autoload.class.libdirs).to eq([Puppet[:libdir]])
+      dir = File.expand_path("/libdir1#{File::PATH_SEPARATOR}/libdir2")
+      with_libdir(dir) do
+        @autoload.class.expects(:gem_directories).returns %w{/one /two}
+        @autoload.class.expects(:module_directories).returns %w{/three /four}
+        dirs = @autoload.class.search_directories(nil)
+        expect(dirs).to include(dir)
+      end
     end
   end
 
@@ -79,49 +113,47 @@ describe Puppet::Util::Autoload do
       File.stubs(:mtime).returns @time_a
     end
 
+    after(:each) do
+      $LOADED_FEATURES.delete("/a/tmp/myfile.rb")
+    end
+
     [RuntimeError, LoadError, SyntaxError].each do |error|
       it "should die with Puppet::Error if a #{error.to_s} exception is thrown" do
         Puppet::FileSystem.stubs(:exist?).returns true
 
         Kernel.expects(:load).raises error
 
-        expect { @autoload.load("foo") }.to raise_error(Puppet::Error)
+        expect { @autoload.load("foo", env) }.to raise_error(Puppet::Error)
       end
     end
 
     it "should not raise an error if the file is missing" do
-      expect(@autoload.load("foo")).to eq(false)
+      expect(@autoload.load("foo", env)).to eq(false)
     end
 
     it "should register loaded files with the autoloader" do
       Puppet::FileSystem.stubs(:exist?).returns true
       Kernel.stubs(:load)
-      @autoload.load("myfile")
+      @autoload.load("myfile", env)
 
       expect(@autoload.class.loaded?("tmp/myfile.rb")).to be
-
-      $LOADED_FEATURES.delete("tmp/myfile.rb")
     end
 
     it "should be seen by loaded? on the instance using the short name" do
       Puppet::FileSystem.stubs(:exist?).returns true
       Kernel.stubs(:load)
-      @autoload.load("myfile")
+      @autoload.load("myfile", env)
 
       expect(@autoload.loaded?("myfile.rb")).to be
-
-      $LOADED_FEATURES.delete("tmp/myfile.rb")
     end
 
     it "should register loaded files with the main loaded file list so they are not reloaded by ruby" do
       Puppet::FileSystem.stubs(:exist?).returns true
       Kernel.stubs(:load)
 
-      @autoload.load("myfile")
-
-      expect($LOADED_FEATURES).to be_include("tmp/myfile.rb")
+      @autoload.load("myfile", env)
 
-      $LOADED_FEATURES.delete("tmp/myfile.rb")
+      expect($LOADED_FEATURES).to be_include(make_absolute("/a/tmp/myfile.rb"))
     end
 
     it "should load the first file in the searchpath" do
@@ -130,22 +162,18 @@ describe Puppet::Util::Autoload do
       Puppet::FileSystem.stubs(:exist?).returns true
       Kernel.expects(:load).with(make_absolute("/a/tmp/myfile.rb"), optionally(anything))
 
-      @autoload.load("myfile")
-
-      $LOADED_FEATURES.delete("tmp/myfile.rb")
+      @autoload.load("myfile", env)
     end
 
     it "should treat equivalent paths to a loaded file as loaded" do
       Puppet::FileSystem.stubs(:exist?).returns true
       Kernel.stubs(:load)
-      @autoload.load("myfile")
+      @autoload.load("myfile", env)
 
       expect(@autoload.class.loaded?("tmp/myfile")).to be
       expect(@autoload.class.loaded?("tmp/./myfile.rb")).to be
       expect(@autoload.class.loaded?("./tmp/myfile.rb")).to be
       expect(@autoload.class.loaded?("tmp/../tmp/myfile.rb")).to be
-
-      $LOADED_FEATURES.delete("tmp/myfile.rb")
     end
   end
 
@@ -165,14 +193,14 @@ describe Puppet::Util::Autoload do
       it "should die an if a #{error.to_s} exception is thrown" do
         Kernel.expects(:load).raises error
 
-        expect { @autoload.loadall }.to raise_error(Puppet::Error)
+        expect { @autoload.loadall(env) }.to raise_error(Puppet::Error)
       end
     end
 
     it "should require the full path to the file" do
       Kernel.expects(:load).with(make_absolute("/a/foo/file.rb"), optionally(anything))
 
-      @autoload.loadall
+      @autoload.loadall(env)
     end
   end
 
@@ -190,19 +218,19 @@ describe Puppet::Util::Autoload do
     end
 
     it "#changed? should return true for a file that was not loaded" do
-      expect(@autoload.class.changed?(@file_a)).to be
+      expect(@autoload.class.changed?(@file_a, env)).to be
     end
 
     it "changes should be seen by changed? on the instance using the short name" do
       File.stubs(:mtime).returns(@first_time)
       Puppet::FileSystem.stubs(:exist?).returns true
       Kernel.stubs(:load)
-      @autoload.load("myfile")
+      @autoload.load("myfile", env)
       expect(@autoload.loaded?("myfile")).to be
-      expect(@autoload.changed?("myfile")).not_to be
+      expect(@autoload.changed?("myfile", env)).not_to be
 
       File.stubs(:mtime).returns(@second_time)
-      expect(@autoload.changed?("myfile")).to be
+      expect(@autoload.changed?("myfile", env)).to be
 
       $LOADED_FEATURES.delete("tmp/myfile.rb")
     end
@@ -218,14 +246,14 @@ describe Puppet::Util::Autoload do
         File.stubs(:mtime).with(@file_a).returns(@first_time + 60)
         Puppet::FileSystem.stubs(:exist?).with(@file_a).returns true
         Kernel.expects(:load).with(@file_a, optionally(anything))
-        @autoload.class.reload_changed
+        @autoload.class.reload_changed(env)
       end
 
       it "should do nothing if the file is deleted" do
         File.stubs(:mtime).with(@file_a).raises(Errno::ENOENT)
         Puppet::FileSystem.stubs(:exist?).with(@file_a).returns false
         Kernel.expects(:load).never
-        @autoload.class.reload_changed
+        @autoload.class.reload_changed(env)
       end
     end
 
@@ -242,7 +270,7 @@ describe Puppet::Util::Autoload do
         Puppet::FileSystem.stubs(:exist?).with(@file_b).returns true
         File.stubs(:mtime).with(@file_b).returns @first_time
         Kernel.expects(:load).with(@file_b, optionally(anything))
-        @autoload.class.reload_changed
+        @autoload.class.reload_changed(env)
         expect(@autoload.class.send(:loaded)["file"]).to eq([@file_b, @first_time])
       end
 
@@ -254,7 +282,7 @@ describe Puppet::Util::Autoload do
         File.stubs(:mtime).with(@file_a).returns @first_time
         Puppet::FileSystem.stubs(:exist?).with(@file_a).returns true
         Kernel.expects(:load).with(@file_a, optionally(anything))
-        @autoload.class.reload_changed
+        @autoload.class.reload_changed(env)
         expect(@autoload.class.send(:loaded)["file"]).to eq([@file_a, @first_time])
       end
     end
@@ -266,7 +294,7 @@ describe Puppet::Util::Autoload do
       expect(Puppet::Util::Autoload.cleanpath(path)).to eq(path)
     end
 
-    describe "on Windows", :if => Puppet.features.microsoft_windows? do
+    describe "on Windows", :if => Puppet::Util::Platform.windows? do
       it "should convert c:\ to c:/" do
         expect(Puppet::Util::Autoload.cleanpath('c:\\')).to eq('c:/')
       end

data/spec/unit/util/character_encoding_spec.rb

@@ -183,47 +183,4 @@ describe Puppet::Util::CharacterEncoding do
       end
     end
   end
-
-  describe "::scrub" do
-    let(:utf_8_string_to_scrub) { "\xfdfoo".force_encoding(Encoding::UTF_8) } # invalid in UTF-8
-    # The invalid-ness of this string comes from unpaired surrogates, ie:
-    #  "any value in the range D80016 to DBFF16 not followed by a value in the
-    #  range DC0016 to DFFF16, or any value in the range DC0016 to DFFF16 not
-    #  preceded by a value in the range D80016 to DBFF16"
-    # http://unicode.org/faq/utf_bom.html#utf16-7
-    # "a\ud800b"
-    # We expect the "b" to be replaced as that is what makes the string invalid
-    let(:utf_16LE_string_to_scrub) { [97, 237, 160, 128, 98].pack('C*').force_encoding(Encoding::UTF_16LE) } # invalid in UTF-16
-    let(:invalid_non_utf) { "foo\u2603".force_encoding(Encoding::EUC_KR) } # EUC_KR foosnowman!
-
-    it "should defer to String#scrub if defined", :if => String.method_defined?(:scrub) do
-      result = Puppet::Util::CharacterEncoding.scrub(utf_8_string_to_scrub)
-      # The result should have the UTF-8 replacement character if we're using Ruby scrub
-      expect(result).to eq("\uFFFDfoo".force_encoding(Encoding::UTF_8))
-      expect(result.bytes.to_a).to eq([239, 191, 189, 102, 111, 111])
-    end
-
-    context "when String#scrub is not defined" do
-      it "should still issue unicode replacement characters if the string is UTF-8" do
-        utf_8_string_to_scrub.stubs(:respond_to?).with(:scrub).returns(false)
-        result = Puppet::Util::CharacterEncoding.scrub(utf_8_string_to_scrub)
-        expect(result).to eq("\uFFFDfoo".force_encoding(Encoding::UTF_8))
-      end
-
-      it "should still issue unicode replacement characters if the string is UTF-16LE" do
-        utf_16LE_string_to_scrub.stubs(:respond_to?).with(:scrub).returns(false)
-        result = Puppet::Util::CharacterEncoding.scrub(utf_16LE_string_to_scrub)
-        # Bytes of replacement character on UTF_16LE are [253, 255]
-        # We just check for bytes because something (ruby?) interprets this array of bytes as:
-        # (97) (237 160) (128 253 255) rather than (97) (237 160 128) (253 255)
-        expect(result).to eq([97, 237, 160, 128, 253, 255].pack('C*').force_encoding(Encoding::UTF_16LE))
-      end
-
-      it "should issue '?' characters if the string is not one of UTF_8 or UTF_16LE" do
-        invalid_non_utf.stubs(:respond_to?).with(:scrub).returns(false)
-        result = Puppet::Util::CharacterEncoding.scrub(invalid_non_utf)
-        expect(result).to eq("foo???".force_encoding(Encoding::EUC_KR))
-      end
-    end
-  end
 end

data/spec/unit/util/checksums_spec.rb

@@ -10,7 +10,7 @@ describe Puppet::Util::Checksums do
     @summer = Puppet::Util::Checksums
   end
 
-  content_sums = [:md5, :md5lite, :sha1, :sha1lite, :sha256, :sha256lite]
+  content_sums = [:md5, :md5lite, :sha1, :sha1lite, :sha256, :sha256lite, :sha512, :sha384, :sha224]
   file_only = [:ctime, :mtime, :none]
 
   content_sums.each do |sumtype|
@@ -42,7 +42,7 @@ describe Puppet::Util::Checksums do
   end
 
   %w{{md5}asdfasdf {sha1}asdfasdf {ctime}asdasdf {mtime}asdfasdf 
-     {sha256}asdfasdf {sha256lite}asdfasdf}.each do |sum|
+     {sha256}asdfasdf {sha256lite}asdfasdf {sha512}asdfasdf {sha384}asdfasdf {sha224}asdfasdf}.each do |sum|
     it "should consider #{sum} to be a checksum" do
       expect(@summer).to be_checksum(sum)
     end
@@ -66,7 +66,7 @@ describe Puppet::Util::Checksums do
     expect(@summer.sumtype("asdfasdfa")).to be_nil
   end
 
-  {:md5 => Digest::MD5, :sha1 => Digest::SHA1, :sha256 => Digest::SHA256}.each do |sum, klass|
+  {:md5 => Digest::MD5, :sha1 => Digest::SHA1, :sha256 => Digest::SHA256, :sha512 => Digest::SHA512, :sha384 => Digest::SHA384}.each do |sum, klass|
     describe("when using #{sum}") do
       it "should use #{klass} to calculate string checksums" do
         klass.expects(:hexdigest).with("mycontent").returns "whatever"

data/spec/unit/util/diff_spec.rb

@@ -4,12 +4,16 @@ require 'puppet/util/diff'
 require 'puppet/util/execution'
 
 describe Puppet::Util::Diff do
+  let(:baz_output) { Puppet::Util::Execution::ProcessOutput.new('baz', 0) }
+
   describe ".diff" do
     it "should execute the diff command with arguments" do
       Puppet[:diff] = 'foo'
       Puppet[:diff_args] = 'bar'
 
-      Puppet::Util::Execution.expects(:execute).with(['foo', 'bar', 'a', 'b'], {:failonfail => false, :combine => false}).returns('baz')
+      Puppet::Util::Execution.expects(:execute)
+        .with(['foo', 'bar', 'a', 'b'], {:failonfail => false, :combine => false})
+        .returns(baz_output)
       expect(subject.diff('a', 'b')).to eq('baz')
     end
 
@@ -17,7 +21,9 @@ describe Puppet::Util::Diff do
       Puppet[:diff] = 'foo'
       Puppet[:diff_args] = 'bar qux'
 
-      Puppet::Util::Execution.expects(:execute).with(['foo', 'bar', 'qux', 'a', 'b'], anything).returns('baz')
+      Puppet::Util::Execution.expects(:execute)
+        .with(['foo', 'bar', 'qux', 'a', 'b'], anything)
+        .returns(baz_output)
       expect(subject.diff('a', 'b')).to eq('baz')
     end
 
@@ -25,7 +31,9 @@ describe Puppet::Util::Diff do
       Puppet[:diff] = 'foo'
       Puppet[:diff_args] = ''
 
-      Puppet::Util::Execution.expects(:execute).with(['foo', 'a', 'b'], {:failonfail => false, :combine => false}).returns('baz')
+      Puppet::Util::Execution.expects(:execute)
+        .with(['foo', 'a', 'b'], {:failonfail => false, :combine => false})
+        .returns(baz_output)
       expect(subject.diff('a', 'b')).to eq('baz')
     end
 

data/spec/unit/util/docs_spec.rb

@@ -69,7 +69,7 @@ EOT
     it "has no side effects on original input string" do
       input       = "First line \n        second line \n        \n            indented line \n        \n        last line\n\n"
       clean_input = "First line \n        second line \n        \n            indented line \n        \n        last line\n\n"
-      not_used = Puppet::Util::Docs.scrub(input)
+      Puppet::Util::Docs.scrub(input)
       expect(input).to eq clean_input
     end
 

data/spec/unit/util/errors_spec.rb

@@ -32,6 +32,6 @@ describe Puppet::Util::Errors do
   it "should have a method for converting error context into a string" do
     @tester.file = "/my/file"
     @tester.line = 50
-    expect(@tester.error_context).to eq(" at /my/file:50")
+    expect(@tester.error_context).to eq(" (file: /my/file, line: 50)")
   end
 end