packaging 0.88.77 → 0.99.0

data/spec/lib/packaging/platforms_spec.rb

@@ -3,8 +3,8 @@ 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']
+      deb_platforms = ['cumulus', 'debian', 'ubuntu']
+      rpm_platforms = ['aix', 'cisco-wrlinux', 'el', 'fedora', 'redhat-fips', '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
@@ -12,21 +12,21 @@ describe 'Pkg::Platforms' do
 
   describe '#formats' do
     it 'should return all package formats' do
-      fmts = ['rpm', 'deb', 'dmg', 'svr4', 'ips', 'msi']
+      fmts = ['rpm', 'deb', 'swix', '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']
+      platforms = ['aix', 'cisco-wrlinux', 'cumulus', 'debian', 'el', 'eos', 'fedora', 'osx', 'redhat-fips', 'sles', 'solaris', 'ubuntu', 'windows']
       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'])
+      expect(Pkg::Platforms.versions_for_platform('el')).to match_array(['5', '6', '7'])
     end
 
     it 'should raise an error if given a nonexistent platform' do
@@ -36,7 +36,7 @@ describe 'Pkg::Platforms' do
 
   describe '#codenames' do
     it 'should return all codenames for a given platform' do
-      codenames = ['focal', 'bionic', 'buster', 'cosmic', 'jessie', 'stretch', 'trusty', 'xenial']
+      codenames = ['cumulus', 'wheezy', 'jessie', 'stretch', 'trusty', 'xenial']
       expect(Pkg::Platforms.codenames).to match_array(codenames)
     end
   end
@@ -59,27 +59,19 @@ describe 'Pkg::Platforms' do
 
   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"])
+      expect(Pkg::Platforms.arches_for_codename('trusty')).to match_array(['i386', 'amd64'])
     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"])
+      expect(Pkg::Platforms.codename_to_tags('trusty')).to match_array(['ubuntu-14.04-i386', 'ubuntu-14.04-amd64'])
     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"])
+      expect(Pkg::Platforms.arches_for_platform_version('sles', '11')).to match_array(['i386', 'x86_64', 's390x'])
     end
   end
 
@@ -97,16 +89,14 @@ describe 'Pkg::Platforms' do
   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 
+    it 'should return a hash of platform info' do
+      expect(Pkg::Platforms.platform_lookup('osx-10.10-x86_64')).to be_instance_of(Hash)
+    end
+
+    it 'should include at least arch and package format keys' do
+      expect(Pkg::Platforms.platform_lookup('osx-10.10-x86_64').keys).to include(:architectures)
+      expect(Pkg::Platforms.platform_lookup('osx-10.10-x86_64').keys).to include(:package_format)
+    end
   end
 
   describe '#get_attribute' do
@@ -115,7 +105,7 @@ describe 'Pkg::Platforms' do
     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/)
+      expect { Pkg::Platforms.get_attribute('eos-4-i386', :signature_format) }.to raise_error(/doesn't have information/)
     end
   end
 
@@ -129,15 +119,14 @@ describe 'Pkg::Platforms' 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'],
+      'cisco-wrlinux-7-x86_64' => ['cisco-wrlinux', '7', 'x86_64'],
+      'cisco-wrlinux-7' => ['cisco-wrlinux', '7', ''],
       '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'],
+      'redhat-fips-7-x86_64' => ['redhat-fips', '7', 'x86_64'],
     }
 
     fail_cases = [
@@ -147,8 +136,6 @@ describe 'Pkg::Platforms' do
       'windows-x86',
       'el-7-notarch',
       'debian-7-x86_64',
-      'el-7-source',
-      'debian-7-SRPMS',
     ]
 
     test_cases.each do |platform_tag, results|
@@ -163,16 +150,4 @@ describe 'Pkg::Platforms' do
       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

@@ -16,45 +16,46 @@ describe "#Pkg::Repo" do
       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
