packaging 0.108.1 → 0.109.0

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

@@ -1,20 +1,22 @@
 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" }
+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" } }
+  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('-')
+      "http://#{builds_server}/#{project}/#{ref}/repos/#{dist}/#{version}/products/#{arch}/repodata/"
+    end.join("\n")
+  end
+  let(:wget_garbage) { "\nother things\n and an index\nhttp://somethingelse.com" }
+  let(:repo_configs) do
+    mocks.map { |mock| "pkg/repo_configs/rpm/pl-#{project}-#{ref}-#{mock}.repo" }
+  end
 
   # Setup and tear down for the tests
   around do |example|
@@ -34,99 +36,135 @@ describe "Pkg::Rpm::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.stub(:find_tool).with("wget", {:required => true}) {false}
-      expect {Pkg::Rpm::Repo.generate_repo_configs}.to raise_error(RuntimeError)
+  describe '#generate_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 "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!")
+    it 'warns if there are no rpm 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 5 --no-parent #{base_url}/repos/ 2>&1")
+        .and_return('')
+      expect(Pkg::Rpm::Repo)
+        .to 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)
+    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 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")
+        expect(Pkg::Util::Execution)
+          .to 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")
+      expect(FileUtils).to 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('-'))
+        expect(Pkg::Paths).to receive(:tag_from_artifact_path).and_return(mocks[i])
+        expect(Pkg::Platforms).to 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)
+        expect(File).to receive(:open).with(repo_config, 'w').and_yield(config[i])
+        expect(config[i]).to 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/)
+      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/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" }
+  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'")
+    it 'makes a repo in the target directory' 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'")
       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" }
+  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" )
+    it 'makes a repo in the target directory' 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::Rpm::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::Rpm::Repo).to receive(:generate_repo_configs)
+      expect(Pkg::Rpm::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::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.")
+  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(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
 
-    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"
+    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)
+      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::Execution).to receive(:retry_on_fail).with(times: 3)
       Pkg::Rpm::Repo.ship_repo_configs
     end
   end

data/spec/lib/packaging/sign_spec.rb

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

data/spec/lib/packaging/tar_spec.rb

@@ -1,35 +1,36 @@
 # -*- ruby -*-
 require 'spec_helper'
 
-describe "tar.rb" do
-  let(:project) { "packaging" }
-  let(:version) { "1.2.3" }
-  let(:files)   { [ "a", "b", "c" ] }
+describe 'tar.rb' do
+  let(:project) { 'packaging' }
+  let(:version) { '1.2.3' }
+  let(:files)   { %w[a b c] }
   let(:templates) do
     [
-      "ext/redhat/spec.erb",
-      { "source" => "ext/debian/control.erb", "target" => "ext/debian/not-a-control-file" },
-      "ext/debian/changelog.erb",
-      "ext/packaging/thing.erb"
+      'ext/redhat/spec.erb',
+      { 'source' => 'ext/debian/control.erb', 'target' => 'ext/debian/not-a-control-file' },
+      'ext/debian/changelog.erb',
+      'ext/packaging/thing.erb'
     ]
   end
   let(:expanded_templates) do
     [
       "#{PROJECT_ROOT}/ext/redhat/spec.erb",
-      { "source" => "ext/debian/control.erb", "target" => "ext/debian/not-a-control-file" },
+      { 'source' => 'ext/debian/control.erb', 'target' => 'ext/debian/not-a-control-file' },
       "#{PROJECT_ROOT}/ext/debian/changelog.erb"
     ]
   end
   before(:each) do
     Pkg::Config.config_from_hash(
       {
-        :templates      => templates,
-        :project        => project,
-        :version        => version,
-        :files          => files,
-        :project_root   => PROJECT_ROOT,
-        :packaging_root => "ext/packaging"
-      })
+        templates: templates,
+        project: project,
+        version: version,
+        files: files,
+        project_root: PROJECT_ROOT,
+        packaging_root: 'ext/packaging'
+      }
+    )
   end
 
   describe '#initialize' do
