packaging 0.108.2 → 0.109.0

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

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

@@ -1,112 +1,146 @@
 require 'spec_helper'
 
-describe "Pkg::Util::File" do
-  let(:source)     { "/tmp/placething.tar.gz" }
-  let(:target)     { "/tmp" }
-  let(:options)    { "--thing-for-tar" }
-  let(:tar)        { "/usr/bin/tar" }
-  let(:files)      { ["foo.rb", "foo/bar.rb"] }
-  let(:symlinks)   { ["bar.rb"] }
-  let(:dirs)       { ["foo"] }
-  let(:empty_dirs) { ["bar"] }
-
-
-  describe "#untar_into" do
+describe 'Pkg::Util::File' do
+  let(:source)     { '/tmp/placething.tar.gz' }
+  let(:target)     { '/tmp' }
+  let(:options)    { '--thing-for-tar' }
+  let(:tar)        { '/usr/bin/tar' }
+  let(:files)      { ['foo.rb', 'foo/bar.rb'] }
+  let(:symlinks)   { ['bar.rb'] }
+  let(:dirs)       { ['foo'] }
+  let(:empty_dirs) { ['bar'] }
+
+
+  describe '#untar_into' do
     before :each do
-      Pkg::Util::Tool.stub(:find_tool).with('tar', :required => true) { tar }
+      allow(Pkg::Util::Tool)
+        .to receive(:find_tool)
+        .with('tar', required: true)
+        .and_return(tar)
     end
 
-    it "raises an exception if the source doesn't exist" do
-      Pkg::Util::File.should_receive(:file_exists?).with(source, {:required => true}).and_raise(RuntimeError)
-      Pkg::Util::Execution.should_not_receive(:capture3)
+    it 'raises an exception if the source doesn\'t exist' do
+      expect(Pkg::Util::File)
+        .to receive(:file_exists?)
+        .with(source, { required: true })
+        .and_raise(RuntimeError)
+      expect(Pkg::Util::Execution).not_to receive(:capture3)
       expect { Pkg::Util::File.untar_into(source) }.to raise_error(RuntimeError)
     end
 
-    it "unpacks the tarball to the current directory if no target is passed" do
-      Pkg::Util::File.should_receive(:file_exists?).with(source, {:required => true}) { true }
-      Pkg::Util::Execution.should_receive(:capture3).with("#{tar}   -xf #{source}")
+    it 'unpacks the tarball to the current directory if no target is passed' do
+      expect(Pkg::Util::File)
+        .to receive(:file_exists?)
+          .with(source, { required: true }) { true }
+      expect(Pkg::Util::Execution)
+        .to receive(:capture3)
+        .with("#{tar}   -xf #{source}")
       Pkg::Util::File.untar_into(source)
     end
 
-    it "unpacks the tarball to the current directory with options if no target is passed" do
-      Pkg::Util::File.should_receive(:file_exists?).with(source, {:required => true}) { true }
-      Pkg::Util::Execution.should_receive(:capture3).with("#{tar} #{options}  -xf #{source}")
+    it 'unpacks the tarball to the current directory with options if no target is passed' do
+      expect(Pkg::Util::File)
+        .to receive(:file_exists?)
+          .with(source, { required: true }) { true }
+      expect(Pkg::Util::Execution)
+        .to receive(:capture3)
+        .with("#{tar} #{options}  -xf #{source}")
       Pkg::Util::File.untar_into(source, nil, options)
     end
 
-    it "unpacks the tarball into the target" do
-      File.stub(:capture3ist?).with(source) { true }
-      Pkg::Util::File.should_receive(:file_exists?).with(source, {:required => true}) { true }
-      Pkg::Util::File.should_receive(:file_writable?).with(target) { true }
-      Pkg::Util::Execution.should_receive(:capture3).with("#{tar}  -C #{target} -xf #{source}")
+    it 'unpacks the tarball into the target' do
+      allow(File).to receive(:capture3ist?).with(source).and_return(true)
+      expect(Pkg::Util::File).to receive(:file_exists?).with(source, { required: true }) { true }
+      expect(Pkg::Util::File).to receive(:file_writable?).with(target) { true }
+      expect(Pkg::Util::Execution).to receive(:capture3).with("#{tar}  -C #{target} -xf #{source}")
       Pkg::Util::File.untar_into(source, target)
     end
 
     it "unpacks the tarball into the target with options passed" do
