packaging 0.88.77

data/spec/lib/packaging/platforms_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+describe 'Pkg::Platforms' do
+  describe '#by_package_format' do
+    it 'should return an array of platforms that use a given format' do
+      deb_platforms = ['debian', 'ubuntu']
+      rpm_platforms = ['aix', 'el', 'fedora', 'redhatfips', 'sles']
+      expect(Pkg::Platforms.by_package_format('deb')).to match_array(deb_platforms)
+      expect(Pkg::Platforms.by_package_format('rpm')).to match_array(rpm_platforms)
+    end
+  end
+
+  describe '#formats' do
+    it 'should return all package formats' do
+      fmts = ['rpm', 'deb', 'dmg', 'svr4', 'ips', 'msi']
+      expect(Pkg::Platforms.formats).to match_array(fmts)
+    end
+  end
+
+  describe '#supported_platforms' do
+    it 'should return all supported platforms' do
+      platforms = ['aix', 'debian', 'el', 'fedora', 'osx', 'redhatfips', 'sles', 'solaris', 'ubuntu', 'windows', 'windowsfips']
+      expect(Pkg::Platforms.supported_platforms).to match_array(platforms)
+    end
+  end
+
+  describe '#versions_for_platform' do
+    it 'should return all supported versions for a given platform' do
+      expect(Pkg::Platforms.versions_for_platform('el')).to match_array(['5', '6', '7', '8'])
+    end
+
+    it 'should raise an error if given a nonexistent platform' do
+      expect{Pkg::Platforms.versions_for_platform('notaplatform') }.to raise_error
+    end
+  end
+
+  describe '#codenames' do
+    it 'should return all codenames for a given platform' do
+      codenames = ['focal', 'bionic', 'buster', 'cosmic', 'jessie', 'stretch', 'trusty', 'xenial']
+      expect(Pkg::Platforms.codenames).to match_array(codenames)
+    end
+  end
+
+  describe '#codename_to_platform_version' do
+    it 'should return the platform and version corresponding to a given codename' do
+      expect(Pkg::Platforms.codename_to_platform_version('xenial')).to eq(['ubuntu', '16.04'])
+    end
+
+    it 'should fail if given nil as a codename' do
+      expect{Pkg::Platforms.codename_to_platform_version(nil)}.to raise_error
+    end
+  end
+
+  describe '#codename_for_platform_version' do
+    it 'should return the codename corresponding to a given platform and version' do
+      expect(Pkg::Platforms.codename_for_platform_version('ubuntu', '16.04')).to eq('xenial')
+    end
+  end
+
+  describe '#arches_for_codename' do
+    it 'should return an array of arches corresponding to a given codename' do
+      expect(Pkg::Platforms.arches_for_codename('xenial')).to match_array(['amd64', 'i386', 'ppc64el'])
+    end
+
+    it 'should be able to include source archietectures' do
+      expect(Pkg::Platforms.arches_for_codename('xenial', true)).to match_array(["amd64", "i386", "ppc64el", "source"])
+    end
+  end
+
+  describe '#codename_to_tags' do
+    it 'should return an array of platform tags corresponding to a given codename' do
+      expect(Pkg::Platforms.codename_to_tags('xenial')).to match_array(['ubuntu-16.04-i386', 'ubuntu-16.04-amd64', "ubuntu-16.04-ppc64el"])
+    end
+  end
+
+  describe '#arches_for_platform_version' do
+    it 'should return an array of arches for a given platform and version' do
+      expect(Pkg::Platforms.arches_for_platform_version('sles', '12')).to match_array(['x86_64', 'ppc64le'])
+    end
+
+    it 'should be able to include source architectures' do
+      expect(Pkg::Platforms.arches_for_platform_version('sles', '12', true)).to match_array(["SRPMS", "ppc64le", "x86_64"])
+    end
+  end
+
+  describe '#platform_tags' do
+    it 'should return an array of platform tags' do
+      tags = Pkg::Platforms.platform_tags
+      expect(tags).to be_instance_of(Array)
+      expect(tags.count).to be > 0
+    end
+
+    it 'should include a basic platform' do
+      tags = Pkg::Platforms.platform_tags
+      expect(tags).to include('el-7-x86_64')
+    end
+  end
+
+  describe '#platform_lookup' do
+    ['osx-10.15-x86_64', 'osx-11-x86_64'].each do |platform|
+      it 'should return a hash of platform info' do
+        expect(Pkg::Platforms.platform_lookup(platform)).to be_instance_of(Hash)
+      end
+  
+      it 'should include at least arch and package format keys' do
+        expect(Pkg::Platforms.platform_lookup(platform).keys).to include(:architectures)
+        expect(Pkg::Platforms.platform_lookup(platform).keys).to include(:package_format)
+      end
+    end 
+  end
+
+  describe '#get_attribute' do
+    it 'returns info about a given platform' do
+      expect(Pkg::Platforms.get_attribute('el-6-x86_64', :signature_format)).to eq('v4')
+    end
+
+    it 'fails with a reasonable error when specified attribute is not defined' do
+      expect { Pkg::Platforms.get_attribute('osx-10.15-x86_64', :signature_format) }.to raise_error(/doesn't have information/)
+    end
+  end
+
+  describe '#package_format_for_tag' do
+    it 'should return the package format for a given platform tag' do
+      expect(Pkg::Platforms.package_format_for_tag('windows-2012-x86')).to eq('msi')
+    end
+  end
+
+  describe '#parse_platform_tag' do
+    test_cases = {
+      'debian-9-amd64' => ['debian', '9', 'amd64'],
+      'windows-2012-x86' => ['windows', '2012', 'x86'],
+      'windowsfips-2012-x64' => ['windowsfips', '2012', 'x64'],
+      'el-7-x86_64' => ['el', '7', 'x86_64'],
+      'el-6' => ['el', '6', ''],
+      'xenial-amd64' => ['ubuntu', '16.04', 'amd64'],
+      'xenial' => ['ubuntu', '16.04', ''],
+      'windows-2012' => ['windows', '2012', ''],
+      'redhatfips-7-x86_64' => ['redhatfips', '7', 'x86_64'],
+      'el-7-SRPMS' => ['el', '7', 'SRPMS'],
+      'ubuntu-16.04-source' => ['ubuntu', '16.04', 'source'],
+    }
+
+    fail_cases = [
+      'debian-4-amd64',
+      'el-x86_64',
+      'nothing',
+      'windows-x86',
+      'el-7-notarch',
+      'debian-7-x86_64',
+      'el-7-source',
+      'debian-7-SRPMS',
+    ]
+
+    test_cases.each do |platform_tag, results|
+      it "returns an array for #{platform_tag}" do
+        expect(Pkg::Platforms.parse_platform_tag(platform_tag)).to match_array(results)
+      end
+    end
+
+    fail_cases.each do |platform_tag|
+      it "fails out for #{platform_tag}" do
+        expect { Pkg::Platforms.parse_platform_tag(platform_tag)}.to raise_error
+      end
+    end
+  end
+
+  describe '#generic_platform_tag' do
+    it 'fails for unsupported platforms' do
+      expect { Pkg::Platforms.generic_platform_tag('butts') }.to raise_error
+    end
+
+    it 'returns a supported platform tag containing the supplied platform' do
+      Pkg::Platforms.supported_platforms.each do |platform|
+        expect(Pkg::Platforms.platform_tags).to include(Pkg::Platforms.generic_platform_tag(platform))
+      end
+    end
+  end
+end

data/spec/lib/packaging/repo_spec.rb

@@ -0,0 +1,135 @@
+# -*- ruby -*-
+require 'spec_helper'
+describe "#Pkg::Repo" do
+  let(:platform_repo_stub) do
+    [
+      {"name"=>"el-4-i386", "repo_location"=>"repos/el/4/**/i386"},
+      {"name"=>"el-5-i386", "repo_location"=>"repos/el/5/**/i386"},
+      {"name"=>"el-6-i386", "repo_location"=>"repos/el/6/**/i386"}
+    ]
+  end
+  describe "#create_signed_repo_archive" do
+    it "should change to the correct dir" do
+      allow(Pkg::Util::Tool).to receive(:check_tool).and_return("tarcommand")
+      allow(Pkg::Config).to receive(:project).and_return("project")
+      allow(Pkg::Util::Version).to receive(:dot_version).and_return("1.1.1")
+      allow(Pkg::Util::File).to receive(:empty_dir?).and_return(false)
+      allow(Pkg::Util::Execution).to receive(:capture3)
+
+      expect(Dir).to receive(:chdir).with('pkg/project/1.1.1').and_yield
+      Pkg::Repo.create_signed_repo_archive("/path", "project-debian-6-i386", "version")
+    end
+
+    it 'should use a ref if ref is specified as versioning' do
+      allow(Pkg::Util::Tool).to receive(:check_tool).and_return('tarcommand')
+      allow(Dir).to receive(:chdir).with('pkg').and_yield
+      allow(Pkg::Util::File).to receive(:empty_dir?).and_return(false)
+      allow(Pkg::Util::Execution).to receive(:capture3)
+
+      expect(Pkg::Config).to receive(:project).and_return('project')
+      expect(Pkg::Config).to receive(:ref).and_return('AAAAAAAAAAAAAAA')
+      expect(Dir).to receive(:chdir).with('pkg/project/AAAAAAAAAAAAAAA').and_yield
+      Pkg::Repo.create_signed_repo_archive('/path', 'project-debian-6-i386', 'ref')
+    end
+
+    it 'should use dot versions if version is specified as versioning' do
+      allow(Pkg::Util::Tool).to receive(:check_tool).and_return('tarcommand')
+      allow(Dir).to receive(:chdir).with('pkg').and_yield
+      allow(Pkg::Util::File).to receive(:empty_dir?).and_return(false)
+      allow(Pkg::Util::Execution).to receive(:capture3)
+
+      expect(Pkg::Config).to receive(:project).and_return('project')
+      expect(Pkg::Util::Version).to receive(:dot_version).and_return('1.1.1')
+      expect(Dir).to receive(:chdir).with('pkg/project/1.1.1').and_yield
+      Pkg::Repo.create_signed_repo_archive('/path', 'project-debian-6-i386', 'version')
+    end
+
+    it 'should fail if ENV["FAIL_ON_MISSING_TARGET"] is true and empty_dir? is also true' do
+      allow(Pkg::Util::Tool).to receive(:check_tool).and_return('tarcommand')
+      allow(Pkg::Config).to receive(:project).and_return('project')
+      allow(Pkg::Util::Version).to receive(:dot_version).and_return('1.1.1')
+      allow(Pkg::Util::Execution).to receive(:capture3)
+      allow(Dir).to receive(:chdir).with('pkg').and_yield
+      allow(Dir).to receive(:chdir).with('project/1.1.1').and_yield
+      allow(Pkg::Util::File).to receive(:empty_dir?).and_return(true)
+      ENV['FAIL_ON_MISSING_TARGET'] = 'true'
+
+      expect{Pkg::Repo.create_signed_repo_archive('/path', 'project-debian-6-i386', 'version')}.to raise_error(RuntimeError, 'Error: missing packages under /path')
+    end
+
+    it "should only warn if ENV['FAIL_ON_MISSING_TARGET'] is false and empty_dir? is true" do
+      allow(Pkg::Util::Tool).to receive(:check_tool).and_return("tarcommand")
+      allow(Pkg::Config).to receive(:project).and_return("project")
+      allow(Pkg::Util::Version).to receive(:dot_version).and_return("1.1.1")
+      allow(Pkg::Util::Execution).to receive(:capture3)
+      allow(Dir).to receive(:chdir).with("pkg/project/1.1.1").and_yield
+      allow(Pkg::Util::File).to receive(:empty_dir?).and_return(true)
+      ENV['FAIL_ON_MISSING_TARGET'] = "false"
+
+      expect{Pkg::Repo.create_signed_repo_archive("/path", "project-debian-6-i386", "version")}.not_to raise_error
+    end
+
+    it 'should invoke tar correctly' do
+      allow(Pkg::Util::Tool).to receive(:check_tool).and_return('tarcommand')
+      allow(Pkg::Config).to receive(:project).and_return('project')
+      allow(Pkg::Util::Version).to receive(:dot_version).and_return('1.1.1')
+      allow(Dir).to receive(:chdir).with('pkg/project/1.1.1').and_yield
+      allow(Pkg::Util::File).to receive(:empty_dir?).and_return(false)
+
+      expect(Pkg::Util::Execution).to receive(:capture3).with('tarcommand --owner=0 --group=0 --create --gzip --file repos/project-debian-6-i386.tar.gz /path')
+      Pkg::Repo.create_signed_repo_archive('/path', 'project-debian-6-i386', 'version')
+    end
+  end
+
+  describe '#create_signed_repo_archive' do
+    it 'should invoke create_signed_repo_archive correctly for multiple entries in platform_repos' do
+      allow(Pkg::Config).to receive(:platform_repos).and_return(platform_repo_stub)
+      allow(Pkg::Config).to receive(:project).and_return('project')
+      allow(Pkg::Util::Version).to receive(:dot_version).and_return('1.1.1')
+      allow(Dir).to receive(:chdir).with('pkg/project/1.1.1').and_yield
+
+      expect(Pkg::Repo).to receive(:create_signed_repo_archive).with('repos/el/4/**/i386', 'project-el-4-i386', 'version')
+      expect(Pkg::Repo).to receive(:create_signed_repo_archive).with('repos/el/5/**/i386', 'project-el-5-i386', 'version')
+      expect(Pkg::Repo).to receive(:create_signed_repo_archive).with('repos/el/6/**/i386', 'project-el-6-i386', 'version')
+
+      allow(Pkg::Util::Execution).to receive(:capture3)
+      Pkg::Repo.create_all_repo_archives('project', 'version')
+    end
+  end
+
+  describe "#argument_required?" do
+    let(:repo_command) { "some command with __REPO_PATH__ but not repo name or anything" }
+    let(:required_arg) { 'repo_path' }
+    let(:optional_arg) { 'repo_name' }
+
+    it 'should return true if command requires arg' do
+      expect(Pkg::Repo.argument_required?(required_arg, repo_command)).to be_true
+    end
+
+    it 'should return false if command does not need arg' do
+      expect(Pkg::Repo.argument_required?(optional_arg, repo_command)).to be_false
+    end
+  end
+
+  describe "#update_repo" do
+    let(:remote_host) { 'weth.delivery.puppetlabs.net' }
+    let(:repo_command) { "some command with __REPO_NAME__ and __REPO_PATH__ and stuff" }
+    let(:repo_name) { 'puppet5' }
+    let(:repo_path) { '/opt/repository/apt' }
+    let(:apt_releases) { ['stretch', 'trusty', 'xenial'] }
+
+    before(:each) do
+      allow(Pkg::Util::Gpg).to receive(:key)
+      allow(Pkg::Config).to receive(:apt_releases).and_return(apt_releases)
+    end
+
+    it 'should fail if required params are nil' do
+      expect{ Pkg::Repo.update_repo(remote_host, repo_command, { :repo_path => repo_path }) }.to raise_error(RuntimeError, /Missing required argument 'repo_name'/)
+    end
+
+    it 'should execute command if optional params are nil' do
+      expect(Pkg::Util::Net).to receive(:remote_execute).with(remote_host, "some command with #{repo_name} and #{repo_path} and stuff")
+      Pkg::Repo.update_repo(remote_host, repo_command, { :repo_name => repo_name, :repo_path => repo_path })
+    end
+  end
+end

data/spec/lib/packaging/retrieve_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+require 'packaging/retrieve'
+require 'packaging/paths'
+
+describe 'Pkg::Retrieve' do
+  local_target = 'pkg'
+  remote_target = 'repos'
+  project = 'puppet-agent'
+  ref = 'b25e64984dd505391f248fe5501ad81e2645b6d2'
+  foss_platforms = ['el-7-x86_64', 'ubuntu-16.04-amd64', 'osx-10.15-x86_64', 'osx-11-x86_64', 'windows-2012-x64']
+  platform_data = {:platform_data => {
+    'aix-7.1-power' => {:artifact => './aix/7.1/PC1/ppc/puppet-agent-5.3.2.155.gb25e649-1.aix7.1.ppc.rpm'},
+    'el-7-x86_64' => {:artifact => './el/7/PC1/x86_64/puppet-agent-5.3.2.155.gb25e649-1.el7.x86_64.rpm'},
+    'osx-10.15-x86_64' => {:artifact => './apple/10.15/PC1/x86_64/puppet-agent-5.3.2.155.gb25e649-1.osx10.15.dmg'},
+    'osx-11-x86_64' => {:artifact => './apple/11/PC1/x86_64/puppet-agent-5.3.2.155.gb25e649-1.osx11.dmg'},
+    'sles-11-i386' => {:artifact => './sles/11/PC1/i386/puppet-agent-5.3.2.155.gb25e649-1.sles11.i386.rpm'},
+    'solaris-10-sparc' => {:artifact => './solaris/10/PC1/puppet-agent-5.3.2.155.gb25e649-1.sparc.pkg.gz'},
+    'ubuntu-16.04-amd64' => {:artifact => './deb/xenial/PC1/puppet-agent_5.3.2.155.gb25e649-1xenial_amd64.deb'},
+    'windows-2012-x64' => {:artifact => './windows/puppet-agent-x64.msi'},
+  }}
+  build_url = "builds.delivery.puppetlabs.net/#{project}/#{ref}/#{remote_target}"
+  build_path = "/opt/jenkins-builds/#{project}/#{ref}/#{remote_target}"
+
+  before :each do
+    allow(Pkg::Config).to receive(:project).and_return(project)
+    allow(Pkg::Config).to receive(:ref).and_return(ref)
+    allow(Pkg::Config).to receive(:foss_platforms).and_return(foss_platforms)
+    allow(File).to receive(:readable?).with("#{local_target}/#{ref}.yaml").and_return(true)
+    allow(Pkg::Util::Serialization).to receive(:load_yaml).and_return(platform_data)
+  end
+
+  describe '#default_wget_command' do
+    let(:options) { [
+      "--quiet",
+      "--recursive",
+      "--no-parent",
+      "--no-host-directories",
+      "--level=0",
+      "--cut-dirs=3",
+      "--directory-prefix=#{local_target}",
+      "--reject='index*",
+    ] }
+    before :each do
+      allow(Pkg::Util::Tool).to receive(:check_tool).with('wget').and_return('wget')
+    end
+    context 'when no options passed' do
+      it 'should include default options' do
+        options.each do |option|
+          expect(Pkg::Retrieve.default_wget_command(local_target, build_url)).to include(option)
+        end
+      end
+    end
+    context 'when options are passed' do
+      it 'should add to existing options' do
+        options.push('--convert-links')
+        options.each do |option|
+          expect(Pkg::Retrieve.default_wget_command(local_target, build_url, {'convert-links' => true})).to include(option)
+        end
+      end
+      it 'should replace default values' do
+        options.push('--level=1').delete('--level=0')
+        expect(Pkg::Retrieve.default_wget_command(local_target, build_url, {'level' => 1})).to_not include('--level=0')
+        options.each do |option|
+          expect(Pkg::Retrieve.default_wget_command(local_target, build_url, {'level' => 1})).to include(option)
+        end
+      end
+    end
+  end
+
+  describe '#foss_only_retrieve' do
+    it 'should fail without foss_platforms' do
+      allow(Pkg::Config).to receive(:foss_platforms).and_return(nil)
+      expect { Pkg::Retrieve.foss_only_retrieve(build_url, local_target) }.to raise_error(/I don't know anything about FOSS_PLATFORMS/)
+    end
+
+    it 'should fail if cannot read <ref>.yaml' do
+      allow(File).to receive(:readable?).with("#{local_target}/#{ref}.yaml").and_return(false)
+      expect { Pkg::Retrieve.foss_only_retrieve(build_url, local_target) }.to raise_error(/Couldn't read #{ref}.yaml/)
+    end
+
+    it 'should retrieve foss_only packages' do
+      expect(Pkg::Retrieve).to receive(:default_wget).exactly(1 + foss_platforms.count).times
+      Pkg::Retrieve.foss_only_retrieve(build_url, local_target)
+    end
+  end
+
+  describe '#retrieve_all' do
+    it 'should try to use wget first' do
+      expect(Pkg::Retrieve).to receive(:default_wget)
+      Pkg::Retrieve.retrieve_all(build_url, build_path, local_target)
+    end
+
+    it 'should use rsync if wget is not found' do
+      allow(Pkg::Util::Tool).to receive(:find_tool).with('wget').and_return(nil)
+      expect(Pkg::Util::Net).to receive(:rsync_from)
+      Pkg::Retrieve.retrieve_all(build_url, build_path, local_target)
+    end
+  end
+end
+

data/spec/lib/packaging/rpm/repo_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe "Pkg::Rpm::Repo" do
+  let(:wget)          { "/opt/tools/bin/wget" }
+  let(:builds_server) { "saturn.puppetlabs.net" }
+  let(:project)       { "rpm_repos" }
+  let(:ref)           { "1234abcd" }
+  let(:base_url)      { "http://#{builds_server}/#{project}/#{ref}" }
+  let(:mocks)         { ["el-5-i386", "el-5-x86_64", "el-5-SRPMS"] }
+  let(:wget_results)  {
+                        mocks.map do |mock|
+                          dist, version, arch = mock.split('-')
+                          "http://#{builds_server}/#{project}/#{ref}/repos/#{dist}/#{version}/products/#{arch}/repodata/"
+                        end.join("\n")
+                      }
+  let(:wget_garbage)  { "\nother things\n and an index\nhttp://somethingelse.com" }
+  let(:repo_configs)  { mocks.map { |mock| "pkg/repo_configs/rpm/pl-#{project}-#{ref}-#{mock}.repo" } }
+
+  # Setup and tear down for the tests
+  around do |example|
+    orig_server = Pkg::Config.builds_server
+    orig_host = Pkg::Config.distribution_server
+    orig_project = Pkg::Config.project
+    orig_ref = Pkg::Config.ref
+    orig_repo_path = Pkg::Config.jenkins_repo_path
+    Pkg::Config.builds_server = builds_server
+    Pkg::Config.project = project
+    Pkg::Config.ref = ref
+    example.run
+    Pkg::Config.builds_server = orig_server
+    Pkg::Config.distribution_server = orig_host
+    Pkg::Config.project = orig_project
+    Pkg::Config.ref = orig_ref
+    Pkg::Config.jenkins_repo_path = orig_repo_path
+  end
+
+  describe "#generate_repo_configs" do
+    it "fails if wget isn't available" do
+      Pkg::Util::Tool.stub(:find_tool).with("wget", {:required => true}) {false}
+      expect {Pkg::Rpm::Repo.generate_repo_configs}.to raise_error(RuntimeError)
+    end
+
+    it "warns if there are no rpm repos available for the build" do
+      Pkg::Util::Tool.should_receive(:find_tool).with("wget", {:required => true}).and_return(wget)
+      Pkg::Util::Execution.should_receive(:capture3).with("#{wget} --spider -r -l 5 --no-parent #{base_url}/repos/ 2>&1").and_return("")
+      Pkg::Rpm::Repo.should_receive(:warn).with("No rpm repos were found to generate configs from!")
+      Pkg::Rpm::Repo.generate_repo_configs
+    end
+
+    it "writes the expected repo configs to disk" do
+      Pkg::Util::Tool.should_receive(:find_tool).with("wget", {:required => true}).and_return(wget)
+      Pkg::Util::Execution.should_receive(:capture3).with("#{wget} --spider -r -l 5 --no-parent #{base_url}/repos/ 2>&1").and_return(wget_results + wget_garbage)
+      wget_results.split.each do |result|
+        cur_result = result.chomp('repodata/')
+        Pkg::Util::Execution.should_receive(:capture3).with("#{wget} --spider -r -l 1 --no-parent #{cur_result} 2>&1").and_return("#{cur_result}/thing.rpm")
+      end
+      FileUtils.should_receive(:mkdir_p).with("pkg/repo_configs/rpm")
+      config = []
+      repo_configs.each_with_index do |repo_config, i|
+        Pkg::Paths.should_receive(:tag_from_artifact_path).and_return(mocks[i])
+        Pkg::Platforms.should_receive(:parse_platform_tag).and_return(mocks[i].split('-'))
+        config[i] = double(File)
+        File.should_receive(:open).with(repo_config, 'w').and_yield(config[i])
+        config[i].should_receive(:puts)
+      end
+      Pkg::Rpm::Repo.generate_repo_configs
+    end
+  end
+
+  describe "#retrieve_repo_configs" do
+    it "fails if wget isn't available" do
+      Pkg::Util::Tool.stub(:find_tool).with("wget", {:required => true}) {false}
+      expect {Pkg::Rpm::Repo.generate_repo_configs}.to raise_error(RuntimeError)
+    end
+
+    it "fails if there are no deb repos available for the build" do
+      Pkg::Util::Tool.should_receive(:find_tool).with("wget", {:required => true}).and_return(wget)
+      FileUtils.should_receive(:mkdir_p).with("pkg/repo_configs").and_return(true)
+      Pkg::Util::Execution.should_receive(:capture3).with("#{wget} -r -np -nH --cut-dirs 3 -P pkg/repo_configs --reject 'index*' #{base_url}/repo_configs/rpm/").and_raise(RuntimeError)
+      expect {Pkg::Rpm::Repo.retrieve_repo_configs}.to raise_error(RuntimeError, /Couldn't retrieve rpm yum repo configs/)
+    end
+  end
+
+  describe "#create_local_repos" do
+    let(:command) { "/usr/bin/make some repos" }
+    let(:target_directory) { "/tmp/dir/thing" }
+
+    it "makes a repo in the target directory" do
+      Pkg::Rpm::Repo.should_receive(:repo_creation_command).with(target_directory).and_return("run this thing")
+      Pkg::Util::Execution.should_receive(:capture3).with("bash -c 'run this thing'")
+      Pkg::Rpm::Repo.create_local_repos(target_directory)
+    end
+  end
+
+  describe "#create_remote_repos" do
+    let(:command) { "/usr/bin/make some repos" }
+    let(:artifact_directory) { "/tmp/dir/thing" }
+    let(:pkg_directories) { ['el-6-i386', 'el/7/x86_64'] }
+
+    it "makes a repo in the target directory" do
+      File.stub(:join) {artifact_directory}
+      Pkg::Repo.should_receive(:directories_that_contain_packages).and_return(pkg_directories)
+      Pkg::Repo.should_receive(:populate_repo_directory)
+      Pkg::Rpm::Repo.should_receive(:repo_creation_command).and_return(command)
+      Pkg::Util::Net.should_receive(:remote_execute).with(Pkg::Config.distribution_server, command)
+      Pkg::Rpm::Repo.should_receive(:generate_repo_configs)
+      Pkg::Rpm::Repo.should_receive(:ship_repo_configs)
+      Pkg::Util::Net.should_receive(:remote_execute).with(Pkg::Config.distribution_server, "rm -f #{artifact_directory}/repos/.lock" )
+      Pkg::Rpm::Repo.create_remote_repos
+    end
+  end
+
+  describe "#ship_repo_configs" do
+    it "warn if there are no repo configs to ship" do
+      Pkg::Util::File.should_receive(:empty_dir?).with("pkg/repo_configs/rpm").and_return(true)
+      Pkg::Rpm::Repo.should_receive(:warn).with("No repo configs have been generated! Try pl:rpm_repo_configs.")
+      Pkg::Rpm::Repo.ship_repo_configs
+    end
+
+    it "ships repo configs to the build server" do
+      Pkg::Config.jenkins_repo_path = "/a/b/c/d"
+      Pkg::Config.project = "thing2"
+      Pkg::Config.ref = "abcd1234"
+      Pkg::Config.distribution_server = "a.host.that.wont.exist"
+      repo_dir = "#{Pkg::Config.jenkins_repo_path}/#{Pkg::Config.project}/#{Pkg::Config.ref}/repo_configs/rpm"
+      Pkg::Util::File.should_receive(:empty_dir?).with("pkg/repo_configs/rpm").and_return(false)
+      Pkg::Util::RakeUtils.should_receive(:invoke_task).with("pl:fetch")
+      Pkg::Util::Net.should_receive(:remote_execute).with(Pkg::Config.distribution_server, "mkdir -p #{repo_dir}")
+      Pkg::Util::Execution.should_receive(:retry_on_fail).with(:times => 3)
+      Pkg::Rpm::Repo.ship_repo_configs
+    end
+  end
+end