packaging 0.108.1 → 0.109.0

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

@@ -2,255 +2,296 @@ require 'spec_helper'
 require 'socket'
 require 'open3'
 
-describe "Pkg::Util::Net" do
-  let(:target)     { "/tmp/placething" }
-  let(:target_uri) { "http://google.com" }
-  let(:content)    { "stuff" }
-  let(:rsync)      { "/bin/rsync" }
-  let(:ssh)        { "/usr/local/bin/ssh" }
-  let(:s3cmd)      { "/usr/local/bin/s3cmd" }
-
-  describe "#fetch_uri" do
-    context "given a target directory" do
-      it "does nothing if the directory isn't writable" do
-        File.stub(:writable?).with(File.dirname(target)) { false }
-        File.should_receive(:open).never
+describe 'Pkg::Util::Net' do
+  let(:target)     { '/tmp/placething' }
+  let(:target_uri) { 'http://google.com' }
+  let(:content)    { 'stuff' }
+  let(:rsync)      { '/bin/rsync' }
+  let(:ssh)        { '/usr/local/bin/ssh' }
+  let(:s3cmd)      { '/usr/local/bin/s3cmd' }
+
+  describe '#fetch_uri' do
+    context 'given a target directory' do
+      it 'does nothing if the directory isn\'t writable' do
+        allow(File).to receive(:writable?).with(File.dirname(target)).and_return(false)
+        expect(File).not_to receive(:open)
         Pkg::Util::Net.fetch_uri(target_uri, target)
       end
 
-      it "writes the content of the uri to a file if directory is writable" do
-        File.should_receive(:writable?).once.with(File.dirname(target)) { true }
-        File.should_receive(:open).once.with(target, 'w')
+      it 'writes the content of the uri to a file if directory is writable' do
+        expect(File).to receive(:writable?).once.with(File.dirname(target)) { true }
+        expect(File).to receive(:open).once.with(target, 'w')
         Pkg::Util::Net.fetch_uri(target_uri, target)
       end
     end
   end
 
-  describe "hostname utils" do
-
-    describe "hostname" do
-      it "should return the hostname of the current host" do
-        Socket.stub(:gethostname) { "foo" }
-        Pkg::Util::Net.hostname.should eq("foo")
+  describe 'hostname utils' do
+    describe 'hostname' do
+      it 'should return the hostname of the current host' do
+        allow(Socket).to receive(:gethostname).and_return('foo')
+        expect(Pkg::Util::Net.hostname).to eq('foo')
       end
     end
 
-    describe "check_host" do
-      context "with required :true" do
-        it "should raise an exception if the passed host does not match the current host" do
-          Socket.stub(:gethostname) { "foo" }
-          Pkg::Util::Net.should_receive(:check_host).and_raise(RuntimeError)
-          expect{ Pkg::Util::Net.check_host("bar", :required => true) }.to raise_error(RuntimeError)
+    describe 'check_host' do
+      context 'with required :true' do
+        it 'should raise an exception if the passed host does not match the current host' do
+          allow(Socket).to receive(:gethostname).and_return('foo')
+          expect(Pkg::Util::Net).to receive(:check_host).and_raise(RuntimeError)
+          expect { Pkg::Util::Net.check_host('bar', required: true) }.to raise_error(RuntimeError)
         end
       end
 
-      context "with required :false" do
-        it "should return nil if the passed host does not match the current host" do
-          Socket.stub(:gethostname) { "foo" }
-          Pkg::Util::Net.check_host("bar", :required => false).should be_nil
+      context 'with required :false' do
+        it 'should return nil if the passed host does not match the current host' do
+          allow(Socket).to receive(:gethostname).and_return('foo')
+          expect(Pkg::Util::Net.check_host('bar', required: false)).to be_nil
         end
       end
     end
   end
 
-  describe "remote_ssh_cmd" do
-    it "should be able to call via deprecated shim" do
-      Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
-      Pkg::Util::Execution.should_receive(:capture3).with("#{ssh}  -t foo 'set -e;bar'")
-      Pkg::Util::Execution.should_receive(:success?).and_return(true)
-      Pkg::Util::Net.remote_ssh_cmd("foo", "bar", true)
+  describe 'remote_ssh_cmd' do
+    it 'should be able to call via deprecated shim' do
+      expect(Pkg::Util::Tool).to receive(:check_tool).with('ssh').and_return(ssh)
+      expect(Pkg::Util::Execution).to receive(:capture3).with("#{ssh}  -t foo 'set -e;bar'")
+      expect(Pkg::Util::Execution).to receive(:success?).and_return(true)
+      Pkg::Util::Net.remote_ssh_cmd('foo', 'bar', true)
     end
   end
 