+      expect(Dir).to receive(:chdir).with("pkg").and_yield
+      expect(Dir).to receive(:chdir).with("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
+    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')
+      expect(Pkg::Config).to receive(:project).and_return("project")
+      expect(Pkg::Config).to receive(:ref).and_return("AAAAAAAAAAAAAAA")
+      expect(Dir).to receive(:chdir).with("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
+    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')
+      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("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')
+    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(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'
+      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{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
@@ -62,74 +63,35 @@ describe "#Pkg::Repo" do
       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").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'] = "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
+    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").and_yield
+      allow(Dir).to receive(:chdir).with("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')
+      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
+  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 })
+      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")
+      Pkg::Repo.create_all_repo_archives("project", "version")
     end
   end
 end

data/spec/lib/packaging/retrieve_spec.rb

@@ -7,19 +7,18 @@ describe 'Pkg::Retrieve' do
   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']
+  foss_platforms = ['el-7-x86_64', 'ubuntu-16.04-amd64', 'osx-10.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'},
+    'aix-6.1-power' => {:artifact => './aix/6.1/PC1/ppc/puppet-agent-5.3.2.155.gb25e649-1.aix6.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'},
+    'osx-10.11-x86_64' => {:artifact => './apple/10.11/PC1/x86_64/puppet-agent-5.3.2.155.gb25e649-1.osx10.11.dmg'},
+    'sles-11-s390x' => {:artifact => './sles/11/PC1/s390x/puppet-agent-5.3.2.155.gb25e649-1.sles11.s390x.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}"
+  build_url = "builds.delivery.puppetlabs.net/#{project}/#{ref}"
+  build_path = "/opt/jenkins-builds/#{project}/#{ref}"
 
   before :each do
     allow(Pkg::Config).to receive(:project).and_return(project)
@@ -29,44 +28,6 @@ describe 'Pkg::Retrieve' do
     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)
@@ -87,13 +48,13 @@ describe 'Pkg::Retrieve' do
   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)
+      Pkg::Retrieve.retrieve_all(build_url, build_path, remote_target, 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)
+      Pkg::Retrieve.retrieve_all(build_url, build_path, remote_target, local_target)
     end
   end
 end

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

@@ -102,10 +102,10 @@ describe "Pkg::Rpm::Repo" do
       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::Util::Net.should_receive(:remote_ssh_cmd).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::Util::Net.should_receive(:remote_ssh_cmd).with(Pkg::Config.distribution_server, "rm -f #{artifact_directory}/repos/.lock" )
       Pkg::Rpm::Repo.create_remote_repos
     end
   end
@@ -124,8 +124,8 @@ describe "Pkg::Rpm::Repo" do
       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::Rpm::Repo.should_receive(:invoke_task).with("pl:fetch")
+      Pkg::Util::Net.should_receive(:remote_ssh_cmd).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

data/spec/lib/packaging/tar_spec.rb

@@ -20,44 +20,34 @@ describe "tar.rb" do
       "#{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::Config.config_from_hash(
+        {
+          :templates      => templates,
+          :project        => project,
+          :version        => version,
+          :files          => files,
+          :project_root   => PROJECT_ROOT,
+          :packaging_root => "ext/packaging"
+        })
+
       Pkg::Tar.any_instance.should_receive(:expand_templates)
       Pkg::Tar.new
     end
 
     it "packaging templates should be filtered and paths should be expanded" do
+      Pkg::Config.config_from_hash(
+        {
+          :templates      => templates,
+          :project        => project,
+          :version        => version,
+          :files          => files,
+          :project_root   => PROJECT_ROOT,
+          :packaging_root => "ext/packaging"
+        })
+
       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))
@@ -72,11 +62,17 @@ describe "tar.rb" do
   end
 
   describe "#template" do
-    before(:each) do
-      Pkg::Config.templates = expanded_templates
-    end
-
     it "should handle hashes and strings correctly" do
+      Pkg::Config.config_from_hash(
+        {
+          :templates      => expanded_templates,
+          :project        => project,
+          :version        => version,
+          :files          => files,
+          :project_root   => PROJECT_ROOT,
+          :packaging_root => "ext/packaging"
+        })
+
       # Set up correct stubs and expectations
       expanded_templates.each do |temp|
         if temp.is_a?(String)
@@ -96,6 +92,16 @@ describe "tar.rb" do
     end
 
     it "should raise an error if the template source can't be found" do
+     Pkg::Config.config_from_hash(
+        {
+          :templates      => expanded_templates,
+          :project        => project,
+          :version        => version,
+          :files          => files,
+          :project_root   => PROJECT_ROOT,
+          :packaging_root => "ext/packaging"
+        })
+
       # Set up correct stubs and expectations
       expanded_templates.each do |temp|
         if temp.is_a?(String)

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

@@ -17,7 +17,7 @@ describe "Pkg::Util::Git_tag" do
 
   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", "main")
+      git_tag = Pkg::Util::Git_tag.new("git://github.com/puppetlabs/leatherman.git", "master")
       expect(git_tag.branch?).to eq(true)
     end
   end

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

@@ -24,7 +24,7 @@ describe "Pkg::Util::Gpg" do
 
   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.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