packaging 0.88.77

data/spec/lib/packaging/sign_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+require 'packaging/sign'
+
+describe 'Pkg::Sign' do
+  describe 'Pkg::Sign::Rpm' do
+
+    before :each do
+      allow(Pkg::Config).to receive(:gpg_key).and_return('7F438280EF8D349F')
+    end
+
+    describe '#has_sig?' do
+      let(:rpm) { 'foo.rpm' }
+      let(:el7_signed_response) { <<-DOC
+Header V4 RSA/SHA256 Signature, key ID ef8d349f: NOKEY
+Header SHA1 digest: OK (3cb7e9861e8bc09783a1b6c8d88243a3c16daa81)
+V4 RSA/SHA256 Signature, key ID ef8d349f: NOKEY
+MD5 digest: OK (d5f06ba2a9053de532326d0659ec0d11)
+DOC
+      }
+      let(:el5_signed_response) { <<-DOC
+Header V3 RSA/SHA1 signature: NOKEY, key ID ef8d349f
+Header SHA1 digest: OK (12ea7bd578097a3aecc5deb8ada6aca6147d68e3)
+V3 RSA/SHA1 signature: NOKEY, key ID ef8d349f
+MD5 digest: OK (27353c6153068a3c9902fcb4ad5b8b92)
+DOC
+      }
+      let(:sles12_signed_response) { <<-DOC
+Header V4 RSA/SHA256 Signature, key ID ef8d349f: NOKEY
+Header SHA1 digest: OK (e713487cf21ebeb933aefd5ec9211a34603233d2)
+V4 RSA/SHA256 Signature, key ID ef8d349f: NOKEY
+MD5 digest: OK (3093a09ac39bc17751f913e19ca74432)
+DOC
+      }
+      let(:unsigned_response) { <<-DOC
+Header SHA1 digest: OK (f9404cc95f200568c2dbb1fd24e1119e3e4a40a9)
+MD5 digest: OK (816095f3cee145091c3fa07a0915ce85)
+DOC
+      }
+      it 'returns true if rpm has been signed (el7)' do
+        allow(Pkg::Sign::Rpm).to receive(:`).and_return(el7_signed_response)
+        expect(Pkg::Sign::Rpm.has_sig?(rpm)).to be true
+      end
+      it 'returns true if rpm has been signed (el5)' do
+        allow(Pkg::Sign::Rpm).to receive(:`).and_return(el5_signed_response)
+        expect(Pkg::Sign::Rpm.has_sig?(rpm)).to be true
+      end
+      it 'returns true if rpm has been signed (sles12)' do
+        allow(Pkg::Sign::Rpm).to receive(:`).and_return(sles12_signed_response)
+        expect(Pkg::Sign::Rpm.has_sig?(rpm)).to be true
+      end
+      it 'returns false if rpm has not been signed' do
+        allow(Pkg::Sign::Rpm).to receive(:`).and_return(unsigned_response)
+        expect(Pkg::Sign::Rpm.has_sig?(rpm)).to be false
+      end
+      it 'fails with unexpected output' do
+        allow(Pkg::Sign::Rpm).to receive(:`).and_return('something that is definitely not a normal response')
+        expect { Pkg::Sign::Rpm.has_sig?(rpm) }.to raise_error(RuntimeError, /Something went wrong checking the signature/)
+      end
+      it 'fails if gpg_key is not set' do
+        allow(Pkg::Config).to receive(:gpg_key).and_return(nil)
+        expect { Pkg::Sign::Rpm.has_sig?(rpm) }.to raise_error(RuntimeError, /You need to set `gpg_key` in your build defaults./)
+      end
+    end
+
+    describe '#sign_all' do
+      let(:rpm_directory) { 'foo' }
+      let(:rpms_not_to_sign) { [
+        "#{rpm_directory}/aix/7.1/PC1/ppc/puppet-agent-5.5.3-1.aix7.1.ppc.rpm",
+      ] }
+      let(:v3_rpms) { [
+        "#{rpm_directory}/el/5/PC1/i386/puppet-agent-5.5.3-1.el5.i386.rpm",
+        "#{rpm_directory}/sles/11/PC1/x86_64/puppet-agent-5.5.3-1.sles11.x86_64.rpm",
+      ] }
+      let(:v4_rpms) { [
+        "#{rpm_directory}/el/7/PC1/aarch64/puppet-agent-5.5.3-1.el7.aarch64.rpm",
+      ] }
+      let(:rpms) { rpms_not_to_sign + v3_rpms + v4_rpms }
+      let(:already_signed_rpms) { [
+        "#{rpm_directory}/el/6/PC1/x86_64/puppet-agent-5.5.3-1.el6.x86_64.rpm",
+      ] }
+      let(:noarch_rpms) { [
+        "#{rpm_directory}/el/6/puppet5/i386/puppetserver-5.3.3-1.el6.noarch.rpm",
+        "#{rpm_directory}/el/6/puppet5/x86_64/puppetserver-5.3.3-1.el6.noarch.rpm",
+        "#{rpm_directory}/el/7/puppet5/i386/puppetserver-5.3.3-1.el7.noarch.rpm",
+        "#{rpm_directory}/el/7/puppet5/x86_64/puppetserver-5.3.3-1.el7.noarch.rpm",
+        "#{rpm_directory}/sles/12/puppet5/i386/puppetserver-5.3.3-1.sles12.noarch.rpm",
+        "#{rpm_directory}/sles/12/puppet5/x86_64/puppetserver-5.3.3-1.sles12.noarch.rpm"
+      ] }
+
+      it 'signs both v3 and v4 rpms' do
+        allow(Dir).to receive(:[]).with("#{rpm_directory}/**/*.rpm").and_return(rpms)
+        rpms.each do |rpm|
+          allow(Pkg::Sign::Rpm).to receive(:has_sig?).and_return(false)
+        end
+        expect(Pkg::Sign::Rpm).to receive(:legacy_sign).with(v3_rpms.join(' '))
+        expect(Pkg::Sign::Rpm).to receive(:sign).with(v4_rpms.join(' '))
+        Pkg::Sign::Rpm.sign_all(rpm_directory)
+      end
+
+      it 'does not sign AIX rpms' do
+        allow(Dir).to receive(:[]).with("#{rpm_directory}/**/*.rpm").and_return(rpms_not_to_sign)
+        allow(Pkg::Sign::Rpm).to receive(:has_sig?)
+        expect(Pkg::Sign::Rpm).to_not receive(:legacy_sign)
+        expect(Pkg::Sign::Rpm).to_not receive(:sign)
+        Pkg::Sign::Rpm.sign_all(rpm_directory)
+      end
+
+      it 'does not sign already-signed rpms' do
+        allow(Dir).to receive(:[]).with("#{rpm_directory}/**/*.rpm").and_return(already_signed_rpms)
+        already_signed_rpms.each do |rpm|
+          allow(Pkg::Sign::Rpm).to receive(:has_sig?).and_return(true)
+        end
+        expect(Pkg::Sign::Rpm).to_not receive(:legacy_sign)
+        expect(Pkg::Sign::Rpm).to_not receive(:sign)
+        Pkg::Sign::Rpm.sign_all(rpm_directory)
+      end
+
+      it 'deletes and relinks rpms with the same basename' do
+        allow(Dir).to receive(:[]).with("#{rpm_directory}/**/*.rpm").and_return(noarch_rpms)
+        allow(Pkg::Sign::Rpm).to receive(:sign)
+        allow(Pkg::Sign::Rpm).to receive(:has_sig?)
+        expect(FileUtils).to receive(:rm).exactly(noarch_rpms.count/2).times
+        expect(FileUtils).to receive(:ln).exactly(noarch_rpms.count/2).times
+        Pkg::Sign::Rpm.sign_all(rpm_directory)
+      end
+
+      it 'does not fail if there are no rpms to sign' do
+        allow(Dir).to receive(:[]).with("#{rpm_directory}/**/*.rpm").and_return([])
+        expect(Pkg::Sign::Rpm.sign_all(rpm_directory)).to_not raise_error
+      end
+    end
+  end
+end

data/spec/lib/packaging/tar_spec.rb

@@ -0,0 +1,116 @@
+# -*- ruby -*-
+require 'spec_helper'
+
+describe "tar.rb" do
+  let(:project) { "packaging" }
+  let(:version) { "1.2.3" }
+  let(:files)   { [ "a", "b", "c" ] }
+  let(:templates) do
+    [
+      "ext/redhat/spec.erb",
+      { "source" => "ext/debian/control.erb", "target" => "ext/debian/not-a-control-file" },
+      "ext/debian/changelog.erb",
+      "ext/packaging/thing.erb"
+    ]
+  end
+  let(:expanded_templates) do
+    [
+      "#{PROJECT_ROOT}/ext/redhat/spec.erb",
+      { "source" => "ext/debian/control.erb", "target" => "ext/debian/not-a-control-file" },
+      "#{PROJECT_ROOT}/ext/debian/changelog.erb"
+    ]
+  end
+  before(:each) do
+    Pkg::Config.config_from_hash(
+      {
+        :templates      => templates,
+        :project        => project,
+        :version        => version,
+        :files          => files,
+        :project_root   => PROJECT_ROOT,
+        :packaging_root => "ext/packaging"
+      })
+  end
+
+  describe '#initialize' do
+    it 'should always mark ext/packaging and pkg directories as excluded files' do
+      Pkg::Config.tar_excludes = ['foo']
+      expect(Pkg::Tar.new.excludes).to eql(['foo', 'pkg', 'ext/packaging'])
+
+      Pkg::Config.tar_excludes = []
+      expect(Pkg::Tar.new.excludes).to eql(['pkg', 'ext/packaging'])
+    end
+
+    it 'should archive the entire project directory by default' do
+      Pkg::Config.files = nil
+      expect(Pkg::Tar.new.files).to eql(Dir.glob('*'))
+    end
+
+    it 'should archive the user-specified list of files' do
+      expect(Pkg::Tar.new.files).to eql(files)
+    end
+  end
+
+  describe "#expand_templates" do
+    it "should be invoked when Pkg::Config.templates is set" do
+      Pkg::Tar.any_instance.should_receive(:expand_templates)
+      Pkg::Tar.new
+    end
+
+    it "packaging templates should be filtered and paths should be expanded" do
+      templates.each do |temp|
+        if temp.is_a?(String)
+          Dir.stub(:glob).with(File.join(PROJECT_ROOT, temp)).and_return(File.join(PROJECT_ROOT, temp))
+        end
+      end
+
+      tar = Pkg::Tar.new
+      tar.templates = templates
+      tar.expand_templates
+      tar.templates.should eq expanded_templates
+    end
+  end
+
+  describe "#template" do
+    before(:each) do
+      Pkg::Config.templates = expanded_templates
+    end
+
+    it "should handle hashes and strings correctly" do
+      # Set up correct stubs and expectations
+      expanded_templates.each do |temp|
+        if temp.is_a?(String)
+          full_path_temp = File.join(PROJECT_ROOT, temp)
+          target = full_path_temp.sub(File.extname(full_path_temp), "")
+        elsif temp.is_a?(Hash)
+          full_path_temp = File.join(PROJECT_ROOT, temp["source"])
+          target = File.join(PROJECT_ROOT, temp["target"])
+        end
+
+        Dir.stub(:glob).with(full_path_temp).and_return(full_path_temp)
+        File.stub(:exist?).with(full_path_temp).and_return(true)
+        Pkg::Util::File.should_receive(:erb_file).with(full_path_temp, target, true, :binding => an_instance_of(Binding))
+      end
+
+      Pkg::Tar.new.template
+    end
+
+    it "should raise an error if the template source can't be found" do
+      # Set up correct stubs and expectations
+      expanded_templates.each do |temp|
+        if temp.is_a?(String)
+          full_path_temp = File.join(PROJECT_ROOT, temp)
+          target = full_path_temp.sub(File.extname(full_path_temp), "")
+        elsif temp.is_a?(Hash)
+          full_path_temp = File.join(PROJECT_ROOT, temp["source"])
+          target = File.join(PROJECT_ROOT, temp["target"])
+        end
+
+        Dir.stub(:glob).with(full_path_temp).and_return(full_path_temp)
+        File.stub(:exist?).with(full_path_temp).and_return(false)
+      end
+
+      expect { Pkg::Tar.new.template }.to raise_error RuntimeError
+    end
+  end
+end

data/spec/lib/packaging/util/execution_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe "Pkg::Util::Execution" do
+  let(:command)    { "/usr/bin/do-something-important --arg1=thing2" }
+  let(:output)     { "the command returns some really cool stuff that may be useful later" }
+
+  describe "#success?" do
+    it "should return false on failure" do
+      %x{false}
+      Pkg::Util::Execution.success?.should be_false
+    end
+
+    it "should return true on success" do
+      %x{true}
+      Pkg::Util::Execution.success?.should be_true
+    end
+
+    it "should return false when passed an exitstatus object from a failure" do
+      %x{false}
+      Pkg::Util::Execution.success?($?).should be_false
+    end
+
+    it "should return true when passed and exitstatus object from a success" do
+      %x{true}
+      Pkg::Util::Execution.success?($?).should be_true
+    end
+  end
+
+  describe "#ex" do
+    it "should raise an error if the command fails" do
+      Pkg::Util::Execution.should_receive(:`).with(command).and_return(true)
+      Pkg::Util::Execution.should_receive(:success?).and_return(false)
+      expect{ Pkg::Util::Execution.ex(command) }.to raise_error(RuntimeError)
+    end
+
+    it "should return the output of the command for success" do
+      Pkg::Util::Execution.should_receive(:`).with(command).and_return(output)
+      Pkg::Util::Execution.should_receive(:success?).and_return(true)
+      Pkg::Util::Execution.ex(command).should == output
+    end
+  end
+
+  describe "#capture3" do
+    it "should raise an error if the command fails" do
+      Open3.should_receive(:capture3).with(command).and_return([output, '', 1])
+      Pkg::Util::Execution.should_receive(:success?).with(1).and_return(false)
+      expect{ Pkg::Util::Execution.capture3(command) }.to raise_error(RuntimeError, /#{output}/)
+    end
+
+    it "should return the output of the command for success" do
+      Open3.should_receive(:capture3).with(command).and_return([output, '', 0])
+      Pkg::Util::Execution.should_receive(:success?).with(0).and_return(true)
+      Pkg::Util::Execution.capture3(command).should == [output, '', 0]
+    end
+  end
+end

data/spec/lib/packaging/util/file_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+describe "Pkg::Util::File" do
+  let(:source)     { "/tmp/placething.tar.gz" }
+  let(:target)     { "/tmp" }
+  let(:options)    { "--thing-for-tar" }
+  let(:tar)        { "/usr/bin/tar" }
+  let(:files)      { ["foo.rb", "foo/bar.rb"] }
+  let(:symlinks)   { ["bar.rb"] }
+  let(:dirs)       { ["foo"] }
+  let(:empty_dirs) { ["bar"] }
+
+
+  describe "#untar_into" do
+    before :each do
+      Pkg::Util::Tool.stub(:find_tool).with('tar', :required => true) { tar }
+    end
+
+    it "raises an exception if the source doesn't exist" do
+      Pkg::Util::File.should_receive(:file_exists?).with(source, {:required => true}).and_raise(RuntimeError)
+      Pkg::Util::Execution.should_not_receive(:capture3)
+      expect { Pkg::Util::File.untar_into(source) }.to raise_error(RuntimeError)
+    end
+
+    it "unpacks the tarball to the current directory if no target is passed" do
+      Pkg::Util::File.should_receive(:file_exists?).with(source, {:required => true}) { true }
+      Pkg::Util::Execution.should_receive(:capture3).with("#{tar}   -xf #{source}")
+      Pkg::Util::File.untar_into(source)
+    end
+
+    it "unpacks the tarball to the current directory with options if no target is passed" do
+      Pkg::Util::File.should_receive(:file_exists?).with(source, {:required => true}) { true }
+      Pkg::Util::Execution.should_receive(:capture3).with("#{tar} #{options}  -xf #{source}")
+      Pkg::Util::File.untar_into(source, nil, options)
+    end
+
+    it "unpacks the tarball into the target" do
+      File.stub(:capture3ist?).with(source) { true }
+      Pkg::Util::File.should_receive(:file_exists?).with(source, {:required => true}) { true }
+      Pkg::Util::File.should_receive(:file_writable?).with(target) { true }
+      Pkg::Util::Execution.should_receive(:capture3).with("#{tar}  -C #{target} -xf #{source}")
+      Pkg::Util::File.untar_into(source, target)
+    end
+
+    it "unpacks the tarball into the target with options passed" do
+      File.stub(:capture3ist?).with(source) { true }
+      Pkg::Util::File.should_receive(:file_exists?).with(source, {:required => true}) { true }
+      Pkg::Util::File.should_receive(:file_writable?).with(target) { true }
+      Pkg::Util::Execution.should_receive(:capture3).with("#{tar} #{options} -C #{target} -xf #{source}")
+      Pkg::Util::File.untar_into(source, target, options)
+    end
+  end
+
+  describe "#files_with_ext" do
+    it "returns nothing if there are no files with that extension" do
+      Pkg::Util::File.files_with_ext("./spec/fixtures/configs/components", ".fake").should be_empty
+    end
+
+    it "returns only the files with that extension" do
+      expect(Pkg::Util::File.files_with_ext("./spec/fixtures/configs/components", ".json")).to include("./spec/fixtures/configs/components/test_file.json")
+      expect(Pkg::Util::File.files_with_ext("./spec/fixtures/configs/components", ".json")).to include("./spec/fixtures/configs/components/test_file_2.json")
+    end
+  end
+
+  describe "#install_files_into_dir" do
+    it "selects the correct files to install" do
+      Pkg::Config.load_defaults
+      workdir = Pkg::Util::File.mktemp
+      patterns = []
+
+      # Set up a bunch of default settings for these to avoid a lot more stubbing in each section below
+      File.stub(:file?) { false }
+      File.stub(:symlink?) { false }
+      File.stub(:directory?) { false }
+      Pkg::Util::File.stub(:empty_dir?) { false }
+
+      # Files should have the path made and should be copied
+      files.each do |file|
+        File.stub(:file?).with(file).and_return(true)
+        Dir.stub(:[]).with(file).and_return(file)
+        FileUtils.should_receive(:mkpath).with(File.dirname(File.join(workdir, file)), :verbose => false)
+        FileUtils.should_receive(:cp).with(file, File.join(workdir, file), :verbose => false, :preserve => true)
+        patterns << file
+      end
+
+      # Symlinks should have the path made and should be copied
+      symlinks.each do |file|
+        File.stub(:symlink?).with(file).and_return(true)
+        Dir.stub(:[]).with(file).and_return(file)
+        FileUtils.should_receive(:mkpath).with(File.dirname(File.join(workdir, file)), :verbose => false)
+        FileUtils.should_receive(:cp).with(file, File.join(workdir, file), :verbose => false, :preserve => true)
+        patterns << file
+      end
+
+      # Dirs should be added to patterns but no acted upon
+      dirs.each do |dir|
+        File.stub(:directory?).with(dir).and_return(true)
+        Dir.stub(:[]).with("#{dir}/**/*").and_return(dir)
+        FileUtils.should_not_receive(:mkpath).with(File.dirname(File.join(workdir, dir)), :verbose => false)
+        FileUtils.should_not_receive(:cp).with(dir, File.join(workdir, dir), :verbose => false, :preserve => true)
+        patterns << dir
+      end
+
+      # Empty dirs should have the path created and nothing copied
+      empty_dirs.each do |dir|
+        Pkg::Util::File.stub(:empty_dir?).with(dir).and_return(true)
+        Dir.stub(:[]).with(dir).and_return(dir)
+        FileUtils.should_receive(:mkpath).with(File.join(workdir, dir), :verbose => false)
+        FileUtils.should_not_receive(:cp).with(dir, File.join(workdir, dir), :verbose => false, :preserve => true)
+        patterns << dir
+      end
+
+      Pkg::Util::File.install_files_into_dir(patterns, workdir)
+      FileUtils.rm_rf workdir
+    end
+  end
+
+  describe "#directories" do
+    it "returns nil if there is no directory" do
+      File.should_receive(:directory?).with("/tmp").and_return(false)
+      Pkg::Util::File.directories("/tmp").should be_nil
+    end
+
+    it "returns the empty array if there are no dirs in the directory" do
+      File.should_receive(:directory?).with("/tmp").and_return(true)
+      Dir.should_receive(:glob).with("*").and_return([])
+      Pkg::Util::File.directories("/tmp").should be_empty
+    end
+
+    it "returns an array of the top level directories inside a directory" do
+      File.stub(:directory?) { false }
+      ["/tmp", "/tmp/dir", "/tmp/other_dir"].each do |dir|
+        File.should_receive(:directory?).with(dir).and_return(true)
+      end
+      Dir.should_receive(:glob).with("*").and_return(["/tmp/file", "/tmp/dir", "/tmp/other_dir"])
+      Pkg::Util::File.directories("/tmp").should eq(["/tmp/dir", "/tmp/other_dir"])
+    end
+  end
+end

data/spec/lib/packaging/util/git_spec.rb

@@ -0,0 +1,160 @@
+# -*- ruby -*-
+require 'spec_helper'
+require 'packaging/util/git'
+
+# rubocop:disable Metrics/BlockLength
+describe 'Pkg::Util::Git' do
+  context '#commit_file' do
+    let(:file) { 'thing.txt' }
+    let(:message) { 'foo' }
+
+    it 'should commit a file with no message, giving changes as the message instead' do
+      allow(Pkg::Util::Git).to receive(:fail_unless_repo)
+      expect(Pkg::Util::Execution).to receive(:capture3).with("#{Pkg::Util::Tool::GIT} diff HEAD #{file}")
+      expect(Pkg::Util::Execution).to receive(:capture3).with("#{Pkg::Util::Tool::GIT} commit #{file} -m \"Commit changes in #{file}\" &> /dev/null")
+      Pkg::Util::Git.commit_file(file)
+    end
+
+    it 'should commit a file with foo as message' do
+      allow(Pkg::Util::Git).to receive(:fail_unless_repo)
+      expect(Pkg::Util::Execution).to receive(:capture3).with("#{Pkg::Util::Tool::GIT} diff HEAD #{file}")
+      expect(Pkg::Util::Execution).to receive(:capture3).with("#{Pkg::Util::Tool::GIT} commit #{file} -m \"Commit #{message} in #{file}\" &> /dev/null")
+      Pkg::Util::Git.commit_file(file, message)
+    end
+  end
+
+  context '#tag' do
+    let(:version) { '1.2.3' }
+    let(:gpg_key) { '1231242354asdfawd' }
+    around do |example|
+      prev_gpg_key = Pkg::Config.gpg_key
+      Pkg::Config.gpg_key = gpg_key
+      example.run
+      Pkg::Config.gpg_key = prev_gpg_key
+    end
+
+    it 'should not fail' do
+      allow(Pkg::Util::Git).to receive(:fail_unless_repo)
+      expect(Pkg::Util::Execution).to receive(:capture3).with("#{Pkg::Util::Tool::GIT} tag -s -u #{gpg_key} -m '#{version}' #{version}")
+      Pkg::Util::Git.tag(version)
+    end
+  end
+
+  context '#bundle' do
+    let(:treeish) { 'foo' }
+    let(:appendix) { 'append' }
+    let(:output_dir) { '/path/to/place' }
+    let(:version) { '1.2.3' }
+    let(:project) { 'fooproj' }
+    let(:string) { 'bar' }
+    let(:temp) { '/other/path/to/place' }
+    around do |example|
+      prev_project = Pkg::Config.project
+      prev_version = Pkg::Config.version
+      Pkg::Config.project = project
+      Pkg::Config.version = version
+      example.run
+      Pkg::Config.project = prev_project
+      Pkg::Config.version = prev_version
+    end
+
+    it 'should create a git bundle with random appendix and random output directory' do
+      allow(Pkg::Util::Git).to receive(:fail_unless_repo)
+      allow(Pkg::Util::File).to receive(:mktemp) { temp }
+      allow(Pkg::Util).to receive(:rand_string) { string }
+      expect(Pkg::Util::Execution).to receive(:capture3).with("#{Pkg::Util::Tool::GIT} bundle create #{temp}/#{project}-#{version}-#{string} #{treeish} --tags")
+      expect(Dir).to receive(:chdir).with(temp)
+      Pkg::Util::Git.bundle(treeish)
+    end
+
+    it 'should create a git bundle with random output directory' do
+      allow(Pkg::Util::Git).to receive(:fail_unless_repo)
+      allow(Pkg::Util::File).to receive(:mktemp) { temp }
+      expect(Pkg::Util::Execution).to receive(:capture3).with("#{Pkg::Util::Tool::GIT} bundle create #{temp}/#{project}-#{version}-#{appendix} #{treeish} --tags")
+      expect(Dir).to receive(:chdir).with(temp)
+      Pkg::Util::Git.bundle(treeish, appendix)
+    end
+
+    it 'should create a git bundle' do
+      allow(Pkg::Util::Git).to receive(:fail_unless_repo)
+      expect(Pkg::Util::Execution).to receive(:capture3).with("#{Pkg::Util::Tool::GIT} bundle create #{output_dir}/#{project}-#{version}-#{appendix} #{treeish} --tags")
+      expect(Dir).to receive(:chdir).with(output_dir)
+      Pkg::Util::Git.bundle(treeish, appendix, output_dir)
+    end
+  end
+
+  context '#pull' do
+    let(:remote) { 'rand.url' }
+    let(:branch) { 'foo' }
+
+    it 'should pull the branch' do
+      allow(Pkg::Util::Git).to receive(:fail_unless_repo)
+      expect(Pkg::Util::Execution).to receive(:capture3).with("#{Pkg::Util::Tool::GIT} pull #{remote} #{branch}")
+      Pkg::Util::Git.pull(remote, branch)
+    end
+  end
+
+  context '#describe' do
+    before(:each) do
+      @project_root = Dir.pwd
+      Pkg::Config.project_root = @project_root
+    end
+
+    let(:describe) { '0.5.0-25-g746e755-dirty' }
+    let(:describe_no_dirty) { '0.5.0-25-g746e755' }
+
+    it 'should default to --tags --dirty' do
+      expect(Pkg::Util::Execution).to receive(:capture3).with("#{Pkg::Util::Tool::GIT} describe --tags --dirty").and_return([describe, '', 0])
+      expect(Pkg::Util::Execution).to receive(:success?).with(0).and_return(true)
+      Pkg::Util::Git.describe
+    end
+
+    it 'should allow you to pass no arguments to describe' do
+      expect(Pkg::Util::Execution).to receive(:capture3).with("#{Pkg::Util::Tool::GIT} describe ").and_return([describe_no_dirty, '', 0])
+      expect(Pkg::Util::Execution).to receive(:success?).with(0).and_return(true)
+      Pkg::Util::Git.describe('')
+    end
+  end
+
+  context '#sha_or_tag' do
+    let(:sha) { '20a338b33e2fc1cbaee27b69de5eb2d06637a7c4' }
+    let(:tag) { '2.0.4' }
+
+    it 'returns a sha if the repo is not tagged' do
+      allow(Pkg::Util::Git).to receive(:ref_type) { 'sha' }
+      allow(Pkg::Util::Git).to receive(:sha) { sha }
+      expect(Pkg::Util::Git.sha_or_tag).to eq sha
+    end
+
+    it 'returns a tag if the repo is tagged' do
+      allow(Pkg::Util::Git).to receive(:ref_type) { 'tag' }
+      allow(Pkg::Util::Git).to receive(:describe) { tag }
+      expect(Pkg::Util::Git.sha_or_tag).to eq tag
+    end
+  end
+
+  context '#tagged?' do
+    let(:sha) { '20a338b33e2fc1cbaee27b69de5eb2d06637a7c4' }
+    let(:tag) { '2.0.4' }
+
+    it 'returns false if we are working on a sha' do
+      allow(Pkg::Util::Git).to receive(:ref_type) { 'tag' }
+      expect(Pkg::Util::Git.tagged?).to be true
+    end
+
+    it 'returns true if we are working on a tag' do
+      allow(Pkg::Util::Git).to receive(:ref_type) { 'sha' }
+      expect(Pkg::Util::Git.tagged?).to be false
+    end
+  end
+
+  context '#remote_tagged?' do
+    it 'reports Yes on tagged component' do
+      expect(Pkg::Util::Git.remote_tagged?('git://github.com/puppetlabs/leatherman.git', 'refs/tags/0.6.2')).to be(true)
+    end
+
+    it 'reports No on non-tagged component' do
+      expect(Pkg::Util::Git.remote_tagged?('git://github.com/puppetlabs/leatherman.git', '4eef05389ebf418b62af17406c7f9f13fa51f975')).to be(false)
+    end
+  end
+end