puppet 4.4.0-universal-darwin

data/spec/unit/util/autoload_spec.rb

@@ -0,0 +1,281 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/util/autoload'
+
+describe Puppet::Util::Autoload do
+  include PuppetSpec::Files
+
+  before do
+    @autoload = Puppet::Util::Autoload.new("foo", "tmp")
+
+    @loaded = {}
+    @autoload.class.stubs(:loaded).returns(@loaded)
+  end
+
+  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
+    end
+
+    it "should collect all of the lib directories that exist in the current environment's module path" do
+      dira = dir_containing('dir_a', {
+        "one" => {},
+        "two" => { "lib" => {} }
+      })
+
+      dirb = dir_containing('dir_a', {
+        "one" => {},
+        "two" => { "lib" => {} }
+      })
+
+      environment = Puppet::Node::Environment.create(:foo, [dira, dirb])
+
+      expect(@autoload.class.module_directories(environment)).to eq(["#{dira}/two/lib", "#{dirb}/two/lib"])
+    end
+
+    it "ignores missing module directories" do
+      environment = Puppet::Node::Environment.create(:foo, [File.expand_path('does/not/exist')])
+
+      expect(@autoload.class.module_directories(environment)).to be_empty
+    end
+
+    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
+      end
+    end
+
+    it "uses the configured environment 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
+      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)
+    end
+
+    it "does not split the Puppet[:libdir]" do
+      Puppet[:libdir] = "/libdir1#{File::PATH_SEPARATOR}/libdir2"
+
+      expect(@autoload.class.libdirs).to eq([Puppet[:libdir]])
+    end
+  end
+
+  describe "when loading a file" do
+    before do
+      @autoload.class.stubs(:search_directories).returns [make_absolute("/a")]
+      FileTest.stubs(:directory?).returns true
+      @time_a = Time.utc(2010, 'jan', 1, 6, 30)
+      File.stubs(:mtime).returns @time_a
+    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)
+      end
+    end
+
+    it "should not raise an error if the file is missing" do
+      expect(@autoload.load("foo")).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")
+
+      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")
+
+      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")
+
+      $LOADED_FEATURES.delete("tmp/myfile.rb")
+    end
+
+    it "should load the first file in the searchpath" do
+      @autoload.stubs(:search_directories).returns [make_absolute("/a"), make_absolute("/b")]
+      FileTest.stubs(:directory?).returns true
+      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")
+    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")
+
+      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
+
+  describe "when loading all files" do
+    before do
+      @autoload.class.stubs(:search_directories).returns [make_absolute("/a")]
+      FileTest.stubs(:directory?).returns true
+      Dir.stubs(:glob).returns [make_absolute("/a/foo/file.rb")]
+      Puppet::FileSystem.stubs(:exist?).returns true
+      @time_a = Time.utc(2010, 'jan', 1, 6, 30)
+      File.stubs(:mtime).returns @time_a
+
+      @autoload.class.stubs(:loaded?).returns(false)
+    end
+
+    [RuntimeError, LoadError, SyntaxError].each do |error|
+      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)
+      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
+    end
+  end
+
+  describe "when reloading files" do
+    before :each do
+      @file_a = make_absolute("/a/file.rb")
+      @file_b = make_absolute("/b/file.rb")
+      @first_time = Time.utc(2010, 'jan', 1, 6, 30)
+      @second_time = @first_time + 60
+    end
+
+    after :each do
+      $LOADED_FEATURES.delete("a/file.rb")
+      $LOADED_FEATURES.delete("b/file.rb")
+    end
+
+    it "#changed? should return true for a file that was not loaded" do
+      expect(@autoload.class.changed?(@file_a)).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")
+      expect(@autoload.loaded?("myfile")).to be
+      expect(@autoload.changed?("myfile")).not_to be
+
+      File.stubs(:mtime).returns(@second_time)
+      expect(@autoload.changed?("myfile")).to be
+
+      $LOADED_FEATURES.delete("tmp/myfile.rb")
+    end
+
+    describe "in one directory" do
+      before :each do
+        @autoload.class.stubs(:search_directories).returns [make_absolute("/a")]
+        File.expects(:mtime).with(@file_a).returns(@first_time)
+        @autoload.class.mark_loaded("file", @file_a)
+      end
+
+      it "should reload if mtime changes" 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
+      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
+      end
+    end
+
+    describe "in two directories" do
+      before :each do
+        @autoload.class.stubs(:search_directories).returns [make_absolute("/a"), make_absolute("/b")]
+      end
+
+      it "should load b/file when a/file is deleted" do
+        File.expects(:mtime).with(@file_a).returns(@first_time)
+        @autoload.class.mark_loaded("file", @file_a)
+        File.stubs(:mtime).with(@file_a).raises(Errno::ENOENT)
+        Puppet::FileSystem.stubs(:exist?).with(@file_a).returns false
+        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
+        expect(@autoload.class.send(:loaded)["file"]).to eq([@file_b, @first_time])
+      end
+
+      it "should load a/file when b/file is loaded and a/file is created" do
+        File.stubs(:mtime).with(@file_b).returns @first_time
+        Puppet::FileSystem.stubs(:exist?).with(@file_b).returns true
+        @autoload.class.mark_loaded("file", @file_b)
+
+        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
+        expect(@autoload.class.send(:loaded)["file"]).to eq([@file_a, @first_time])
+      end
+    end
+  end
+
+  describe "#cleanpath" do
+    it "should leave relative paths relative" do
+      path = "hello/there"
+      expect(Puppet::Util::Autoload.cleanpath(path)).to eq(path)
+    end
+
+    describe "on Windows", :if => Puppet.features.microsoft_windows? do
+      it "should convert c:\ to c:/" do
+        expect(Puppet::Util::Autoload.cleanpath('c:\\')).to eq('c:/')
+      end
+    end
+  end
+
+  describe "#expand" do
+    it "should expand relative to the autoloader's prefix" do
+      expect(@autoload.expand('bar')).to eq('tmp/bar')
+    end
+  end
+end