-  describe "remote_execute" do
-    it "should fail if ssh is not present" do
-      Pkg::Util::Tool.stub(:find_tool).with("ssh") { fail }
-      Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_raise(RuntimeError)
-      expect{ Pkg::Util::Net.remote_execute("foo", "bar") }.to raise_error(RuntimeError)
+  describe 'remote_execute' do
+    it 'should fail if ssh is not present' do
+      allow(Pkg::Util::Tool).to receive(:find_tool).with('ssh').and_raise(RuntimeError)
+      expect(Pkg::Util::Tool).to receive(:check_tool).with('ssh').and_raise(RuntimeError)
+      expect { Pkg::Util::Net.remote_execute('foo', 'bar') }.to raise_error(RuntimeError)
     end
 
-    it "should be able to not fail fast" do
-        Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
-        Kernel.should_receive(:system).with("#{ssh}  -t foo 'bar'")
-        Pkg::Util::Execution.should_receive(:success?).and_return(true)
-        Pkg::Util::Net.remote_execute(
-          "foo", "bar", capture_output: false, extra_options: '', fail_fast: false)
+    it 'should be able to not fail fast' do
+      expect(Pkg::Util::Tool).to receive(:check_tool).with('ssh').and_return(ssh)
+      expect(Kernel).to receive(:system).with("#{ssh}  -t foo 'bar'")
+      expect(Pkg::Util::Execution).to receive(:success?).and_return(true)
+      Pkg::Util::Net.remote_execute(
+        'foo', 'bar', capture_output: false, extra_options: '', fail_fast: false
+      )
     end
 
-    it "should be able to trace output" do
-        Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
-        Kernel.should_receive(:system).with("#{ssh}  -t foo 'set -x;bar'")
-        Pkg::Util::Execution.should_receive(:success?).and_return(true)
-        Pkg::Util::Net.remote_execute(
-          "foo", "bar", capture_output: false, fail_fast: false, trace: true)
+    it 'should be able to trace output' do
+      expect(Pkg::Util::Tool).to receive(:check_tool).with('ssh').and_return(ssh)
+      expect(Kernel).to receive(:system).with("#{ssh}  -t foo 'set -x;bar'")
+      expect(Pkg::Util::Execution).to receive(:success?).and_return(true)
+      Pkg::Util::Net.remote_execute(
+        'foo', 'bar', capture_output: false, fail_fast: false, trace: true
+      )
     end
 
-    context "without output captured" do
-      it "should execute a command :foo on a host :bar using Kernel" do
-        Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
-        Kernel.should_receive(:system).with("#{ssh}  -t foo 'set -e;bar'")
-        Pkg::Util::Execution.should_receive(:success?).and_return(true)
-        Pkg::Util::Net.remote_execute("foo", "bar")
+    context 'without output captured' do
+      it 'should execute a command :foo on a host :bar using Kernel' do
+        expect(Pkg::Util::Tool).to receive(:check_tool).with("ssh").and_return(ssh)
+        expect(Kernel).to receive(:system).with("#{ssh}  -t foo 'set -e;bar'")
+        expect(Pkg::Util::Execution).to receive(:success?).and_return(true)
+        Pkg::Util::Net.remote_execute('foo', 'bar')
       end
 
-      it "should escape single quotes in the command" do
-        Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
-        Kernel.should_receive(:system).with("#{ssh}  -t foo 'set -e;b'\\''ar'")
-        Pkg::Util::Execution.should_receive(:success?).and_return(true)
-        Pkg::Util::Net.remote_execute("foo", "b'ar")
+      it 'should escape single quotes in the command' do
+        expect(Pkg::Util::Tool).to receive(:check_tool).with('ssh').and_return(ssh)
+        expect(Kernel).to receive(:system).with("#{ssh}  -t foo 'set -e;b'\\''ar'")
+        expect(Pkg::Util::Execution).to receive(:success?).and_return(true)
+        Pkg::Util::Net.remote_execute('foo', "b'ar")
       end
 