-      File.stub(:capture3ist?).with(source) { true }
-      Pkg::Util::File.should_receive(:file_exists?).with(source, {:required => true}) { true }
-      Pkg::Util::File.should_receive(:file_writable?).with(target) { true }
-      Pkg::Util::Execution.should_receive(:capture3).with("#{tar} #{options} -C #{target} -xf #{source}")
+      allow(File).to receive(:capture3ist?).with(source).and_return(true)
+      expect(Pkg::Util::File).to receive(:file_exists?).with(source, { required: true }) { true }
+      expect(Pkg::Util::File).to receive(:file_writable?).with(target) { true }
+      expect(Pkg::Util::Execution)
+        .to receive(:capture3)
+        .with("#{tar} #{options} -C #{target} -xf #{source}")
       Pkg::Util::File.untar_into(source, target, options)
     end
   end
 
-  describe "#files_with_ext" do
-    it "returns nothing if there are no files with that extension" do
-      Pkg::Util::File.files_with_ext("./spec/fixtures/configs/components", ".fake").should be_empty
+  describe '#files_with_ext' do
+    it 'returns nothing if there are no files with that extension' do
+      expect(Pkg::Util::File.files_with_ext('./spec/fixtures/configs/components', '.fake'))
+        .to be_empty
     end
 
-    it "returns only the files with that extension" do
-      expect(Pkg::Util::File.files_with_ext("./spec/fixtures/configs/components", ".json")).to include("./spec/fixtures/configs/components/test_file.json")
-      expect(Pkg::Util::File.files_with_ext("./spec/fixtures/configs/components", ".json")).to include("./spec/fixtures/configs/components/test_file_2.json")
+    it 'returns only the files with that extension' do
+      expect(Pkg::Util::File.files_with_ext('./spec/fixtures/configs/components', '.json'))
+        .to include('./spec/fixtures/configs/components/test_file.json')
+      expect(Pkg::Util::File.files_with_ext('./spec/fixtures/configs/components', '.json'))
+        .to include('./spec/fixtures/configs/components/test_file_2.json')
     end
   end
 
-  describe "#install_files_into_dir" do
-    it "selects the correct files to install" do
+  describe '#install_files_into_dir' do
+    it 'selects the correct files to install' do
       Pkg::Config.load_defaults
       workdir = Pkg::Util::File.mktemp
       patterns = []
 
-      # Set up a bunch of default settings for these to avoid a lot more stubbing in each section below
-      File.stub(:file?) { false }
-      File.stub(:symlink?) { false }
-      File.stub(:directory?) { false }
-      Pkg::Util::File.stub(:empty_dir?) { false }
+      allow(File).to receive(:file?).and_return(false)
+      allow(File).to receive(:symlink?).and_return(false)
+      allow(File).to receive(:directory?).and_return(false)
+      allow(Pkg::Util::File).to receive(:empty_dir?).and_return(false)
 
       # Files should have the path made and should be copied
       files.each do |file|
-        File.stub(:file?).with(file).and_return(true)
-        Dir.stub(:[]).with(file).and_return(file)
-        FileUtils.should_receive(:mkpath).with(File.dirname(File.join(workdir, file)), :verbose => false)
-        FileUtils.should_receive(:cp).with(file, File.join(workdir, file), :verbose => false, :preserve => true)
+        allow(File).to receive(:file?).with(file).and_return(true)
+        allow(Dir).to receive(:[]).with(file).and_return(file)
+        expect(FileUtils)
+          .to receive(:mkpath)
+          .with(File.dirname(File.join(workdir, file)), verbose: false)
+        expect(FileUtils)
+          .to receive(:cp)
+          .with(file, File.join(workdir, file), verbose: false, preserve: true)
         patterns << file
       end
 
       # Symlinks should have the path made and should be copied
       symlinks.each do |file|
-        File.stub(:symlink?).with(file).and_return(true)
-        Dir.stub(:[]).with(file).and_return(file)
-        FileUtils.should_receive(:mkpath).with(File.dirname(File.join(workdir, file)), :verbose => false)
-        FileUtils.should_receive(:cp).with(file, File.join(workdir, file), :verbose => false, :preserve => true)
+        allow(File).to receive(:symlink?).with(file).and_return(true)
+        allow(Dir).to receive(:[]).with(file).and_return(file)
+        expect(FileUtils)
+          .to receive(:mkpath)
+          .with(File.dirname(File.join(workdir, file)), verbose: false)
+        expect(FileUtils)
+          .to receive(:cp)
+          .with(file, File.join(workdir, file), verbose: false, preserve: true)
         patterns << file
       end
 
