packaging 0.108.1 → 0.109.0

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

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

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-describe "Pkg::Util::Gpg" do
-  let(:gpg)      { "/local/bin/gpg" }
-  let(:keychain) { "/usr/local/bin/keychain" }
-  let(:gpg_key)  { "abcd1234" }
-  let(:target_file) { "/tmp/file" }
+describe 'Pkg::Util::Gpg' do
+  let(:gpg)      { '/local/bin/gpg' }
+  let(:keychain) { '/usr/local/bin/keychain' }
+  let(:gpg_key)  { 'abcd1234' }
+  let(:target_file) { '/tmp/file' }
 
   before(:each) do
     reset_env(['RPM_GPG_AGENT'])
@@ -12,36 +12,37 @@ describe "Pkg::Util::Gpg" do
   end
 
   describe '#key' do
-    it "fails if Pkg::Config.gpg_key isn't set" do
+    it 'fails if Pkg::Config.gpg_key isn\'t set' do
       allow(Pkg::Config).to receive(:gpg_key).and_return(nil)
       expect { Pkg::Util::Gpg.key }.to raise_error(RuntimeError)
     end
-    it "fails if Pkg::Config.gpg_key is an empty string" do
+    it 'fails if Pkg::Config.gpg_key is an empty string' do
       allow(Pkg::Config).to receive(:gpg_key).and_return('')
       expect { Pkg::Util::Gpg.key }.to raise_error(RuntimeError)
     end
   end
 
   describe '#kill_keychain' do
-    it "doesn't reload the keychain if already loaded" do
+    it 'doesn\'t reload the keychain if already loaded' do
       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
+
+      expect(Pkg::Util::Gpg).not_to receive(:kill_keychain)
+      expect(Pkg::Util::Gpg).not_to receive(:start_keychain)
       Pkg::Util::Gpg.load_keychain
       Pkg::Util::Gpg.instance_variable_set("@keychain_loaded", nil)
     end
 
     it "doesn't reload the keychain if ENV['RPM_GPG_AGENT'] is set" do
       ENV['RPM_GPG_AGENT'] = 'blerg'
-      Pkg::Util::Gpg.should_receive(:kill_keychain).never
-      Pkg::Util::Gpg.should_receive(:start_keychain).never
+      expect(Pkg::Util::Gpg).not_to receive(:kill_keychain)
+      expect(Pkg::Util::Gpg).not_to receive(:start_keychain)
       Pkg::Util::Gpg.load_keychain
     end
 
     it 'kills and starts the keychain if not loaded already' do
       Pkg::Util::Gpg.instance_variable_set("@keychain_loaded", nil)
-      Pkg::Util::Gpg.should_receive(:kill_keychain).once
-      Pkg::Util::Gpg.should_receive(:start_keychain).once
+      expect(Pkg::Util::Gpg).to receive(:kill_keychain).once
+      expect(Pkg::Util::Gpg).to receive(:start_keychain).once
       Pkg::Util::Gpg.load_keychain
     end
   end
@@ -49,15 +50,19 @@ describe "Pkg::Util::Gpg" do
   describe '#sign_file' do
     it 'adds special flags if RPM_GPG_AGENT is set' do
       ENV['RPM_GPG_AGENT'] = 'blerg'
-      additional_flags = "--no-tty --use-agent"
-      Pkg::Util::Tool.should_receive(:find_tool).with('gpg').and_return(gpg)
-      Pkg::Util::Execution.should_receive(:capture3).with("#{gpg}\s#{additional_flags}\s--armor --detach-sign -u #{gpg_key} #{target_file}")
+      additional_flags = '--no-tty --use-agent'
+      expect(Pkg::Util::Tool).to receive(:find_tool).with('gpg').and_return(gpg)
+      expect(Pkg::Util::Execution)
+        .to receive(:capture3)
+        .with("#{gpg}\s#{additional_flags}\s--armor --detach-sign -u #{gpg_key} #{target_file}")
       Pkg::Util::Gpg.sign_file(target_file)
     end
 
     it 'signs without extra flags when RPM_GPG_AGENT is not set' do