-      it "should raise an error if ssh fails" do
-        Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
-        Kernel.should_receive(:system).with("#{ssh}  -t foo 'set -e;bar'")
-        Pkg::Util::Execution.should_receive(:success?).and_return(false)
-        expect{ Pkg::Util::Net.remote_execute("foo", "bar") }
+      it 'should raise an error if ssh fails' do
+        expect(Pkg::Util::Tool).to receive(:check_tool).with("ssh").and_return(ssh)
+        expect(Kernel).to receive(:system).with("#{ssh}  -t foo 'set -e;bar'")
+        expect(Pkg::Util::Execution).to receive(:success?).and_return(false)
+        expect { Pkg::Util::Net.remote_execute('foo', 'bar') }
           .to raise_error(RuntimeError, /failed./)
       end
     end
 
-    context "with output captured" do
-      it "should execute a command :foo on a host :bar using Pkg::Util::Execution.capture3" do
-        Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
-        Pkg::Util::Execution.should_receive(:capture3).with("#{ssh}  -t foo 'set -e;bar'")
-        Pkg::Util::Execution.should_receive(:success?).and_return(true)
-        Pkg::Util::Net.remote_execute("foo", "bar", capture_output: true)
+    context 'with output captured' do
+      it 'should execute a command :foo on a host :bar using Pkg::Util::Execution.capture3' do
+        expect(Pkg::Util::Tool).to receive(:check_tool).with('ssh').and_return(ssh)
+        expect(Pkg::Util::Execution).to receive(:capture3).with("#{ssh}  -t foo 'set -e;bar'")
+        expect(Pkg::Util::Execution).to receive(:success?).and_return(true)
+        Pkg::Util::Net.remote_execute('foo', 'bar', capture_output: true)
       end
 
       it "should escape single quotes in the command" do
-        Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
-        Pkg::Util::Execution.should_receive(:capture3).with("#{ssh}  -t foo 'set -e;b'\\''ar'")
-        Pkg::Util::Execution.should_receive(:success?).and_return(true)
-        Pkg::Util::Net.remote_execute("foo", "b'ar", capture_output: true)
+        expect(Pkg::Util::Tool).to receive(:check_tool).with('ssh').and_return(ssh)
+        expect(Pkg::Util::Execution).to receive(:capture3).with("#{ssh}  -t foo 'set -e;b'\\''ar'")
+        expect(Pkg::Util::Execution).to receive(:success?).and_return(true)
+        Pkg::Util::Net.remote_execute('foo', "b'ar", capture_output: true)
       end
 
       it "should raise an error if ssh fails" do
-        Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
-        Pkg::Util::Execution.should_receive(:capture3).with("#{ssh}  -t foo 'set -e;bar'")
-        Pkg::Util::Execution.should_receive(:success?).and_return(false)
-        expect{ Pkg::Util::Net.remote_execute("foo", "bar", capture_output: true) }
+        expect(Pkg::Util::Tool).to receive(:check_tool).with('ssh').and_return(ssh)
+        expect(Pkg::Util::Execution).to receive(:capture3).with("#{ssh}  -t foo 'set -e;bar'")
+        expect(Pkg::Util::Execution).to receive(:success?).and_return(false)
+        expect { Pkg::Util::Net.remote_execute('foo', 'bar', capture_output: true) }
           .to raise_error(RuntimeError, /failed./)
       end
     end
   end
 
-  describe "#rsync_to" do
-    defaults = "--recursive --hard-links --links --verbose --omit-dir-times --no-perms --no-owner --no-group"
-    it "should fail if rsync is not present" do
-      Pkg::Util::Tool.stub(:find_tool).with("rsync") { fail }
-      Pkg::Util::Tool.should_receive(:check_tool).with("rsync").and_raise(RuntimeError)
-      expect{ Pkg::Util::Net.rsync_to("foo", "bar", "boo") }.to raise_error(RuntimeError)
+  describe '#rsync_to' do
+    defaults = '--recursive --hard-links --links --verbose --omit-dir-times --no-perms --no-owner --no-group'
+    it 'should fail if rsync is not present' do
+      allow(Pkg::Util::Tool).to receive(:find_tool).with('rsync').and_raise(RuntimeError)
+      expect(Pkg::Util::Tool).to receive(:check_tool).with('rsync').and_raise(RuntimeError)
+      expect { Pkg::Util::Net.rsync_to('foo', 'bar', 'boo') }.to raise_error(RuntimeError)
     end
 
     it "should rsync 'thing' to 'foo@bar:/home/foo' with flags '#{defaults} --ignore-existing'" do
