packaging 0.108.2 → 0.109.0

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

@@ -1,15 +1,17 @@
 require 'spec_helper'
 
-describe "Pkg::Deb::Repo" do
-  let(:wget)          { "/opt/tools/bin/wget" }
-  let(:builds_server) { "saturn.puppetlabs.net" }
-  let(:project)       { "deb_repos" }
-  let(:ref)           { "1234abcd" }
+describe 'Pkg::Deb::Repo' do
+  let(:wget)          { '/opt/tools/bin/wget' }
+  let(:builds_server) { 'saturn.puppetlabs.net' }
+  let(:project)       { 'deb_repos' }
+  let(:ref)           { '1234abcd' }
   let(:base_url)      { "http://#{builds_server}/#{project}/#{ref}" }
   let(:cows)          { ["bionic", "focal", "buster", ""] }
-  let(:wget_results)  { cows.map {|cow| "#{base_url}/repos/apt/#{cow}" }.join("\n") }
+  let(:wget_results)  { cows.map { |cow| "#{base_url}/repos/apt/#{cow}" }.join("\n") }
   let(:wget_garbage)  { "\n and an index\nhttp://somethingelse.com/robots" }
-  let(:repo_configs)  { cows.reject {|cow| cow.empty?}.map {|dist| "pkg/repo_configs/deb/pl-#{project}-#{ref}-#{dist}.list" } }
+  let(:repo_configs)  do
+    cows.reject(&:empty?).map { |dist| "pkg/repo_configs/deb/pl-#{project}-#{ref}-#{dist}.list" }
+  end
 
   # Setup and tear down for the tests
   around do |example|
@@ -29,126 +31,186 @@ describe "Pkg::Deb::Repo" do
     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.should_receive(:find_tool).with("wget", {:required => true}).and_raise(RuntimeError)
-      expect {Pkg::Deb::Repo.generate_repo_configs}.to raise_error(RuntimeError)
+  describe '#generate_repo_configs' do
+    it 'fails if wget isn\'t available' do
+      expect(Pkg::Util::Tool)
+        .to receive(:find_tool)
+        .with('wget', { required: true })
+        .and_raise(RuntimeError)
+      expect { Pkg::Deb::Repo.generate_repo_configs }.to raise_error(RuntimeError)
     end
 
-    it "warns 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)
-      Pkg::Util::Execution.should_receive(:capture3).with("#{wget} --spider -r -l 1 --no-parent #{base_url}/repos/apt/ 2>&1").and_raise(RuntimeError)
-      Pkg::Deb::Repo.should_receive(:warn).with("No debian repos available for #{project} at #{ref}.")
+    it 'warns if there are no deb repos available for the build' do
+      expect(Pkg::Util::Tool)
+        .to receive(:find_tool)
+        .with('wget', { required: true })
+        .and_return(wget)
+      expect(Pkg::Util::Execution)
+        .to receive(:capture3)
+        .with("#{wget} --spider -r -l 1 --no-parent #{base_url}/repos/apt/ 2>&1")
+        .and_raise(RuntimeError)
+      expect(Pkg::Deb::Repo)
+        .to receive(:warn)
+        .with("No debian repos available for #{project} at #{ref}.")
       Pkg::Deb::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 1 --no-parent #{base_url}/repos/apt/ 2>&1").and_return(wget_results + wget_garbage)
-      FileUtils.should_receive(:mkdir_p).with("pkg/repo_configs/deb")
+    it 'writes the expected repo configs to disk' do
+      expect(Pkg::Util::Tool)
+        .to receive(:find_tool)
+        .with('wget', { required: true })
+        .and_return(wget)
+      expect(Pkg::Util::Execution)
+        .to receive(:capture3)
+        .with("#{wget} --spider -r -l 1 --no-parent #{base_url}/repos/apt/ 2>&1")
+        .and_return(wget_results + wget_garbage)
+      expect(FileUtils).to receive(:mkdir_p).with('pkg/repo_configs/deb')
       config = []
       repo_configs.each_with_index do |repo_config, i|
         config[i] = double(File)
-        File.should_receive(:open).with(repo_config, 'w').and_yield(config[i])
-        config[i].should_receive(:puts)
+        expect(File).to receive(:open).with(repo_config, 'w').and_yield(config[i])
+        expect(config[i]).to receive(:puts)
       end
       Pkg::Deb::Repo.generate_repo_configs
     end
   end
 
