packaging 0.99.0

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

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

@@ -0,0 +1,36 @@
+# -*- ruby -*-
+require 'spec_helper'
+
+describe "Pkg::Util::Git_tag" do
+  context "parse_ref!" do
+    it "fails for a ref that doesn't exist'" do
+      expect { Pkg::Util::Git_tag.new("git://github.com/puppetlabs/leatherman.git", "garbagegarbage") }.to raise_error(RuntimeError, /ERROR : Not a ref or sha!/)
+    end
+  end
+
+  context "sha?" do
+    it "sets ref type as a sha when passed a sha" do
+      git_tag = Pkg::Util::Git_tag.new("git://github.com/puppetlabs/leatherman.git", "4eef05389ebf418b62af17406c7f9f13fa51f975")
+      expect(git_tag.sha?).to eq(true)
+    end
+  end
+
+  context "branch?" do
+    it "sets ref type as a branch when passed a branch" do
+      git_tag = Pkg::Util::Git_tag.new("git://github.com/puppetlabs/leatherman.git", "master")
+      expect(git_tag.branch?).to eq(true)
+    end
+  end
+
+  context "tag?" do
+    it "sets ref type as a tag when passed a tag" do
+      git_tag = Pkg::Util::Git_tag.new("git://github.com/puppetlabs/leatherman.git", "tags/0.6.2")
+      expect(git_tag.tag?).to eq(true)
+    end
+
+    it "sets ref type as a tag when passed a fully qualified tag" do
+      git_tag = Pkg::Util::Git_tag.new("git://github.com/puppetlabs/leatherman.git", "refs/tags/0.6.2")
+      expect(git_tag.tag?).to eq(true)
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe "Pkg::Util::Gpg" do
+  let(:gpg)      { "/local/bin/gpg" }
+  let(:keychain) { "/usr/local/bin/keychain" }
+  let(:gpg_key)  { "abcd1234" }
+  let(:target_file) { "/tmp/file" }
+
+  before(:each) do
+    reset_env(['RPM_GPG_AGENT'])
+    Pkg::Config.gpg_key = gpg_key
+  end
+
+  describe '#key' do
+    it "fails if Pkg::Config.gpg_key isn't set" do
+      allow(Pkg::Config).to receive(:gpg_key).and_return(nil)
+      expect { Pkg::Util::Gpg.key }.to raise_error(RuntimeError)
+    end
+    it "fails if Pkg::Config.gpg_key is an empty string" do
+      allow(Pkg::Config).to receive(:gpg_key).and_return('')
+      expect { Pkg::Util::Gpg.key }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '#kill_keychain' do
+    it "doesn't reload the keychain if already loaded" do
+      Pkg::Util::Gpg.instance_variable_set("@keychain_loaded", TRUE)
+      Pkg::Util::Gpg.should_receive(:kill_keychain).never
+      Pkg::Util::Gpg.should_receive(:start_keychain).never
+      Pkg::Util::Gpg.load_keychain
+      Pkg::Util::Gpg.instance_variable_set("@keychain_loaded", nil)
+    end
+
+    it "doesn't reload the keychain if ENV['RPM_GPG_AGENT'] is set" do
+      ENV['RPM_GPG_AGENT'] = 'blerg'
+      Pkg::Util::Gpg.should_receive(:kill_keychain).never
+      Pkg::Util::Gpg.should_receive(:start_keychain).never
+      Pkg::Util::Gpg.load_keychain
+    end
+
+    it 'kills and starts the keychain if not loaded already' do
+      Pkg::Util::Gpg.instance_variable_set("@keychain_loaded", nil)
+      Pkg::Util::Gpg.should_receive(:kill_keychain).once
+      Pkg::Util::Gpg.should_receive(:start_keychain).once
+      Pkg::Util::Gpg.load_keychain
+    end
+  end
+
+  describe '#sign_file' do
+    it 'adds special flags if RPM_GPG_AGENT is set' do
+      ENV['RPM_GPG_AGENT'] = 'blerg'
+      additional_flags = "--no-tty --use-agent"
+      Pkg::Util::Tool.should_receive(:find_tool).with('gpg').and_return(gpg)
+      Pkg::Util::Execution.should_receive(:capture3).with("#{gpg}\s#{additional_flags}\s--armor --detach-sign -u #{gpg_key} #{target_file}")
+      Pkg::Util::Gpg.sign_file(target_file)
+    end
+
+    it 'signs without extra flags when RPM_GPG_AGENT is not set' do
+      Pkg::Util::Tool.should_receive(:find_tool).with('gpg').and_return(gpg)
+      Pkg::Util::Execution.should_receive(:capture3).with("#{gpg}\s\s--armor --detach-sign -u #{gpg_key} #{target_file}")
+      Pkg::Util::Gpg.sign_file(target_file)
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+# -*- ruby -*-
+require 'spec_helper'
+
+describe Pkg::Util::Jenkins do
+  let(:build_host) {"Jenkins-foo"}
+  let(:name) {"job-foo"}
+  around do |example|
+    old_build_host = Pkg::Config.jenkins_build_host
+    Pkg::Config.jenkins_build_host = build_host
+    example.run
+    Pkg::Config.jenkins_build_host = old_build_host
+  end
+
+  describe "#create_jenkins_job" do
+    let(:xml_file) {"bar.xml"}
+
+    it "should call curl_form_data with the correct arguments" do
+      Pkg::Util::Net.should_receive(:curl_form_data).with("http://#{build_host}/createItem?name=#{name}", ["-H", '"Content-Type: application/xml"', "--data-binary", "@#{xml_file}"])
+      Pkg::Util::Jenkins.create_jenkins_job(name, xml_file)
+    end
+  end
+
+  describe "#jenkins_job_exists?" do
+
+    it "should call curl_form_data with correct arguments" do
+      Pkg::Util::Net.should_receive(:curl_form_data).with("http://#{build_host}/job/#{name}/config.xml", ["--silent", "--fail"], :quiet => true).and_return(['output', 0])
+      Pkg::Util::Execution.should_receive(:success?).and_return(true)
+      Pkg::Util::Jenkins.jenkins_job_exists?(name)
+    end
+
+    it "should return false on job not existing" do
+      Pkg::Util::Net.should_receive(:curl_form_data).with("http://#{build_host}/job/#{name}/config.xml", ["--silent", "--fail"], :quiet => true).and_return(['output', 1])
+      Pkg::Util::Execution.should_receive(:success?).and_return(false)
+      Pkg::Util::Jenkins.jenkins_job_exists?(name).should be_false
+    end
+
+    it "should return false if curl_form_data raised a runtime error" do
+      Pkg::Util::Net.should_receive(:curl_form_data).with("http://#{build_host}/job/#{name}/config.xml", ["--silent", "--fail"], :quiet => true).and_return(false)
+      Pkg::Util::Jenkins.jenkins_job_exists?(name).should be_false
+    end
+
+    it "should return true when job exists" do
+      Pkg::Util::Net.should_receive(:curl_form_data).with("http://#{build_host}/job/#{name}/config.xml", ["--silent", "--fail"], :quiet => true).and_return(['output', 0])
+      Pkg::Util::Execution.should_receive(:success?).and_return(true)
+      Pkg::Util::Jenkins.jenkins_job_exists?(name).should be_true
+    end
+  end
+
+  describe '#poll_jenkins_job' do
+    let(:job_url) { "http://cat.meow/" }
+    let(:build_url) { "#{job_url}/1" }
+    let(:result) { "SUCCESS" }
+    let(:job_hash) { {'lastBuild' => { 'url' => build_url } }}
+    let(:build_hash) { {'result' => result, 'building' => false } }
+
+    before :each do
+      subject.stub(:get_jenkins_info).with(job_url).and_return(job_hash)
+      subject.stub(:wait_for_build).with(build_url).and_return(build_hash)
+    end
+
+    context "when polling the given url" do
+      it "return the resulting build_hash when build completes successfully" do
+        subject.poll_jenkins_job(job_url)
+      end
+    end
+  end
+
+  describe '#wait_for_build' do
+    let(:job_url) { "http://cat.meow/" }
+    let(:build_url) { "#{job_url}/1" }
+    let(:build_hash) { {'building' => false } }
+
+    context "when waiting for the given build to finish" do
+      it "return the resulting build_hash when build completes successfully" do
+        subject.should_receive(:get_jenkins_info).with(job_url).and_return(build_hash)
+        subject.wait_for_build(job_url)
+      end
+    end
+  end
+
+  describe '#get_jenkins_info' do
+    let(:url) { "http://cat.meow/" }
+    let(:uri) { URI(url) }
+    let(:response) { double }
+    let(:valid_json) { "{\"employees\":[
+    {\"firstName\":\"John\", \"lastName\":\"Doe\"},
+    {\"firstName\":\"Anna\", \"lastName\":\"Smith\"},
+    {\"firstName\":\"Peter\", \"lastName\":\"Jones\"} ]}" }
+
+    before :each do
+      response.stub(:body).and_return( valid_json )
+      response.stub(:code).and_return( '200' )
+      Pkg::Util::Jenkins.should_receive(:URI).and_return(uri)
+    end
+
+    context "when making HTTP GET request to given url" do
+      it "should return Hash of JSON contents when response is non-error" do
+        Net::HTTP.should_receive(:get_response).with(uri).and_return(response)
+        subject.get_jenkins_info(url)
+      end
+
+      it "should raise Runtime error when response is error" do
+        response.stub(:code).and_return( '400' )
+        Net::HTTP.should_receive(:get_response).with(uri).and_return(response)
+        expect{
+          subject.get_jenkins_info(url)
+        }.to raise_error(Exception, /Unable to query .*, please check that it is valid./)
+      end
+    end
+  end
+
+end