-      Pkg::Util::Tool.should_receive(:check_tool).with("rsync").and_return(rsync)
-      Pkg::Util::Execution.should_receive(:capture3).with("#{rsync} #{defaults} --ignore-existing thing foo@bar:/home/foo", true)
-      Pkg::Util::Net.rsync_to("thing", "foo@bar", "/home/foo")
+      expect(Pkg::Util::Tool).to receive(:check_tool).with('rsync').and_return(rsync)
+      expect(Pkg::Util::Execution)
+        .to receive(:capture3)
+        .with("#{rsync} #{defaults} --ignore-existing thing foo@bar:/home/foo", true)
+      Pkg::Util::Net.rsync_to('thing', 'foo@bar', '/home/foo')
     end
 
     it "rsyncs 'thing' to 'foo@bar:/home/foo' with flags that don't include --ignore-existing" do
-      Pkg::Util::Tool.should_receive(:check_tool).with("rsync").and_return(rsync)
-      Pkg::Util::Execution.should_receive(:capture3).with("#{rsync} #{defaults} thing foo@bar:/home/foo", true)
-      Pkg::Util::Net.rsync_to("thing", "foo@bar", "/home/foo", extra_flags: [])
+      expect(Pkg::Util::Tool).to receive(:check_tool).with('rsync').and_return(rsync)
+      expect(Pkg::Util::Execution)
+        .to receive(:capture3)
+        .with("#{rsync} #{defaults} thing foo@bar:/home/foo", true)
+      Pkg::Util::Net.rsync_to('thing', 'foo@bar', '/home/foo', extra_flags: [])
     end
 
     it "rsyncs 'thing' to 'foo@bar:/home/foo' with flags that don't include arbitrary flags" do
-      Pkg::Util::Tool.should_receive(:check_tool).with("rsync").and_return(rsync)
-      Pkg::Util::Execution.should_receive(:capture3).with("#{rsync} #{defaults} --foo-bar --and-another-flag thing foo@bar:/home/foo", true)
-      Pkg::Util::Net.rsync_to("thing", "foo@bar", "/home/foo", extra_flags: ["--foo-bar", "--and-another-flag"])
+      expect(Pkg::Util::Tool).to receive(:check_tool).with('rsync').and_return(rsync)
+      expect(Pkg::Util::Execution)
+        .to receive(:capture3)
+        .with("#{rsync} #{defaults} --foo-bar --and-another-flag thing foo@bar:/home/foo", true)
+      Pkg::Util::Net.rsync_to('thing', 'foo@bar', '/home/foo',
+                              extra_flags: ["--foo-bar", "--and-another-flag"])
     end
   end
 
-  describe "#s3sync_to" do
-    it "should fail if s3cmd is not present" do
-      Pkg::Util::Tool.should_receive(:find_tool).with('s3cmd', :required => true).and_raise(RuntimeError)
-      Pkg::Util::Execution.should_not_receive(:capture3).with("#{s3cmd} sync  'foo' s3://bar/boo/")
-      expect{ Pkg::Util::Net.s3sync_to("foo", "bar", "boo") }.to raise_error(RuntimeError)
+  describe '#s3sync_to' do
+    it 'should fail if s3cmd is not present' do
+      expect(Pkg::Util::Tool)
+        .to receive(:find_tool)
+        .with('s3cmd', required: true)
+        .and_raise(RuntimeError)
+      expect(Pkg::Util::Execution)
+        .to_not receive(:capture3).with("#{s3cmd} sync  'foo' s3://bar/boo/")
+      expect { Pkg::Util::Net.s3sync_to('foo', 'bar', 'boo') }.to raise_error(RuntimeError)
     end
 
-    it "should fail if ~/.s3cfg is not present" do
-      Pkg::Util::Tool.should_receive(:check_tool).with("s3cmd").and_return(s3cmd)
-      Pkg::Util::File.should_receive(:file_exists?).with(File.join(ENV['HOME'], '.s3cfg')).and_return(false)
-      expect{ Pkg::Util::Net.s3sync_to("foo", "bar", "boo") }.to raise_error(RuntimeError, /does not exist/)
+    it 'should fail if ~/.s3cfg is not present' do
+      expect(Pkg::Util::Tool).to receive(:check_tool).with("s3cmd").and_return(s3cmd)
+      expect(Pkg::Util::File)
+        .to receive(:file_exists?)
+        .with(File.join(ENV['HOME'], '.s3cfg'))
+        .and_return(false)
+      expect { Pkg::Util::Net.s3sync_to('foo', 'bar', 'boo') }
+        .to raise_error(RuntimeError, /does not exist/)
     end
 
     it "should s3 sync 'thing' to 's3://foo@bar/home/foo/' with no flags" do