-  describe "#retrieve_repo_configs" do
-    it "fails if wget isn't available" do
-      Pkg::Util::Tool.should_receive(:find_tool).with("wget", {:required => true}).and_raise(RuntimeError)
-      expect {Pkg::Deb::Repo.generate_repo_configs}.to raise_error(RuntimeError)
+  describe '#retrieve_repo_configs' do
+    it 'fails if wget isn\'t available' do
+      expect(Pkg::Util::Tool)
+        .to receive(:find_tool)
+        .with('wget', { required: true })
+        .and_raise(RuntimeError)
+      expect { Pkg::Deb::Repo.generate_repo_configs }.to raise_error(RuntimeError)
     end
 
-    it "warns 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/deb/").and_raise(RuntimeError)
-      expect {Pkg::Deb::Repo.retrieve_repo_configs}.to raise_error(RuntimeError, /Couldn't retrieve deb apt repo configs/)
+    it 'warns if there are no deb repos available for the build' do
+      expect(Pkg::Util::Tool)
+        .to receive(:find_tool)
+        .with('wget', { required: true })
+        .and_return(wget)
+      expect(FileUtils)
+        .to receive(:mkdir_p)
+        .with('pkg/repo_configs')
+        .and_return(true)
+      expect(Pkg::Util::Execution)
+        .to receive(:capture3)
+        .with("#{wget} -r -np -nH --cut-dirs 3 -P pkg/repo_configs --reject 'index*' #{base_url}/repo_configs/deb/")
+        .and_raise(RuntimeError)
+      expect { Pkg::Deb::Repo.retrieve_repo_configs }
+        .to raise_error(RuntimeError, /Couldn't retrieve deb apt repo configs/)
     end
   end
 
-  describe "#repo_creation_command" do
-    let(:prefix) { "thing" }
-    let(:artifact_directory) { ["/a/b/c/bionic"] }
+  describe '#repo_creation_command' do
+    let(:prefix) { 'thing' }
+    let(:artifact_directory) { ['/a/b/c/bionic'] }
 
-    it "returns a command to make repos" do
+    it 'returns a command to make repos' do
       command = Pkg::Deb::Repo.repo_creation_command(prefix, artifact_directory)
-      command.should match(/reprepro/)
-      command.should match(/#{prefix}/)
-      command.should match(/#{artifact_directory}/)
+      expect(command).to match(/reprepro/)
+      expect(command).to match(/#{prefix}/)
+      expect(command).to match(/#{artifact_directory}/)
     end
   end
 
-  describe "#create_repos" do
-    let(:command) { "/usr/bin/make some repos" }
-    let(:artifact_directory) { "/tmp/dir/thing" }
+  describe '#create_repos' do
+    let(:command) { '/usr/bin/make some repos' }
+    let(:artifact_directory) { '/tmp/dir/thing' }
     let(:pkg_directories) { ['place/to/deb/bionic', 'other/deb/focal'] }
 
-    it "generates repo configs remotely and then ships them" 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::Deb::Repo.should_receive(:repo_creation_command).and_return(command)
-      Pkg::Util::Net.should_receive(:remote_execute).with(Pkg::Config.distribution_server, command)
-      Pkg::Deb::Repo.should_receive(:generate_repo_configs)
-      Pkg::Deb::Repo.should_receive(:ship_repo_configs)
-      Pkg::Util::Net.should_receive(:remote_execute).with(Pkg::Config.distribution_server, "rm -f #{artifact_directory}/repos/.lock" )
+    it 'generates repo configs remotely and then ships them' do
+      allow(File).to receive(:join).and_return(artifact_directory)
+      expect(Pkg::Repo).to receive(:directories_that_contain_packages).and_return(pkg_directories)
+      expect(Pkg::Repo).to receive(:populate_repo_directory)
+      expect(Pkg::Deb::Repo).to receive(:repo_creation_command).and_return(command)
+      expect(Pkg::Util::Net)
+        .to receive(:remote_execute)
+        .with(Pkg::Config.distribution_server, command)
+      expect(Pkg::Deb::Repo).to receive(:generate_repo_configs)
+      expect(Pkg::Deb::Repo).to receive(:ship_repo_configs)
+      expect(Pkg::Util::Net)
+        .to receive(:remote_execute)
+        .with(Pkg::Config.distribution_server, "rm -f #{artifact_directory}/repos/.lock")
       Pkg::Deb::Repo.create_repos
     end
   end
 
-  describe "#ship_repo_configs" do
-    it "warns if there are no repo configs to ship" do
-      File.should_receive(:exist?).with("pkg/repo_configs/deb").and_return(true)
-      Pkg::Util::File.should_receive(:empty_dir?).with("pkg/repo_configs/deb").and_return(true)
-      Pkg::Deb::Repo.should_receive(:warn).with("No repo configs have been generated! Try pl:deb_repo_configs.")
+  describe '#ship_repo_configs' do
+    it 'warns if there are no repo configs to ship' do
+      expect(File).to receive(:exist?).with('pkg/repo_configs/deb').and_return(true)
+      expect(Pkg::Util::File)
+        .to receive(:empty_dir?)
+        .with("pkg/repo_configs/deb")
+        .and_return(true)
+      expect(Pkg::Deb::Repo)
+        .to receive(:warn)
+        .with('No repo configs have been generated! Try pl:deb_repo_configs.')
       Pkg::Deb::Repo.ship_repo_configs
     end
 
-    it "ships repo configs to the build server" do
-      File.should_receive(:exist?).with("pkg/repo_configs/deb").and_return(true)
-      Pkg::Config.jenkins_repo_path = "/a/b/c/d"
-      Pkg::Config.distribution_server = "a.host.that.wont.exist"
+    it 'ships repo configs to the build server' do
+      expect(File).to receive(:exist?).with('pkg/repo_configs/deb').and_return(true)
+      Pkg::Config.jenkins_repo_path = '/a/b/c/d'
+      Pkg::Config.distribution_server = 'a.host.that.wont.exist'
       repo_dir = "#{Pkg::Config.jenkins_repo_path}/#{Pkg::Config.project}/#{Pkg::Config.ref}/repo_configs/deb"
-      Pkg::Util::File.should_receive(:empty_dir?).with("pkg/repo_configs/deb").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)
+      expect(Pkg::Util::File)
+        .to receive(:empty_dir?)
+        .with('pkg/repo_configs/deb')
+        .and_return(false)
+      expect(Pkg::Util::RakeUtils)
+        .to receive(:invoke_task)
+        .with("pl:fetch")
+      expect(Pkg::Util::Net)
+        .to receive(:remote_execute)
+        .with(Pkg::Config.distribution_server, "mkdir -p #{repo_dir}")
+      expect(Pkg::Util::Execution)
+        .to receive(:retry_on_fail)
+        .with(times: 3)
       Pkg::Deb::Repo.ship_repo_configs
     end
   end
 
-  describe "#sign_repos" do
-    it "fails without reprepro" do
-      Pkg::Util::Tool.should_receive(:find_tool).with('reprepro', {:required => true}).and_raise(RuntimeError)
+  describe '#sign_repos' do
+    it 'fails without reprepro' do
+      expect(Pkg::Util::Tool)
+        .to receive(:find_tool)
+        .with('reprepro', { required: true })
+        .and_raise(RuntimeError)
       expect { Pkg::Deb::Repo.sign_repos }.to raise_error(RuntimeError)
     end
 
-    it "makes a repo for each dist" do
+    it 'makes a repo for each dist' do
       # stub out start_keychain to prevent actual keychain starts.
-      Pkg::Util::Gpg.stub(:start_keychain)
+      allow(Pkg::Util::Gpg).to receive(:start_keychain)
 
-      dists = cows.reject { |cow| cow.empty? }
+      dists = cows.reject(&:empty?)
       distfiles = {}
-      Pkg::Util::File.should_receive(:directories).with("repos/apt").and_return(dists)
+      expect(Pkg::Util::File)
+        .to receive(:directories)
+        .with('repos/apt')
+        .and_return(dists)
 
       # Let the keychain command happen if find_tool('keychain') finds it
-      keychain_command = "/usr/bin/keychain -k mine"
+      keychain_command = '/usr/bin/keychain -k mine'
       allow(Pkg::Util::Execution).to receive(:capture3) { keychain_command }
 
       # Enforce reprepro
-      reprepro_command = "/bin/reprepro"
-      Pkg::Util::Tool.should_receive(:check_tool).with("reprepro").and_return(reprepro_command)
-      Pkg::Util::Execution.should_receive(:capture3).at_least(1).times.with("#{reprepro_command} -vvv --confdir ./conf --dbdir ./db --basedir ./ export")
+      reprepro_command = '/bin/reprepro'
+      expect(Pkg::Util::Tool)
+        .to receive(:check_tool)
+        .with('reprepro')
+        .and_return(reprepro_command)
+      expect(Pkg::Util::Execution)
+        .to receive(:capture3)
+        .at_least(1).times
+        .with("#{reprepro_command} -vvv --confdir ./conf --dbdir ./db --basedir ./ export")
 
       dists.each do |dist|
         distfiles[dist] = double
-        Dir.should_receive(:chdir).with("repos/apt/#{dist}").and_yield
-        File.should_receive(:open).with("conf/distributions", "w").and_yield(distfiles[dist])
-        distfiles[dist].should_receive(:puts)
+        expect(Dir).to receive(:chdir).with("repos/apt/#{dist}").and_yield
+        expect(File).to receive(:open).with('conf/distributions', 'w').and_yield(distfiles[dist])
+        expect(distfiles[dist]).to receive(:puts)
       end
 
       Pkg::Deb::Repo.sign_repos

data/spec/lib/packaging/deb_spec.rb

@@ -3,50 +3,53 @@ require 'spec_helper'
 require 'packaging/deb'
 
 describe 'deb.rb' do
-  describe "#set_cow_envs" do
+  describe '#set_cow_envs' do
     before(:each) do
-      reset_env(["DIST", "ARCH", "PE_VER", "BUILDMIRROR"])
+      reset_env(['DIST', 'ARCH', 'PE_VER', 'BUILDMIRROR'])
       Pkg::Config.deb_build_mirrors = nil
       Pkg::Config.build_pe = nil
       Pkg::Config.pe_version = nil
     end
 
     after(:all) do
-      reset_env(["DIST", "ARCH", "PE_VER", "BUILDMIRROR"])
+      reset_env(['DIST', 'ARCH', 'PE_VER', 'BUILDMIRROR'])
       Pkg::Config.deb_build_mirrors = nil
       Pkg::Config.build_pe = nil
       Pkg::Config.pe_version = nil
     end
 
-    it "should always set DIST and ARCH correctly" do
-      Pkg::Deb.send(:set_cow_envs, "base-wheezy-i386.cow")
-      ENV["DIST"].should eq("wheezy")
-      ENV["ARCH"].should eq("i386")
-      ENV["PE_VER"].should be_nil
-      ENV["BUILDMIRROR"].should be_nil
+    it 'should always set DIST and ARCH correctly' do
+      Pkg::Deb.send(:set_cow_envs, 'base-wheezy-i386.cow')
+      expect(ENV['DIST']).to eq('wheezy')
+      expect(ENV['ARCH']).to eq('i386')
+      expect(ENV['PE_VER']).to be nil
+      expect(ENV['BUILDMIRROR']).to be nil
     end
 
-    it "should set BUILDMIRROR if Pkg::Config.deb_build_mirrors is set" do
-      Pkg::Config.deb_build_mirrors = ["deb http://pl-build-tools.delivery.puppetlabs.net/debian __DIST__ main", "deb http://debian.is.awesome/wait no it is not"]
-      Pkg::Deb.send(:set_cow_envs, "base-wheezy-i386.cow")
-      ENV["DIST"].should eq("wheezy")
-      ENV["ARCH"].should eq("i386")
-      ENV["PE_VER"].should be_nil
-      ENV["BUILDMIRROR"].should eq("deb http://pl-build-tools.delivery.puppetlabs.net/debian wheezy main | deb http://debian.is.awesome/wait no it is not")
+    it 'should set BUILDMIRROR if Pkg::Config.deb_build_mirrors is set' do
+      Pkg::Config.deb_build_mirrors = [
+        'deb http://pl-build-tools.delivery.puppetlabs.net/debian __DIST__ main',
+        'deb http://debian.is.awesome/wait no it is not'
+      ]
+      Pkg::Deb.send(:set_cow_envs, 'base-wheezy-i386.cow')
+      expect(ENV['DIST']).to eq('wheezy')
+      expect(ENV['ARCH']).to eq('i386')
+      expect(ENV['PE_VER']).to be nil
+      expect(ENV['BUILDMIRROR']).to eq('deb http://pl-build-tools.delivery.puppetlabs.net/debian wheezy main | deb http://debian.is.awesome/wait no it is not')
     end
 
-    it "should set PE_VER if Pkg::Config.build_pe is truthy" do
+    it 'should set PE_VER if Pkg::Config.build_pe is truthy' do
       Pkg::Config.build_pe = true
-      Pkg::Config.pe_version = "3.2"
-      Pkg::Deb.send(:set_cow_envs, "base-wheezy-i386.cow")
-      ENV["DIST"].should eq("wheezy")
-      ENV["ARCH"].should eq("i386")
-      ENV["PE_VER"].should eq("3.2")
-      ENV["BUILDMIRROR"].should be_nil
+      Pkg::Config.pe_version = '3.2'
+      Pkg::Deb.send(:set_cow_envs, 'base-wheezy-i386.cow')
+      expect(ENV['DIST']).to eq('wheezy')
+      expect(ENV['ARCH']).to eq('i386')
+      expect(ENV['PE_VER']).to eq('3.2')
+      expect(ENV['BUILDMIRROR']).to be nil
     end
 
-    it "should fail on a badly formatted cow" do
-      expect { Pkg::Deb.send(:set_cow_envs, "wheezy-i386") }.to raise_error(RuntimeError)
+    it 'should fail on a badly formatted cow' do
+      expect { Pkg::Deb.send(:set_cow_envs, 'wheezy-i386') }.to raise_error(RuntimeError)
     end
   end
 end

data/spec/lib/packaging/repo_spec.rb

@@ -1,23 +1,25 @@
 # -*- ruby -*-
 require 'spec_helper'
-describe "#Pkg::Repo" do
+
+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"}
+      { "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")
+
+  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")
+      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
@@ -54,19 +56,23 @@ describe "#Pkg::Repo" do
       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')
+      expect do
+        Pkg::Repo.create_signed_repo_archive('/path', 'project-debian-6-i386', 'version')
+      end.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")
+    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(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"
+      ENV['FAIL_ON_MISSING_TARGET'] = 'false'
 
-      expect{Pkg::Repo.create_signed_repo_archive("/path", "project-debian-6-i386", "version")}.not_to raise_error
+      expect do
+        Pkg::Repo.create_signed_repo_archive('/path', 'project-debian-6-i386', 'version')
+      end.not_to raise_error
     end
 
     it 'should invoke tar correctly' do
@@ -76,7 +82,9 @@ describe "#Pkg::Repo" do
       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')
+      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
@@ -88,32 +96,38 @@ describe "#Pkg::Repo" do
       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')
+      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" }
+  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
+      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
+      expect(Pkg::Repo.argument_required?(optional_arg, repo_command)).to be false
     end
   end
 
-  describe "#update_repo" do
+  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_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'] }
@@ -124,12 +138,19 @@ describe "#Pkg::Repo" do
     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'/)
+      expect do
+        Pkg::Repo.update_repo(remote_host, repo_command, { repo_path: repo_path })
+      end.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 })
+      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/rpm/repo_spec.rb

@@ -6,7 +6,7 @@ describe 'Pkg::Rpm::Repo' do
   let(:project)       { 'rpm_repos' }
   let(:ref)           { '1234abcd' }
   let(:base_url)      { "http://#{builds_server}/#{project}/#{ref}" }
-  let(:mocks)         { %w[el-5-i386 el-5-x86_64 el-5-SRPMS] }
+  let(:mocks)         { ['el-5-i386', 'el-5-x86_64', 'el-5-SRPMS'] }
   let(:wget_results) do
     mocks.map do |mock|
       dist, version, arch = mock.split('-')
@@ -41,7 +41,7 @@ describe 'Pkg::Rpm::Repo' do
       allow(Pkg::Util::Tool)
         .to receive(:find_tool)
         .with('wget', { required: true })
-        .and_return(false)
+        .and_return false
       expect { Pkg::Rpm::Repo.generate_repo_configs }.to raise_error(RuntimeError)
     end
 
@@ -63,7 +63,7 @@ describe 'Pkg::Rpm::Repo' do
     it 'writes the expected repo configs to disk' do
       expect(Pkg::Util::Tool)
         .to receive(:find_tool)
-        .with("wget", { required: true })
+        .with('wget', { required: true })
         .and_return(wget)
       expect(Pkg::Util::Execution)
         .to receive(:capture3)
@@ -76,7 +76,7 @@ describe 'Pkg::Rpm::Repo' do
           .with("#{wget} --spider -r -l 1 --no-parent #{cur_result} 2>&1")
           .and_return("#{cur_result}/thing.rpm")
       end
-      expect(FileUtils).to receive(:mkdir_p).with('pkg/repo_configs/rpm')
+      expect(FileUtils).to receive(:mkdir_p).with("pkg/repo_configs/rpm")
       config = []
       repo_configs.each_with_index do |repo_config, i|
         expect(Pkg::Paths).to receive(:tag_from_artifact_path).and_return(mocks[i])
@@ -89,24 +89,13 @@ describe 'Pkg::Rpm::Repo' do
     end
   end
 
-  describe '#retrieve_repo_configs' do
-    it 'fails if wget isn\'t available' do
-      allow(Pkg::Util::Tool)
-        .to receive(:find_tool)
-        .with('wget', { required: true })
-        .and_return(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
+  describe "#retrieve_repo_configs" do
+    it "fails if there are no deb repos available for the build" do
       expect(Pkg::Util::Tool)
         .to receive(:find_tool)
         .with('wget', { required: true })
         .and_return(wget)
-      expect(FileUtils)
-        .to receive(:mkdir_p)
-        .with('pkg/repo_configs')
-        .and_return(true)
+      expect(FileUtils).to receive(:mkdir_p).with('pkg/repo_configs').and_return(true)
       expect(Pkg::Util::Execution)
         .to receive(:capture3)
         .with("#{wget} -r -np -nH --cut-dirs 3 -P pkg/repo_configs --reject 'index*' #{base_url}/repo_configs/rpm/")
@@ -124,10 +113,8 @@ describe 'Pkg::Rpm::Repo' do
       expect(Pkg::Rpm::Repo)
         .to receive(:repo_creation_command)
         .with(target_directory)
-        .and_return("run this thing")
-      expect(Pkg::Util::Execution)
-        .to receive(:capture3)
-        .with("bash -c 'run this thing'")
+        .and_return('run this thing')
+      expect(Pkg::Util::Execution).to receive(:capture3).with("bash -c 'run this thing'")
       Pkg::Rpm::Repo.create_local_repos(target_directory)
     end
   end
@@ -157,9 +144,11 @@ describe 'Pkg::Rpm::Repo' do
   describe '#ship_repo_configs' do
     it 'warn if there are no repo configs to ship' do
       Pkg::Config.jenkins_repo_path = '/a/b/c/d'
-      expect(Dir).to receive(:exist?).with("pkg/repo_configs/rpm").and_return(false)
-      expect(Pkg::Rpm::Repo).to receive(:warn)
-      expect(Pkg::Util::RakeUtils).not_to receive(:invoke_task)
+      expect(Dir).to receive(:exist?).with("pkg/repo_configs/rpm").and_return(true)
+      expect(Dir).to receive(:empty?).with("pkg/repo_configs/rpm").and_return(true)
+      expect(Pkg::Rpm::Repo)
+        .to receive(:warn)
+        .with(/^No repo_configs found in.*Skipping repo shipping/)
       Pkg::Rpm::Repo.ship_repo_configs
     end
 
@@ -168,22 +157,14 @@ describe 'Pkg::Rpm::Repo' do
       Pkg::Config.project = 'thing2'
       Pkg::Config.ref = 'abcd1234'
       Pkg::Config.distribution_server = 'a.host.that.wont.exist'
-      repo_dir = File.join(
-        Pkg::Config.jenkins_repo_path,
-        Pkg::Config.project,
-        Pkg::Config.ref,
-        'repo_configs',
-        'rpm'
-      )
-      expect(Dir).to receive(:exist?).with('pkg/repo_configs/rpm').and_return(true)
-      expect(Dir).to receive(:empty?).with('pkg/repo_configs/rpm').and_return(false)
+      repo_dir = "#{Pkg::Config.jenkins_repo_path}/#{Pkg::Config.project}/#{Pkg::Config.ref}/repo_configs/rpm"
+      expect(Dir).to receive(:exist?).with("pkg/repo_configs/rpm").and_return(true)
+      expect(Dir).to receive(:empty?).with("pkg/repo_configs/rpm").and_return(false)
       expect(Pkg::Util::RakeUtils).to receive(:invoke_task).with('pl:fetch')
       expect(Pkg::Util::Net)
         .to receive(:remote_execute)
         .with(Pkg::Config.distribution_server, "mkdir -p #{repo_dir}")
-      expect(Pkg::Util::Net)
-        .to receive(:rsync_to)
-        .with('pkg/repo_configs/rpm/', Pkg::Config.distribution_server, repo_dir)
+      expect(Pkg::Util::Execution).to receive(:retry_on_fail).with(times: 3)
       Pkg::Rpm::Repo.ship_repo_configs
     end
   end