@@ -51,63 +52,66 @@ describe "tar.rb" do
     end
   end
 
-  describe "#expand_templates" do
-    it "should be invoked when Pkg::Config.templates is set" do
-      Pkg::Tar.any_instance.should_receive(:expand_templates)
+  describe '#expand_templates' do
+    it 'should be invoked when Pkg::Config.templates is set' do
+      expect_any_instance_of(Pkg::Tar).to receive(:expand_templates)
       Pkg::Tar.new
     end
 
-    it "packaging templates should be filtered and paths should be expanded" do
+    it 'packaging templates should be filtered and paths should be expanded' do
       templates.each do |temp|
         if temp.is_a?(String)
-          Dir.stub(:glob).with(File.join(PROJECT_ROOT, temp)).and_return(File.join(PROJECT_ROOT, temp))
+          allow(Dir)
+            .to receive(:glob)
+            .with(File.join(PROJECT_ROOT, temp))
+            .and_return(File.join(PROJECT_ROOT, temp))
         end
       end
 
       tar = Pkg::Tar.new
       tar.templates = templates
       tar.expand_templates
-      tar.templates.should eq expanded_templates
+      expect(tar.templates).to eq(expanded_templates)
     end
   end
 
-  describe "#template" do
+  describe '#template' do
     before(:each) do
       Pkg::Config.templates = expanded_templates
     end
 
-    it "should handle hashes and strings correctly" do
-      # Set up correct stubs and expectations
+    it 'should handle hashes and strings correctly' do
       expanded_templates.each do |temp|
-        if temp.is_a?(String)
+        case temp
+        when String
           full_path_temp = File.join(PROJECT_ROOT, temp)
-          target = full_path_temp.sub(File.extname(full_path_temp), "")
-        elsif temp.is_a?(Hash)
-          full_path_temp = File.join(PROJECT_ROOT, temp["source"])
-          target = File.join(PROJECT_ROOT, temp["target"])
+          target = full_path_temp.sub(File.extname(full_path_temp), '')
+        when Hash
+          full_path_temp = File.join(PROJECT_ROOT, temp['source'])
+          target = File.join(PROJECT_ROOT, temp['target'])
         end
 
-        Dir.stub(:glob).with(full_path_temp).and_return(full_path_temp)
-        File.stub(:exist?).with(full_path_temp).and_return(true)
-        Pkg::Util::File.should_receive(:erb_file).with(full_path_temp, target, true, :binding => an_instance_of(Binding))
+        allow(Dir).to receive(:glob).with(full_path_temp).and_return(full_path_temp)
+        allow(File).to receive(:exist?).with(full_path_temp).and_return(true)
+        expect(Pkg::Util::File)
+          .to receive(:erb_file)
+          .with(full_path_temp, target, true, binding: an_instance_of(Binding))
       end
 
       Pkg::Tar.new.template
     end
 
-    it "should raise an error if the template source can't be found" do
-      # Set up correct stubs and expectations
+    it 'should raise an error if the template source can\'t be found' do
       expanded_templates.each do |temp|
-        if temp.is_a?(String)
-          full_path_temp = File.join(PROJECT_ROOT, temp)
-          target = full_path_temp.sub(File.extname(full_path_temp), "")
-        elsif temp.is_a?(Hash)
-          full_path_temp = File.join(PROJECT_ROOT, temp["source"])
-          target = File.join(PROJECT_ROOT, temp["target"])
-        end
+        full_path_temp = case temp
+                         when String
+                           File.join(PROJECT_ROOT, temp)
+                         when Hash
+                           File.join(PROJECT_ROOT, temp['source'])
+                         end
 
-        Dir.stub(:glob).with(full_path_temp).and_return(full_path_temp)
-        File.stub(:exist?).with(full_path_temp).and_return(false)
+        allow(Dir).to receive(:glob).with(full_path_temp).and_return(full_path_temp)
+        allow(File).to receive(:exist?).with(full_path_temp).and_return(false)
       end
 
       expect { Pkg::Tar.new.template }.to raise_error RuntimeError

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

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