-      Pkg::Util::Tool.should_receive(:check_tool).with("s3cmd").and_return(s3cmd)
-      Pkg::Util::File.should_receive(:file_exists?).with(File.join(ENV['HOME'], '.s3cfg')).and_return(true)
-      Pkg::Util::Execution.should_receive(:capture3).with("#{s3cmd} sync  'thing' s3://foo@bar/home/foo/")
+      expect(Pkg::Util::Tool).to receive(:check_tool).with("s3cmd").and_return(s3cmd)
+      expect(Pkg::Util::File)
+        .to receive(:file_exists?)
+        .with(File.join(ENV['HOME'], '.s3cfg'))
+        .and_return(true)
+      expect(Pkg::Util::Execution)
+        .to receive(:capture3)
+        .with("#{s3cmd} sync  'thing' s3://foo@bar/home/foo/")
       Pkg::Util::Net.s3sync_to("thing", "foo@bar", "home/foo")
     end
 
-    it "should s3 sync 'thing' to 's3://foo@bar/home/foo/' with --delete-removed and --acl-public" do
-      Pkg::Util::Tool.should_receive(:check_tool).with("s3cmd").and_return(s3cmd)
-      Pkg::Util::File.should_receive(:file_exists?).with(File.join(ENV['HOME'], '.s3cfg')).and_return(true)
-      Pkg::Util::Execution.should_receive(:capture3).with("#{s3cmd} sync --delete-removed --acl-public 'thing' s3://foo@bar/home/foo/")
+    it "should s3sync 'thing' to 's3://foo@bar/home/foo/' with --delete-removed and --acl-public" do
+      expect(Pkg::Util::Tool).to receive(:check_tool).with("s3cmd").and_return(s3cmd)
+      expect(Pkg::Util::File)
+        .to receive(:file_exists?)
+        .with(File.join(ENV['HOME'], '.s3cfg'))
+        .and_return(true)
+      expect(Pkg::Util::Execution)
+        .to receive(:capture3)
+        .with("#{s3cmd} sync --delete-removed --acl-public 'thing' s3://foo@bar/home/foo/")
       Pkg::Util::Net.s3sync_to("thing", "foo@bar", "home/foo", ["--delete-removed", "--acl-public"])
     end
   end
 
-  describe "#rsync_from" do
+  describe '#rsync_from' do
     defaults = "--recursive --hard-links --links --verbose --omit-dir-times --no-perms --no-owner --no-group"
-    it "should fail if rsync is not present" do
-      Pkg::Util::Tool.stub(:find_tool).with("rsync") { fail }
-      Pkg::Util::Tool.should_receive(:check_tool).with("rsync").and_raise(RuntimeError)
-      expect{ Pkg::Util::Net.rsync_from("foo", "bar", "boo") }.to raise_error(RuntimeError)
+    it 'should fail if rsync is not present' do
+      allow(Pkg::Util::Tool).to receive(:find_tool).with('rsync').and_raise(RuntimeError)
+      expect(Pkg::Util::Tool).to receive(:check_tool).with('rsync').and_raise(RuntimeError)
+      expect { Pkg::Util::Net.rsync_from('foo', 'bar', 'boo') }.to raise_error(RuntimeError)
     end
 
-    it "should not include the flags '--ignore-existing' by default" do
-      Pkg::Util::Tool.should_receive(:check_tool).with("rsync").and_return(rsync)
-      Pkg::Util::Execution.should_receive(:capture3).with("#{rsync} #{defaults} foo@bar:thing /home/foo", true)
-      Pkg::Util::Net.rsync_from("thing", "foo@bar", "/home/foo")
+    it 'should not include the flags \'--ignore-existing\' by default' do
+      expect(Pkg::Util::Tool).to receive(:check_tool).with('rsync').and_return(rsync)
+      expect(Pkg::Util::Execution)
+        .to receive(:capture3)
+        .with("#{rsync} #{defaults} foo@bar:thing /home/foo", true)
+      Pkg::Util::Net.rsync_from('thing', 'foo@bar', '/home/foo')
     end
 
     it "should rsync 'thing' from 'foo@bar' to '/home/foo' with flags '#{defaults}'" do