-      Pkg::Util::Tool.should_receive(:find_tool).with('gpg').and_return(gpg)
-      Pkg::Util::Execution.should_receive(:capture3).with("#{gpg}\s\s--armor --detach-sign -u #{gpg_key} #{target_file}")
+      expect(Pkg::Util::Tool).to receive(:find_tool).with('gpg').and_return(gpg)
+      expect(Pkg::Util::Execution)
+        .to receive(:capture3)
+        .with("#{gpg}\s\s--armor --detach-sign -u #{gpg_key} #{target_file}")
       Pkg::Util::Gpg.sign_file(target_file)
     end
   end

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

@@ -1,9 +1,10 @@
 # -*- ruby -*-
 require 'spec_helper'
+require 'json'
 
 describe Pkg::Util::Jenkins do
-  let(:build_host) {"Jenkins-foo"}
-  let(:name) {"job-foo"}
+  let(:build_host) { 'Jenkins-foo' }
+  let(:name) { 'job-foo' }
   around do |example|
     old_build_host = Pkg::Config.jenkins_build_host
     Pkg::Config.jenkins_build_host = build_host
@@ -11,51 +12,77 @@ describe Pkg::Util::Jenkins do
     Pkg::Config.jenkins_build_host = old_build_host
   end
 
-  describe "#create_jenkins_job" do
-    let(:xml_file) {"bar.xml"}
+  describe '#create_jenkins_job' do
+    let(:xml_file) { 'bar.xml' }
 
-    it "should call curl_form_data with the correct arguments" do
-      Pkg::Util::Net.should_receive(:curl_form_data).with("http://#{build_host}/createItem?name=#{name}", ["-H", '"Content-Type: application/xml"', "--data-binary", "@#{xml_file}"])
+    it 'should call curl_form_data with the correct arguments' do
+      expect(Pkg::Util::Net)
+        .to receive(:curl_form_data)
+        .with("http://#{build_host}/createItem?name=#{name}",
+              ['-H', '"Content-Type: application/xml"',
+               '--data-binary',
+               "@#{xml_file}"])
       Pkg::Util::Jenkins.create_jenkins_job(name, xml_file)
     end
   end
 
-  describe "#jenkins_job_exists?" do
-
-    it "should call curl_form_data with correct arguments" do
-      Pkg::Util::Net.should_receive(:curl_form_data).with("http://#{build_host}/job/#{name}/config.xml", ["--silent", "--fail"], :quiet => true).and_return(['output', 0])
-      Pkg::Util::Execution.should_receive(:success?).and_return(true)
+  describe '#jenkins_job_exists?' do
+    it 'should call curl_form_data with correct arguments' do
+      expect(Pkg::Util::Net)
+        .to receive(:curl_form_data)
+        .with("http://#{build_host}/job/#{name}/config.xml",
+              ['--silent', '--fail'],
+              quiet: true)
+        .and_return(['output', 0])
+      expect(Pkg::Util::Execution).to receive(:success?).and_return(true)
       Pkg::Util::Jenkins.jenkins_job_exists?(name)
     end
 
-    it "should return false on job not existing" do
-      Pkg::Util::Net.should_receive(:curl_form_data).with("http://#{build_host}/job/#{name}/config.xml", ["--silent", "--fail"], :quiet => true).and_return(['output', 1])
-      Pkg::Util::Execution.should_receive(:success?).and_return(false)
-      Pkg::Util::Jenkins.jenkins_job_exists?(name).should be_false
+    it 'should return false on job not existing' do
+      expect(Pkg::Util::Net)
+        .to receive(:curl_form_data)
+        .with("http://#{build_host}/job/#{name}/config.xml",
+              ['--silent', '--fail'],
+              quiet: true)
+        .and_return(['output', 1])
+      expect(Pkg::Util::Execution)
+        .to receive(:success?)
+        .and_return(false)
+      expect(Pkg::Util::Jenkins.jenkins_job_exists?(name)).to be false
     end
 