data/spec/unit/util/backups_spec.rb

@@ -0,0 +1,134 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/util/backups'
+
+describe Puppet::Util::Backups do
+  include PuppetSpec::Files
+
+  let(:bucket) { stub('bucket', :name => "foo") }
+  let!(:file) do
+    f = Puppet::Type.type(:file).new(:name => path, :backup => 'foo')
+    f.stubs(:bucket).returns(bucket)
+    f
+  end
+
+  describe "when backing up a file" do
+    let(:path) { make_absolute('/no/such/file') }
+
+    it "should noop if the file does not exist" do
+      file = Puppet::Type.type(:file).new(:name => path)
+
+      file.expects(:bucket).never
+      Puppet::FileSystem.expects(:exist?).with(path).returns false
+
+      file.perform_backup
+    end
+
+    it "should succeed silently if self[:backup] is false" do
+      file = Puppet::Type.type(:file).new(:name => path, :backup => false)
+
+      file.expects(:bucket).never
+      Puppet::FileSystem.expects(:exist?).never
+
+      file.perform_backup
+    end
+
+    it "a bucket should be used when provided" do
+      lstat_path_as(path, 'file')
+      bucket.expects(:backup).with(path).returns("mysum")
+      Puppet::FileSystem.expects(:exist?).with(path).returns(true)
+
+      file.perform_backup
+    end
+
+    it "should propagate any exceptions encountered when backing up to a filebucket" do
+      lstat_path_as(path, 'file')
+      bucket.expects(:backup).raises ArgumentError
+      Puppet::FileSystem.expects(:exist?).with(path).returns(true)
+
+      expect { file.perform_backup }.to raise_error(ArgumentError)
+    end
+
+    describe "and local backup is configured" do
+      let(:ext) { 'foobkp' }
+      let(:backup) { path + '.' + ext }
+      let(:file) { Puppet::Type.type(:file).new(:name => path, :backup => '.'+ext) }
+
+      it "should remove any local backup if one exists" do
+        lstat_path_as(backup, 'file')
+        Puppet::FileSystem.expects(:unlink).with(backup)
+        FileUtils.stubs(:cp_r)
+        Puppet::FileSystem.expects(:exist?).with(path).returns(true)
+
+        file.perform_backup
+      end
+
+      it "should fail when the old backup can't be removed" do
+        lstat_path_as(backup, 'file')
+        Puppet::FileSystem.expects(:unlink).with(backup).raises ArgumentError
+        FileUtils.expects(:cp_r).never
+        Puppet::FileSystem.expects(:exist?).with(path).returns(true)
+
+        expect { file.perform_backup }.to raise_error(Puppet::Error)
+      end
+
+      it "should not try to remove backups that don't exist" do
+        Puppet::FileSystem.expects(:lstat).with(backup).raises(Errno::ENOENT)
+        Puppet::FileSystem.expects(:unlink).with(backup).never
+        FileUtils.stubs(:cp_r)
+        Puppet::FileSystem.expects(:exist?).with(path).returns(true)
+
+        file.perform_backup
+      end
+
+      it "a copy should be created in the local directory" do
+        FileUtils.expects(:cp_r).with(path, backup, :preserve => true)
+        Puppet::FileSystem.stubs(:exist?).with(path).returns(true)
+
+        expect(file.perform_backup).to be_truthy
+      end
+
+      it "should propagate exceptions if no backup can be created" do
+        FileUtils.expects(:cp_r).raises ArgumentError
+
+        Puppet::FileSystem.stubs(:exist?).with(path).returns(true)
+        expect { file.perform_backup }.to raise_error(Puppet::Error)
+      end
+    end
+  end
+
+  describe "when backing up a directory" do
+    let(:path) { make_absolute('/my/dir') }
+    let(:filename) { File.join(path, 'file') }
+
+    it "a bucket should work when provided" do
+      File.stubs(:file?).with(filename).returns true
+      Find.expects(:find).with(path).yields(filename)
+
+      bucket.expects(:backup).with(filename).returns true
+
+      lstat_path_as(path, 'directory')
+
+      Puppet::FileSystem.stubs(:exist?).with(path).returns(true)
+      Puppet::FileSystem.stubs(:exist?).with(filename).returns(true)
+
+      file.perform_backup
+    end
+
+    it "should do nothing when recursing" do
+      file = Puppet::Type.type(:file).new(:name => path, :backup => 'foo', :recurse => true)
+
+      bucket.expects(:backup).never
+      stub_file = stub('file', :stat => stub('stat', :ftype => 'directory'))
+      Puppet::FileSystem.stubs(:new).with(path).returns stub_file
+      Find.expects(:find).never
+
+      file.perform_backup
+    end
+  end
+
+  def lstat_path_as(path, ftype)
+    Puppet::FileSystem.expects(:lstat).with(path).returns(stub('File::Stat', :ftype => ftype))
+  end
+end