-      Pkg::Util::Tool.should_receive(:check_tool).with("rsync").and_return(rsync)
-      Pkg::Util::Execution.should_receive(:capture3).with("#{rsync} #{defaults} foo@bar:thing /home/foo", true)
-      Pkg::Util::Net.rsync_from("thing", "foo@bar", "/home/foo")
+      expect(Pkg::Util::Tool).to receive(:check_tool).with('rsync').and_return(rsync)
+      expect(Pkg::Util::Execution)
+        .to receive(:capture3)
+        .with("#{rsync} #{defaults} foo@bar:thing /home/foo", true)
+      Pkg::Util::Net.rsync_from('thing', 'foo@bar', '/home/foo')
     end
 
     it "rsyncs 'thing' from 'foo@bar:/home/foo' with flags that don't include arbitrary flags" do
-      Pkg::Util::Tool.should_receive(:check_tool).with("rsync").and_return(rsync)
-      Pkg::Util::Execution.should_receive(:capture3).with("#{rsync} #{defaults} --foo-bar --and-another-flag foo@bar:thing /home/foo", true)
-      Pkg::Util::Net.rsync_from("thing", "foo@bar", "/home/foo", extra_flags: ["--foo-bar", "--and-another-flag"])
+      expect(Pkg::Util::Tool).to receive(:check_tool).with('rsync').and_return(rsync)
+      expect(Pkg::Util::Execution)
+        .to receive(:capture3)
+        .with("#{rsync} #{defaults} --foo-bar --and-another-flag foo@bar:thing /home/foo", true)
+      Pkg::Util::Net.rsync_from('thing', 'foo@bar', '/home/foo',
+                                extra_flags: ['--foo-bar', '--and-another-flag'])
     end
   end
 
   describe "#curl_form_data" do
-    let(:curl) {"/bin/curl"}
-    let(:form_data) {["name=FOO"]}
-    let(:options) { {:quiet => true} }
-
-    it "should return false on failure" do
-      Pkg::Util::Tool.should_receive(:check_tool).with("curl").and_return(curl)
-      Pkg::Util::Execution.should_receive(:capture3).with("#{curl} -i '#{target_uri}'").and_return(['stdout', 'stderr', 1])
-      Pkg::Util::Net.curl_form_data(target_uri).should eq(['stdout', 1])
+    let(:curl) { '/bin/curl' }
+    let(:form_data) { ['name=FOO'] }
+    let(:options) { { quiet: true } }
+
+    it 'should return false on failure' do
+      expect(Pkg::Util::Tool).to receive(:check_tool).with('curl').and_return(curl)
+      expect(Pkg::Util::Execution)
+        .to receive(:capture3)
+        .with("#{curl} -i '#{target_uri}'").and_return(['stdout', 'stderr', 1])
+      expect(Pkg::Util::Net.curl_form_data(target_uri)).to eq(['stdout', 1])
     end
 
 
     it "should curl with just the uri" do
-      Pkg::Util::Tool.should_receive(:check_tool).with("curl").and_return(curl)
-      Pkg::Util::Execution.should_receive(:capture3).with("#{curl} -i '#{target_uri}'")
+      expect(Pkg::Util::Tool).to receive(:check_tool).with('curl').and_return(curl)
+      expect(Pkg::Util::Execution).to receive(:capture3).with("#{curl} -i '#{target_uri}'")
       Pkg::Util::Net.curl_form_data(target_uri)
     end
 
-    it "should curl with the form data and uri" do
-      Pkg::Util::Tool.should_receive(:check_tool).with("curl").and_return(curl)
-      Pkg::Util::Execution.should_receive(:capture3).with("#{curl} -i #{form_data[0]} '#{target_uri}'")
+    it 'should curl with the form data and uri' do
+      expect(Pkg::Util::Tool).to receive(:check_tool).with('curl').and_return(curl)
+      expect(Pkg::Util::Execution)
+        .to receive(:capture3)
+        .with("#{curl} -i #{form_data[0]} '#{target_uri}'")
       Pkg::Util::Net.curl_form_data(target_uri, form_data)
     end
 