-    it "should return false if curl_form_data raised a runtime error" do
-      Pkg::Util::Net.should_receive(:curl_form_data).with("http://#{build_host}/job/#{name}/config.xml", ["--silent", "--fail"], :quiet => true).and_return(false)
-      Pkg::Util::Jenkins.jenkins_job_exists?(name).should be_false
+    it 'should return false if curl_form_data raised a runtime error' do
+      expect(Pkg::Util::Net)
+        .to receive(:curl_form_data)
+        .with("http://#{build_host}/job/#{name}/config.xml",
+              ['--silent', '--fail'],
+              quiet: true)
+        .and_return(false)
+      expect(Pkg::Util::Jenkins.jenkins_job_exists?(name)).to be false
     end
 
-    it "should return true when job exists" do
-      Pkg::Util::Net.should_receive(:curl_form_data).with("http://#{build_host}/job/#{name}/config.xml", ["--silent", "--fail"], :quiet => true).and_return(['output', 0])
-      Pkg::Util::Execution.should_receive(:success?).and_return(true)
-      Pkg::Util::Jenkins.jenkins_job_exists?(name).should be_true
+    it 'should return true when job exists' do
+      expect(Pkg::Util::Net)
+        .to receive(:curl_form_data)
+        .with("http://#{build_host}/job/#{name}/config.xml",
+              ['--silent', '--fail'],
+              quiet: true)
+        .and_return(['output', 0])
+      expect(Pkg::Util::Execution).to receive(:success?).and_return(true)
+      expect(Pkg::Util::Jenkins.jenkins_job_exists?(name)).to be true
     end
   end
 
   describe '#poll_jenkins_job' do
-    let(:job_url) { "http://cat.meow/" }
+    let(:job_url) { 'http://cat.meow' }
     let(:build_url) { "#{job_url}/1" }
-    let(:result) { "SUCCESS" }
-    let(:job_hash) { {'lastBuild' => { 'url' => build_url } }}
-    let(:build_hash) { {'result' => result, 'building' => false } }
+    let(:result) { 'SUCCESS' }
+    let(:job_hash) { { 'lastBuild' => { 'url' => build_url } } }
+    let(:build_hash) { { 'result' => result, 'building' => false } }
 
     before :each do
-      subject.stub(:get_jenkins_info).with(job_url).and_return(job_hash)
-      subject.stub(:wait_for_build).with(build_url).and_return(build_hash)
+      allow(subject).to receive(:get_jenkins_info).with(job_url).and_return(job_hash)
+      allow(subject).to receive(:wait_for_build).with(build_url).and_return(build_hash)
     end
 
     context "when polling the given url" do
@@ -66,47 +93,51 @@ describe Pkg::Util::Jenkins do
   end
 
   describe '#wait_for_build' do
-    let(:job_url) { "http://cat.meow/" }
+    let(:job_url) { 'http://cat.meow' }
     let(:build_url) { "#{job_url}/1" }
-    let(:build_hash) { {'building' => false } }
+    let(:build_hash) { { 'building' => false } }
 
     context "when waiting for the given build to finish" do
       it "return the resulting build_hash when build completes successfully" do
-        subject.should_receive(:get_jenkins_info).with(job_url).and_return(build_hash)
+        expect(subject).to receive(:get_jenkins_info).with(job_url).and_return(build_hash)
         subject.wait_for_build(job_url)
       end
     end
   end
 
   describe '#get_jenkins_info' do
-    let(:url) { "http://cat.meow/" }
+    let(:url) { 'http://cat.meow' }
     let(:uri) { URI(url) }
     let(:response) { double }