data/spec/unit/util/checksums_spec.rb

@@ -0,0 +1,208 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/util/checksums'
+
+describe Puppet::Util::Checksums do
+  include PuppetSpec::Files
+
+  before do
+    @summer = Puppet::Util::Checksums
+  end
+
+  content_sums = [:md5, :md5lite, :sha1, :sha1lite, :sha256, :sha256lite]
+  file_only = [:ctime, :mtime, :none]
+
+  content_sums.each do |sumtype|
+    it "should be able to calculate #{sumtype} sums from strings" do
+      expect(@summer).to be_respond_to(sumtype)
+    end
+  end
+
+  content_sums.each do |sumtype|
+    it "should know the expected length of #{sumtype} sums" do
+      expect(@summer).to be_respond_to(sumtype.to_s + "_hex_length")
+    end
+  end
+
+  [content_sums, file_only].flatten.each do |sumtype|
+    it "should be able to calculate #{sumtype} sums from files" do
+      expect(@summer).to be_respond_to(sumtype.to_s + "_file")
+    end
+  end
+
+  [content_sums, file_only].flatten.each do |sumtype|
+    it "should be able to calculate #{sumtype} sums from stream" do
+      expect(@summer).to be_respond_to(sumtype.to_s + "_stream")
+    end
+  end
+
+  it "should have a method for determining whether a given string is a checksum" do
+    expect(@summer).to respond_to(:checksum?)
+  end
+
+  %w{{md5}asdfasdf {sha1}asdfasdf {ctime}asdasdf {mtime}asdfasdf 
+     {sha256}asdfasdf {sha256lite}asdfasdf}.each do |sum|
+    it "should consider #{sum} to be a checksum" do
+      expect(@summer).to be_checksum(sum)
+    end
+  end
+
+  %w{{nosuchsumthislong}asdfasdf {a}asdfasdf {ctime}}.each do |sum|
+    it "should not consider #{sum} to be a checksum" do
+      expect(@summer).not_to be_checksum(sum)
+    end
+  end
+
+  it "should have a method for stripping a sum type from an existing checksum" do
+    expect(@summer.sumtype("{md5}asdfasdfa")).to eq("md5")
+  end
+
+  it "should have a method for stripping the data from a checksum" do
+    expect(@summer.sumdata("{md5}asdfasdfa")).to eq("asdfasdfa")
+  end
+
+  it "should return a nil sumtype if the checksum does not mention a checksum type" do
+    expect(@summer.sumtype("asdfasdfa")).to be_nil
+  end
+
+  {:md5 => Digest::MD5, :sha1 => Digest::SHA1, :sha256 => Digest::SHA256}.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"
+        expect(@summer.send(sum, "mycontent")).to eq("whatever")
+      end
+
+      it "should use incremental #{klass} sums to calculate file checksums" do
+        digest = mock 'digest'
+        klass.expects(:new).returns digest
+
+        file = "/path/to/my/file"
+
+        fh = mock 'filehandle'
+        fh.expects(:read).with(4096).times(3).returns("firstline").then.returns("secondline").then.returns(nil)
+
+        File.expects(:open).with(file, "rb").yields(fh)
+
+        digest.expects(:<<).with "firstline"
+        digest.expects(:<<).with "secondline"
+        digest.expects(:hexdigest).returns :mydigest
+
+        expect(@summer.send(sum.to_s + "_file", file)).to eq(:mydigest)
+      end
+
+      it "should behave like #{klass} to calculate stream checksums" do
+        digest = mock 'digest'
+        klass.expects(:new).returns digest
+        digest.expects(:<<).with "firstline"
+        digest.expects(:<<).with "secondline"
+        digest.expects(:hexdigest).returns :mydigest
+
+        expect(@summer.send(sum.to_s + "_stream") do |checksum|
+          checksum << "firstline"
+          checksum << "secondline"
+        end).to eq(:mydigest)
+      end
+    end
+  end
+
+  {:md5lite => Digest::MD5, :sha1lite => Digest::SHA1, :sha256lite => Digest::SHA256}.each do |sum, klass|
+    describe("when using #{sum}") do
+      it "should use #{klass} to calculate string checksums from the first 512 characters of the string" do
+        content = "this is a test" * 100
+        klass.expects(:hexdigest).with(content[0..511]).returns "whatever"
+        expect(@summer.send(sum, content)).to eq("whatever")
+      end
+
+      it "should use #{klass} to calculate a sum from the first 512 characters in the file" do
+        digest = mock 'digest'
+        klass.expects(:new).returns digest
+
+        file = "/path/to/my/file"
+
+        fh = mock 'filehandle'
+        fh.expects(:read).with(512).returns('my content')
+
+        File.expects(:open).with(file, "rb").yields(fh)
+
+        digest.expects(:<<).with "my content"
+        digest.expects(:hexdigest).returns :mydigest
+
+        expect(@summer.send(sum.to_s + "_file", file)).to eq(:mydigest)
+      end
+
+      it "should use #{klass} to calculate a sum from the first 512 characters in a stream" do
+        digest = mock 'digest'
+        content = "this is a test" * 100
+        klass.expects(:new).returns digest
+        digest.expects(:<<).with content[0..511]
+        digest.expects(:hexdigest).returns :mydigest
+
+        expect(@summer.send(sum.to_s + "_stream") do |checksum|
+          checksum << content
+        end).to eq(:mydigest)
+      end
+
+      it "should use #{klass} to calculate a sum from the first 512 characters in a multi-part stream" do
+        digest = mock 'digest'
+        content = "this is a test" * 100
+        klass.expects(:new).returns digest
+        digest.expects(:<<).with content[0..5]
+        digest.expects(:<<).with content[6..510]
+        digest.expects(:<<).with content[511..511]
+        digest.expects(:hexdigest).returns :mydigest
+
+        expect(@summer.send(sum.to_s + "_stream") do |checksum|
+          checksum << content[0..5]
+          checksum << content[6..510]
+          checksum << content[511..-1]
+        end).to eq(:mydigest)
+      end
+    end
+  end
+
+  [:ctime, :mtime].each do |sum|
+    describe("when using #{sum}") do
+      it "should use the '#{sum}' on the file to determine the ctime" do
+        file = "/my/file"
+        stat = mock 'stat', sum => "mysum"
+        Puppet::FileSystem.expects(:stat).with(file).returns(stat)
+
+        expect(@summer.send(sum.to_s + "_file", file)).to eq("mysum")
+      end
+
+      it "should return nil for streams" do
+        expectation = stub "expectation"
+        expectation.expects(:do_something!).at_least_once
+        expect(@summer.send(sum.to_s + "_stream"){ |checksum| checksum << "anything" ; expectation.do_something!  }).to be_nil
+      end
+    end
+  end
+
+  describe "when using the none checksum" do
+    it "should return an empty string" do
+      expect(@summer.none_file("/my/file")).to eq("")
+    end
+
+    it "should return an empty string for streams" do
+      expectation = stub "expectation"
+      expectation.expects(:do_something!).at_least_once
+      expect(@summer.none_stream{ |checksum| checksum << "anything" ; expectation.do_something!  }).to eq("")
+    end
+  end
+
+  {:md5 => Digest::MD5, :sha1 => Digest::SHA1}.each do |sum, klass|
+    describe "when using #{sum}" do
+      let(:content) { "hello\r\nworld" }
+      let(:path) do
+        path = tmpfile("checksum_#{sum}")
+        File.open(path, 'wb') {|f| f.write(content)}
+        path
+      end
+
+      it "should preserve nl/cr sequences" do
+        expect(@summer.send(sum.to_s + "_file", path)).to eq(klass.hexdigest(content))
+      end
+    end
+  end
+end