-    it "should curl with form data, uri, and be quiet" do
-      Pkg::Util::Tool.should_receive(:check_tool).with("curl").and_return(curl)
-      Pkg::Util::Execution.should_receive(:capture3).with("#{curl} -i #{form_data[0]} '#{target_uri}'").and_return(['stdout', 'stderr', 0])
-      Pkg::Util::Net.curl_form_data(target_uri, form_data, options).should eq(['', 0])
+    it 'should curl with form data, uri, and be quiet' do
+      expect(Pkg::Util::Tool).to receive(:check_tool).with('curl').and_return(curl)
+      expect(Pkg::Util::Execution)
+        .to receive(:capture3)
+        .with("#{curl} -i #{form_data[0]} '#{target_uri}'")
+        .and_return(['stdout', 'stderr', 0])
+      expect(Pkg::Util::Net.curl_form_data(target_uri, form_data, options)).to eq(['', 0])
     end
-
   end
 
-  describe "#print_url_info" do
-    it "should output correct formatting" do
-      Pkg::Util::Net.should_receive(:puts).with("\n////////////////////////////////////////////////////////////////////////////////\n\n
+  describe '#print_url_info' do
+    it 'should output correct formatting' do
+      expect(Pkg::Util::Net)
+        .to receive(:puts)
+        .with("\n////////////////////////////////////////////////////////////////////////////////\n\n
   Build submitted. To view your build progress, go to\n#{target_uri}\n\n
 ////////////////////////////////////////////////////////////////////////////////\n\n")
       Pkg::Util::Net.print_url_info(target_uri)

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

@@ -1,10 +1,16 @@
 require 'spec_helper'
 
-describe "Pkg::Util::RakeUtils" do
+describe 'Pkg::Util::RakeUtils' do
   let(:foo_defined?) { Rake::Task.task_defined?(:foo) }
   let(:bar_defined?) { Rake::Task.task_defined?(:bar) }
-  let(:define_foo)   { body = proc{}; Rake::Task.define_task(:foo, &body) }
-  let(:define_bar)   { body = proc{}; Rake::Task.define_task(:bar, &body) }
+  let(:define_foo) do
+    body = proc {}
+    Rake::Task.define_task(:foo, &body)
+  end
+  let(:define_bar) do
+    body = proc {}
+    Rake::Task.define_task(:bar, &body)
+  end
 
   before(:each) do
     if foo_defined?
@@ -12,21 +18,21 @@ describe "Pkg::Util::RakeUtils" do
     end
   end
 
-  describe "#task_defined?" do
-    context "given a Rake::Task task name" do
-      it "should return true if the task exists" do
-        Rake::Task.stub(:task_defined?).with(:foo) {true}
-        expect(Pkg::Util::RakeUtils.task_defined?(:foo)).to be_true
+  describe '#task_defined?' do
+    context 'given a Rake::Task task name' do
+      it 'should return true if the task exists' do
+        allow(Rake::Task).to receive(:task_defined?).with(:foo).and_return(true)
+        expect(Pkg::Util::RakeUtils.task_defined?(:foo)).to be true
       end
-      it "should return false if the task does not exist" do
-        Rake::Task.stub(:task_defined?).with(:foo) {false}
-        expect(Pkg::Util::RakeUtils.task_defined?(:foo)).to be_false
+      it 'should return false if the task does not exist' do
+        allow(Rake::Task).to receive(:task_defined?).with(:foo).and_return(false)
+        expect(Pkg::Util::RakeUtils.task_defined?(:foo)).to be false
       end
     end
   end
 
-  describe "#get_task" do
-    it "should return a task object for a named task" do
+  describe '#get_task' do
+    it 'should return a task object for a named task' do
       foo = nil
       if !foo_defined?
         foo = define_foo
@@ -39,8 +45,8 @@ describe "Pkg::Util::RakeUtils" do
     end
   end
 
-  describe "#add_dependency" do
-    it "should add a dependency to a given rake task" do
+  describe '#add_dependency' do
+    it 'should add a dependency to a given rake task' do
       foo = nil
       bar = nil
       if !foo_defined?
@@ -58,9 +64,9 @@ describe "Pkg::Util::RakeUtils" do
     end
   end
 
-  describe "#evaluate_pre_tasks" do
-    context "Given a data file with :pre_tasks defined" do
-      it "should, for each k=>v pair, add v as a dependency to k" do
+  describe '#evaluate_pre_tasks' do
+    context 'Given a data file with :pre_tasks defined' do
+      it 'should, for each k=>v pair, add v as a dependency to k' do
         Pkg::Config.config_from_yaml(File.join(FIXTURES, 'util', 'pre_tasks.yaml'))
         expect(Pkg::Util::RakeUtils).to receive(:add_dependency)
         Pkg::Util::RakeUtils.evaluate_pre_tasks

data/spec/lib/packaging_spec.rb

@@ -2,18 +2,16 @@ require 'spec_helper'
 
 #   We load packaging.rb once, in spec_helper, to avoid reloading the library
 #   and issuing warnings about already defined constants.
-describe "Pkg" do
-  it "should require the utilities module, Pkg::Util" do
-    Pkg::Util.should_not be_nil
+describe 'Pkg' do
+  it 'should require the utilities module, Pkg::Util' do
+    expect(Pkg::Util).to_not be_nil
   end
 
-  it  "should require the configuration module, Pkg::Config" do
-    Pkg::Config.should_not be_nil
+  it 'should require the configuration module, Pkg::Config' do
+    expect(Pkg::Config).to_not be_nil
   end
 
-  it  "should require the tar library, Pkg::Tar" do
-    Pkg::Tar.should_not be_nil
+  it 'should require the tar library, Pkg::Tar' do
+    expect(Pkg::Tar).to_not be_nil
   end
-
 end
-

data/tasks/apple.rake

@@ -57,19 +57,19 @@ def make_directory_tree
     mkdir_p(val)
   end
 
-  if File.exists?('ext/osx/postflight.erb')
+  if File.exist?('ext/osx/postflight.erb')
     Pkg::Util::File.erb_file 'ext/osx/postflight.erb', "#{@working_tree['scripts']}/postinstall", false, :binding => binding
   end
 
-  if File.exists?('ext/osx/preflight.erb')
+  if File.exist?('ext/osx/preflight.erb')
     Pkg::Util::File.erb_file 'ext/osx/preflight.erb', "#{@working_tree['scripts']}/preinstall", false, :binding => binding
   end
 
-  if File.exists?('ext/osx/prototype.plist.erb')
+  if File.exist?('ext/osx/prototype.plist.erb')
     Pkg::Util::File.erb_file 'ext/osx/prototype.plist.erb', "#{@scratch}/prototype.plist", false, :binding => binding
   end
 
-  if File.exists?('ext/packaging/static_artifacts/PackageInfo.plist')
+  if File.exist?('ext/packaging/static_artifacts/PackageInfo.plist')
     cp 'ext/packaging/static_artifacts/PackageInfo.plist', "#{@scratch}/PackageInfo.plist"
   end
 end
@@ -148,13 +148,13 @@ def pack_source
 
   # Setup a preinstall script and replace variables in the files with
   # the correct paths.
-  if File.exists?("#{@working_tree['scripts']}/preinstall")
+  if File.exist?("#{@working_tree['scripts']}/preinstall")
     chmod(0755, "#{@working_tree['scripts']}/preinstall")
     sh "sudo chown root:wheel #{@working_tree['scripts']}/preinstall"
   end
 
   # Setup a postinstall from from the erb created earlier
-  if File.exists?("#{@working_tree['scripts']}/postinstall")
+  if File.exist?("#{@working_tree['scripts']}/postinstall")
     chmod(0755, "#{@working_tree['scripts']}/postinstall")
     sh "sudo chown root:wheel #{@working_tree['scripts']}/postinstall"
   end
@@ -244,8 +244,7 @@ namespace :package do
     if Pkg::Config.build_dmg
       bench = Benchmark.realtime do
         # Test for pkgbuild binary
-        fail "pkgbuild must be installed." unless \
-          File.exists?(PKGBUILD)
+        fail "pkgbuild must be installed." unless File.exist?(PKGBUILD)
 
         make_directory_tree
         pack_source

data/tasks/deb.rake

@@ -52,7 +52,7 @@ task :prep_deb_tars, :work_dir do |t, args|
         elsif file.directory?
           mkdir_p "#{pkg_dir}/#{file}"
         elsif file.extname == '.erb'
-          Pkg::Util::File.erb_file(file, "#{pkg_dir}/#{file.sub(/\.[^\.]*$/, '')}", false, :binding => Pkg::Config.get_binding)
+          Pkg::Util::File.erb_file(file, "#{pkg_dir}/#{file.sub(/\.[^.]*$/, '')}", false, :binding => Pkg::Config.get_binding)
         else
           cp file, "#{pkg_dir}/#{file}"
         end