-    let(:valid_json) { "{\"employees\":[
-    {\"firstName\":\"John\", \"lastName\":\"Doe\"},
-    {\"firstName\":\"Anna\", \"lastName\":\"Smith\"},
-    {\"firstName\":\"Peter\", \"lastName\":\"Jones\"} ]}" }
+    let(:valid_json) do
+      {
+        'employees' => [
+          { 'firstName' => 'John', 'lastName' => 'Doe' },
+          { 'firstName' => 'Anna', 'lastName' => 'Smith' },
+          { 'firstName' => 'Peter', 'lastName' => 'Jones' }
+        ]
+      }.to_json
+    end
 
     before :each do
-      response.stub(:body).and_return( valid_json )
-      response.stub(:code).and_return( '200' )
-      Pkg::Util::Jenkins.should_receive(:URI).and_return(uri)
+      allow(response).to receive(:body).and_return(valid_json)
+      allow(response).to receive(:code).and_return('200')
+      expect(Pkg::Util::Jenkins).to receive(:URI).and_return(uri)
     end
 
-    context "when making HTTP GET request to given url" do
-      it "should return Hash of JSON contents when response is non-error" do
-        Net::HTTP.should_receive(:get_response).with(uri).and_return(response)
+    context 'when making HTTP GET request to given url' do
+      it 'should return Hash of JSON contents when response is non-error' do
+        expect(Net::HTTP).to receive(:get_response).with(uri).and_return(response)
         subject.get_jenkins_info(url)
       end
 
-      it "should raise Runtime error when response is error" do
-        response.stub(:code).and_return( '400' )
-        Net::HTTP.should_receive(:get_response).with(uri).and_return(response)
-        expect{
+      it 'should raise Runtime error when response is error' do
+        allow(response).to receive(:code).and_return('400')
+        expect(Net::HTTP).to receive(:get_response).with(uri).and_return(response)
+        expect do
           subject.get_jenkins_info(url)
-        }.to raise_error(Exception, /Unable to query .*, please check that it is valid./)
+        end.to raise_error(Exception, /Unable to query .*, please check that it is valid./)
       end
     end
   end
-
 end

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

@@ -2,7 +2,7 @@
 require 'spec_helper'
 
 describe 'Pkg::Util::Misc' do
-  context "#search_and_replace" do
+  context '#search_and_replace' do
     let(:orig_string) { "#!/bin/bash\necho '__REPO_NAME__'" }
     let(:updated_string) { "#!/bin/bash\necho 'abcdefg'" }
     let(:good_replacements) do
@@ -13,19 +13,24 @@ describe 'Pkg::Util::Misc' do
     end
 
     it 'replaces the token with the Pkg::Config variable' do
-      Pkg::Config.config_from_hash({:project => "foo", :repo_name => 'abcdefg'})
-      Pkg::Util::Misc.search_and_replace(orig_string, good_replacements).should eq(updated_string)
+      Pkg::Config.config_from_hash({ project: 'foo', repo_name: 'abcdefg' })
+      expect(Pkg::Util::Misc.search_and_replace(orig_string, good_replacements))
+        .to eq(updated_string)
     end
 
     it 'does no replacement if the Pkg::Config variable is not set' do
-      Pkg::Config.config_from_hash({:project => 'foo',})
-      Pkg::Util::Misc.search_and_replace(orig_string, good_replacements).should eq(orig_string)
+      Pkg::Config.config_from_hash({ project: 'foo' })
+      expect(Pkg::Util::Misc.search_and_replace(orig_string, good_replacements))
+        .to eq(orig_string)
     end
 
     it 'warns and continues if the Pkg::Config variable is unknown to packaging' do
-      Pkg::Config.config_from_hash({:project => 'foo',})
-      Pkg::Util::Misc.should_receive(:warn).with("replacement value for '#{warn_replacements.keys.first}' probably shouldn't be nil")
-      Pkg::Util::Misc.search_and_replace(orig_string, warn_replacements).should eq(orig_string)
+      Pkg::Config.config_from_hash({ project: 'foo' })
+      expect(Pkg::Util::Misc)
+        .to receive(:warn)
+        .with("replacement value for '#{warn_replacements.keys.first}' probably shouldn't be nil")
+      expect(Pkg::Util::Misc.search_and_replace(orig_string, warn_replacements))
+        .to eq(orig_string)
     end
   end
 end