-      # Dirs should be added to patterns but no acted upon
+      # Dirs should be added to patterns but not acted upon
       dirs.each do |dir|
-        File.stub(:directory?).with(dir).and_return(true)
-        Dir.stub(:[]).with("#{dir}/**/*").and_return(dir)
-        FileUtils.should_not_receive(:mkpath).with(File.dirname(File.join(workdir, dir)), :verbose => false)
-        FileUtils.should_not_receive(:cp).with(dir, File.join(workdir, dir), :verbose => false, :preserve => true)
+        allow(File).to receive(:directory?).with(dir).and_return(true)
+        allow(Dir).to receive(:[]).with("#{dir}/**/*").and_return(dir)
+        expect(FileUtils)
+          .not_to receive(:mkpath)
+          .with(File.dirname(File.join(workdir, dir)), verbose: false)
+        expect(FileUtils)
+          .not_to receive(:cp)
+          .with(dir, File.join(workdir, dir), verbose: false, preserve: true)
         patterns << dir
       end
 
       # Empty dirs should have the path created and nothing copied
       empty_dirs.each do |dir|
-        Pkg::Util::File.stub(:empty_dir?).with(dir).and_return(true)
-        Dir.stub(:[]).with(dir).and_return(dir)
-        FileUtils.should_receive(:mkpath).with(File.join(workdir, dir), :verbose => false)
-        FileUtils.should_not_receive(:cp).with(dir, File.join(workdir, dir), :verbose => false, :preserve => true)
+        allow(Pkg::Util::File).to receive(:empty_dir?).with(dir).and_return(true)
+        allow(Dir).to receive(:[]).with(dir).and_return(dir)
+        expect(FileUtils)
+          .to receive(:mkpath)
+          .with(File.join(workdir, dir), verbose: false)
+        expect(FileUtils)
+          .not_to receive(:cp)
+          .with(dir, File.join(workdir, dir), verbose: false, preserve: true)
         patterns << dir
       end
 
@@ -115,25 +149,28 @@ describe "Pkg::Util::File" do
     end
   end
 
-  describe "#directories" do
-    it "returns nil if there is no directory" do
-      File.should_receive(:directory?).with("/tmp").and_return(false)
-      Pkg::Util::File.directories("/tmp").should be_nil
+  describe '#directories' do
+    it 'returns nil if there is no directory' do
+      expect(File).to receive(:directory?).with('/tmp').and_return(false)
+      expect(Pkg::Util::File.directories('/tmp')).to be_nil
     end
 
-    it "returns the empty array if there are no dirs in the directory" do
-      File.should_receive(:directory?).with("/tmp").and_return(true)
-      Dir.should_receive(:glob).with("*").and_return([])
-      Pkg::Util::File.directories("/tmp").should be_empty
+    it 'returns the empty array if there are no dirs in the directory' do
+      expect(File).to receive(:directory?).with('/tmp').and_return(true)
+      expect(Dir).to receive(:glob).with('*').and_return([])
+      expect(Pkg::Util::File.directories("/tmp")).to be_empty
     end
 
-    it "returns an array of the top level directories inside a directory" do
-      File.stub(:directory?) { false }
-      ["/tmp", "/tmp/dir", "/tmp/other_dir"].each do |dir|
-        File.should_receive(:directory?).with(dir).and_return(true)
+    it 'returns an array of the top level directories inside a directory' do
+      allow(File).to receive(:directory?).and_return(false)
+      ['/tmp', '/tmp/dir', '/tmp/other_dir'].each do |dir|
+        expect(File).to receive(:directory?).with(dir).and_return(true)
       end
-      Dir.should_receive(:glob).with("*").and_return(["/tmp/file", "/tmp/dir", "/tmp/other_dir"])
-      Pkg::Util::File.directories("/tmp").should eq(["/tmp/dir", "/tmp/other_dir"])
+      expect(Dir)
+        .to receive(:glob)
+        .with('*')
+        .and_return(['/tmp/file', '/tmp/dir', '/tmp/other_dir'])
+      expect(Pkg::Util::File.directories('/tmp')).to eq(['/tmp/dir', '/tmp/other_dir'])
     end
   end
 end