ztk 3.0.4 → 3.1.0

data/spec/ztk/rescue_retry_spec.rb

@@ -27,7 +27,7 @@ describe ZTK::RescueRetry do
   describe "class" do
 
     it "should be ZTK::RescueRetry" do
-      subject.should be ZTK::RescueRetry
+      expect(subject).to be ZTK::RescueRetry
     end
 
   end
@@ -35,42 +35,42 @@ describe ZTK::RescueRetry do
   describe "behaviour" do
 
     it "should throw an exception if executed without a block" do
-      lambda {
+      expect do
         ZTK::RescueRetry.try(:tries => 5)
-      }.should raise_error ZTK::RescueRetryError, "You must supply a block!"
+      end.to raise_error ZTK::RescueRetryError
     end
 
     it "should retry on all exceptions by default if one is not supplied" do
       $counter = 0
-      lambda {
+      expect do
         ZTK::RescueRetry.try(:tries => 3) do
           $counter += 1
           raise "TestException"
         end
-      }.should raise_error "TestException"
-      $counter.should == 3
+      end.to raise_error "TestException"
+      expect($counter).to be == 3
     end
 
     it "should retry on supplied exception" do
       $counter = 0
-      lambda {
+      expect do
         ZTK::RescueRetry.try(:tries => 3, :on => EOFError) do
           $counter += 1
           raise EOFError
         end
-      }.should raise_error EOFError
-      $counter.should == 3
+      end.to raise_error EOFError
+      expect($counter).to be == 3
     end
 
     it "should not retry on exception if it does not match the supplied exception" do
       $counter = 0
-      lambda {
+      expect do
         ZTK::RescueRetry.try(:tries => 3, :on => EOFError) do
           $counter += 1
           raise "TestException"
         end
-      }.should raise_error "TestException"
-      $counter.should == 1
+      end.to raise_error "TestException"
+      expect($counter).to be == 1
     end
 
     it "should call our lambda when it catches an exception and retries" do
@@ -78,25 +78,25 @@ describe ZTK::RescueRetry do
       on_retry_m = lambda { |exception|
         $counter += 1
       }
-      lambda {
+      expect do
         ZTK::RescueRetry.try(:tries => 3, :on => EOFError, :on_retry => on_retry_m) do
           raise EOFError
         end
-      }.should raise_error EOFError
-      $counter.should == 2
+      end.to raise_error EOFError
+      expect($counter).to be == 2
     end
 
     it "should not retry exceptions that are ignored" do
       $counter = 0
 
-      lambda {
+      expect do
         ZTK::RescueRetry.try(:tries => 3, :raise => EOFError) do
           $counter += 1
           raise EOFError
         end
-      }.should raise_error EOFError
+      end.to raise_error EOFError
 
-      $counter.should == 1
+      expect($counter).to be == 1
     end
 
   end

data/spec/ztk/spinner_spec.rb

@@ -27,7 +27,7 @@ describe ZTK::Spinner do
   describe "class" do
 
     it "should be ZTK::Spinner" do
-      subject.should be ZTK::Spinner
+      expect(subject).to be ZTK::Spinner
     end
 
   end
@@ -35,9 +35,9 @@ describe ZTK::Spinner do
   describe "behaviour" do
 
     it "should throw an exception if executed without a block" do
-      lambda {
+      expect do
         ZTK::Spinner.spin
-      }.should raise_error ZTK::SpinnerError, "You must supply a block!"
+      end.to raise_error ZTK::SpinnerError
     end
 
   end

data/spec/ztk/ssh_spec.rb

@@ -22,15 +22,9 @@ require "spec_helper"
 
 describe ZTK::SSH do
 
-  before(:each) do
-    @ui = ZTK::UI.new(
-      :stdout => StringIO.new,
-      :stderr => StringIO.new,
-      :stdin => StringIO.new
-    )
-  end
+  let(:ui) { ZTK::UI.new(:stdout => StringIO.new, :stderr => StringIO.new, :stdin => StringIO.new) }
 
-  subject { ZTK::SSH.new(:ui => @ui) }
+  subject { ZTK::SSH.new }
 
   describe "class" do
 
@@ -40,485 +34,105 @@ describe ZTK::SSH do
 
   end
 
-  # this stuff doesn't work as is under travis-ci right now
-  describe "direct SSH behaviour" do
-
-    describe "execute" do
-
-      it "should be able to connect to 127.0.0.1 as the current user and execute a command (your key must be in ssh-agent)" do
-        subject.config do |config|
-          config.ui = @ui
-
-          config.user = ENV["USER"]
-          config.host_name = "127.0.0.1"
-        end
-
-        data = %x(hostname).chomp
-
-        status = subject.exec("hostname")
-        status.exit_code.should == 0
-        @ui.stdout.rewind
-        @ui.stdout.read.chomp.should == data
-
-        expect(subject.close).to be true
-      end
-
-      it "should timeout after the period specified" do
-        subject.config do |config|
-          config.ui = @ui
-
-          config.user = ENV["USER"]
-          config.host_name = "127.0.0.1"
-          config.timeout = WAIT_SMALL
-        end
-        hostname = %x(hostname).chomp
-        lambda { subject.exec("hostname ; sleep 10") }.should raise_error ZTK::SSHError
-
-        expect(subject.close).to be true
-      end
-
-      it "should throw an exception if the exit status is not as expected" do
-        subject.config do |config|
-          config.ui = @ui
-
-          config.user = ENV["USER"]
-          config.host_name = "127.0.0.1"
-        end
-        lambda { subject.exec("/bin/bash -c 'exit 64'") }.should raise_error ZTK::SSHError
-
-        expect(subject.close).to be true
-      end
-
-      it "should return a instance of an OpenStruct object" do
-        subject.config do |config|
-          config.ui = @ui
-
-          config.user = ENV["USER"]
-          config.host_name = "127.0.0.1"
-        end
-        result = subject.exec(%q{echo "Hello World"})
-        result.should be_an_instance_of OpenStruct
-
-        expect(subject.close).to be true
-      end
-
-      it "should return the exit code" do
-        subject.config do |config|
-          config.ui = @ui
-
-          config.user = ENV["USER"]
-          config.host_name = "127.0.0.1"
-        end
-        data = 64
-
-        result = subject.exec(%Q{/bin/bash -c 'exit #{data}'}, :exit_code => data)
-        result.exit_code.should == data
-
-        expect(subject.close).to be true
-      end
+  [ :direct, :proxy ].each do |connection_type|
 
-      it "should return the output" do
-        subject.config do |config|
-          config.ui = @ui
-
-          config.user = ENV["USER"]
-          config.host_name = "127.0.0.1"
-        end
-        data = "Hello World @ #{Time.now.utc}"
+    before(:each) do
+      subject.config do |config|
+        config.ui = ui
+        config.user = ENV["USER"]
+        config.host_name = "127.0.0.1"
 
-        result = subject.exec(%Q{echo "#{data}"})
-        result.output.match(data).should_not be nil
-
-        expect(subject.close).to be true
-      end
-
-      it "should allow us to change the expected exit code" do
-        subject.config do |config|
-          config.ui = @ui
-
-          config.user = ENV["USER"]
-          config.host_name = "127.0.0.1"
-        end
-        data = 32
-        result = subject.exec(%Q{/bin/bash -c 'exit #{data}'}, :exit_code => data)
-
-        expect(subject.close).to be true
-      end
-
-      it "should allow us to execute a bootstrap script" do
-        subject.config do |config|
-          config.ui = @ui
-
-          config.user = ENV["USER"]
-          config.host_name = "127.0.0.1"
-        end
-        data = "Hello World @ #{Time.now.utc}"
-
-        result = subject.bootstrap(<<-EOBOOTSTRAP)
-echo "#{data}" >&1
-EOBOOTSTRAP
-
-        expect(result.output).to match(/#{data}/)
-
-        expect(subject.close).to be true
-      end
-
-      it "should allow us to write a file" do
-        subject.config do |config|
-          config.ui = @ui
-
-          config.user = ENV["USER"]
-          config.host_name = "127.0.0.1"
-        end
-        data = "Hello World @ #{Time.now.utc}"
-        test_filename = File.join("", "tmp", "test_file.txt")
-
-        subject.file(:target => test_filename) do |f|
-          f.write(data)
-        end
-
-        result = subject.exec(%Q{cat #{test_filename}})
-
-        expect(result.output).to match(/#{data}/)
-
-        expect(subject.close).to be true
-      end
-
-      describe "stdout" do
-
-        it "should capture STDOUT (with PTY) and send it to the STDOUT pipe" do
-          subject.config do |config|
-            config.ui = @ui
-
-            config.user = ENV["USER"]
-            config.host_name = "127.0.0.1"
-          end
-          data = "Hello World @ #{Time.now.utc}"
-
-          subject.exec(%Q{echo "#{data}" >&1})
-
-          @ui.stdout.rewind
-          expect(@ui.stdout.read).to match(/#{data}/)
-
-          @ui.stderr.rewind
-          expect(@ui.stderr.read).to be_empty
-
-          @ui.stdin.rewind
-          expect(@ui.stdin.read).to be_empty
-
-          expect(subject.close).to be true
-        end
-
-        it "should capture STDOUT (without PTY) and send it to the STDOUT pipe" do
-          subject.config do |config|
-            config.ui = @ui
-
-            config.user = ENV["USER"]
-            config.host_name = "127.0.0.1"
-
-            config.request_pty = false
-          end
-          data = "Hello World @ #{Time.now.utc}"
-
-          subject.exec(%Q{echo "#{data}" >&1})
-
-          @ui.stdout.rewind
-          expect(@ui.stdout.read).to match(/#{data}/)
-
-          @ui.stderr.rewind
-          expect(@ui.stderr.read).to be_empty
-
-          @ui.stdin.rewind
-          expect(@ui.stdin.read).to be_empty
-
-          expect(subject.close).to be true
-        end
-
-      end
-
-      describe "stderr" do
-
-        it "should capture STDERR (with PTY) and send it to the STDOUT pipe" do
-          subject.config do |config|
-            config.ui = @ui
-
-            config.user = ENV["USER"]
-            config.host_name = "127.0.0.1"
-          end
-          data = "Hello World @ #{Time.now.utc}"
-
-          subject.exec(%Q{echo "#{data}" >&2})
-
-          @ui.stdout.rewind
-          expect(@ui.stdout.read).to match(/#{data}/)
-
-          @ui.stderr.rewind
-          expect(@ui.stderr.read).to be_empty
-
-          @ui.stdin.rewind
-          expect(@ui.stdin.read).to be_empty
-
-          expect(subject.close).to be true
-        end
-
-        it "should capture STDERR (without PTY) and send it to the STDERR pipe" do
-          subject.config do |config|
-            config.ui = @ui
-
-            config.user = ENV["USER"]
-            config.host_name = "127.0.0.1"
-
-            config.request_pty = false
-          end
-          data = "Hello World @ #{Time.now.utc}"
-
-          subject.exec(%Q{echo "#{data}" >&2})
-
-          @ui.stdout.rewind
-          expect(@ui.stdout.read).to be_empty
-
-          @ui.stderr.rewind
-          expect(@ui.stderr.read).to match(/#{data}/)
-
-          @ui.stdin.rewind
-          expect(@ui.stdin.read).to be_empty
-
-          expect(subject.close).to be true
-        end
-
-      end
-
-    end
-
-    describe "upload" do
-
-      [true, false].each do |use_scp|
-        it "should be able to upload a file to 127.0.0.1 as the current user using #{use_scp ? 'scp' : 'sftp'} (your key must be in ssh-agent)" do
-          subject.config do |config|
-            config.ui = @ui
-
-            config.user = ENV["USER"]
-            config.host_name = "127.0.0.1"
-          end
-
-          data = "Hello World @ #{Time.now.utc}"
-
-          remote_temp = Tempfile.new('remote')
-          remote_file = File.join(ZTK::Locator.root, "tmp", File.basename(remote_temp.path.dup))
-          remote_temp.close
-          File.exists?(remote_file) && File.delete(remote_file)
-
-          local_temp = Tempfile.new('local')
-          local_file = File.join(ZTK::Locator.root, "tmp", File.basename(local_temp.path.dup))
-          local_temp.close
-          if RUBY_VERSION < "1.9.3"
-            File.open(local_file, 'w') do |file|
-              file.puts(data)
-            end
-          else
-            IO.write(local_file, data)
-          end
-
-          File.exists?(remote_file).should == false
-          subject.upload(local_file, remote_file, :use_scp => use_scp)
-          File.exists?(remote_file).should == true
-
-          File.exists?(remote_file) && File.delete(remote_file)
-          File.exists?(local_file) && File.delete(local_file)
-
-          expect(subject.close).to be true
+        if connection_type == :proxy
+          config.proxy_user = ENV["USER"]
+          config.proxy_host_name = "127.0.0.1"
         end
       end
-
     end
 
-    describe "download" do
+    describe "#console (#{connection_type})" do
 
-      [true, false].each do |use_scp|
-        it "should be able to download a file from 127.0.0.1 as the current user using #{use_scp ? 'scp' : 'sftp'} (your key must be in ssh-agent)" do
-          subject.config do |config|
-            config.ui = @ui
+      it "should execute a console" do
+        expect(Kernel).to receive(:exec)
 
-            config.user = ENV["USER"]
-            config.host_name = "127.0.0.1"
-          end
-
-          data = "Hello World @ #{Time.now.utc}"
-
-          local_temp = Tempfile.new('local')
-          local_file = File.join(ZTK::Locator.root, "tmp", File.basename(local_temp.path.dup))
-          local_temp.close
-          File.exists?(local_file) && File.delete(local_file)
-
-          remote_temp = Tempfile.new('remote')
-          remote_file = File.join(ZTK::Locator.root, "tmp", File.basename(remote_temp.path.dup))
-          remote_temp.close
-          if RUBY_VERSION < "1.9.3"
-            File.open(remote_file, 'w') do |file|
-              file.puts(data)
-            end
-          else
-            IO.write(remote_file, data)
-          end
-
-          File.exists?(local_file).should == false
-          subject.download(remote_file, local_file, :use_scp => use_scp)
-          File.exists?(local_file).should == true
-
-          File.exists?(local_file) && File.delete(local_file)
-          File.exists?(remote_file) && File.delete(remote_file)
-
-          expect(subject.close).to be true
-        end
+        subject.console
       end
 
     end
 
-  end
-
-  describe "proxy SSH behaviour" do
-
-    describe "execute" do
-
-      it "should be able to proxy through 127.0.0.1, connecting to 127.0.0.1 as the current user and execute a command (your key must be in ssh-agent)" do
-        subject.config do |config|
-          config.ui = @ui
-
-          config.user = ENV["USER"]
-          config.host_name = "127.0.0.1"
-          config.proxy_user = ENV["USER"]
-          config.proxy_host_name = "127.0.0.1"
-        end
+    describe "#execute (#{connection_type})" do
 
-        data = %x( hostname ).chomp
+      it "should be able to connect to 127.0.0.1 as the current user and execute a command (your key must be in ssh-agent)" do
+        data = %x(hostname).chomp
 
         status = subject.exec("hostname")
-        status.exit_code.should == 0
-        @ui.stdout.rewind
-        @ui.stdout.read.chomp.should == data
+        expect(status.exit_code).to be == 0
 
-        expect(subject.close).to be true
+        ui.stdout.rewind
+        expect(ui.stdout.read.chomp).to match(data)
+
+        expect(subject.close).to be == true
       end
 
       it "should timeout after the period specified" do
-        subject.config do |config|
-          config.ui = @ui
+        subject.config.timeout = WAIT_SMALL
 
-          config.user = ENV["USER"]
-          config.host_name = "127.0.0.1"
-          config.proxy_user = ENV["USER"]
-          config.proxy_host_name = "127.0.0.1"
-          config.timeout = WAIT_SMALL
-        end
-        hostname = %x(hostname).chomp
-        lambda { subject.exec("hostname ; sleep 10") }.should raise_error ZTK::SSHError
+        expect{ subject.exec("sleep 10") }.to raise_error ZTK::SSHError
 
-        expect(subject.close).to be true
+        expect(subject.close).to be == true
       end
 
       it "should throw an exception if the exit status is not as expected" do
-        subject.config do |config|
-          config.ui = @ui
+        expect{ subject.exec("exit 42") }.to raise_error ZTK::SSHError
 
-          config.user = ENV["USER"]
-          config.host_name = "127.0.0.1"
-          config.proxy_user = ENV["USER"]
-          config.proxy_host_name = "127.0.0.1"
-        end
-        lambda { subject.exec("/bin/bash -c 'exit 64'") }.should raise_error ZTK::SSHError
-
-        expect(subject.close).to be true
+        expect(subject.close).to be == true
       end
 
       it "should return a instance of an OpenStruct object" do
-        subject.config do |config|
-          config.ui = @ui
-
-          config.user = ENV["USER"]
-          config.host_name = "127.0.0.1"
-          config.proxy_user = ENV["USER"]
-          config.proxy_host_name = "127.0.0.1"
-        end
-        result = subject.exec(%q{echo "Hello World"})
-        result.should be_an_instance_of OpenStruct
+        result = subject.exec(%{echo "Hello World"})
+        expect(result).to be_an_instance_of OpenStruct
 
-        expect(subject.close).to be true
+        expect(subject.close).to be == true
       end
 
       it "should return the exit code" do
-        subject.config do |config|
-          config.ui = @ui
-
-          config.user = ENV["USER"]
-          config.host_name = "127.0.0.1"
-          config.proxy_user = ENV["USER"]
-          config.proxy_host_name = "127.0.0.1"
-        end
         data = 64
 
-        result = subject.exec(%Q{/bin/bash -c 'exit #{data}'}, :exit_code => data)
-        result.exit_code.should == data
+        result = subject.exec(%{exit #{data}}, :exit_code => data)
+        expect(result.exit_code).to be == data
 
-        expect(subject.close).to be true
+        expect(subject.close).to be == true
       end
 
       it "should return the output" do
-        subject.config do |config|
-          config.ui = @ui
-
-          config.user = ENV["USER"]
-          config.host_name = "127.0.0.1"
-          config.proxy_user = ENV["USER"]
-          config.proxy_host_name = "127.0.0.1"
-        end
         data = "Hello World @ #{Time.now.utc}"
 
         result = subject.exec(%Q{echo "#{data}"})
-        result.output.match(data).should_not be nil
+        expect(result.output).to match(data)
 
-        expect(subject.close).to be true
+        expect(subject.close).to be == true
       end
 
       it "should allow us to change the expected exit code" do
-        subject.config do |config|
-          config.ui = @ui
-
-          config.user = ENV["USER"]
-          config.host_name = "127.0.0.1"
-          config.proxy_user = ENV["USER"]
-          config.proxy_host_name = "127.0.0.1"
-        end
         data = 32
-        result = subject.exec(%Q{/bin/bash -c 'exit #{data}'}, :exit_code => data)
 
-        expect(subject.close).to be true
+        result = subject.exec(%{exit #{data}}, :exit_code => data)
+        expect(result.exit_code).to be == data
+
+        expect(subject.close).to be == true
       end
 
       it "should allow us to execute a bootstrap script" do
-        subject.config do |config|
-          config.ui = @ui
-
-          config.user = ENV["USER"]
-          config.host_name = "127.0.0.1"
-        end
         data = "Hello World @ #{Time.now.utc}"
 
         result = subject.bootstrap(<<-EOBOOTSTRAP)
 echo "#{data}" >&1
 EOBOOTSTRAP
+        expect(result.output.chomp).to match(data)
 
-        expect(result.output).to match(/#{data}/)
-
-        expect(subject.close).to be true
+        expect(subject.close).to be == true
       end
 
       it "should allow us to write a file" do
-        subject.config do |config|
-          config.ui = @ui
-
-          config.user = ENV["USER"]
-          config.host_name = "127.0.0.1"
-        end
         data = "Hello World @ #{Time.now.utc}"
         test_filename = File.join("", "tmp", "test_file.txt")
 
@@ -526,140 +140,74 @@ EOBOOTSTRAP
           f.write(data)
         end
 
-        result = subject.exec(%Q{cat #{test_filename}})
+        result = subject.exec(%{cat #{test_filename}})
+        expect(result.output.chomp).to match(data)
 
-        expect(result.output).to match(/#{data}/)
-
-        expect(subject.close).to be true
+        expect(subject.close).to be == true
       end
 
-      describe "stdout" do
-
-        it "should capture STDOUT (with PTY) and send it to the STDOUT pipe" do
-          subject.config do |config|
-            config.ui = @ui
+    end #execute
 
-            config.user = ENV["USER"]
-            config.host_name = "127.0.0.1"
-            config.proxy_user = ENV["USER"]
-            config.proxy_host_name = "127.0.0.1"
-          end
-          data = "Hello World @ #{Time.now.utc}"
+    describe "#ui (#{connection_type})" do
 
-          subject.exec(%Q{echo "#{data}" >&1})
+      describe "#stdout (#{connection_type})" do
 
-          @ui.stdout.rewind
-          expect(@ui.stdout.read).to match(/#{data}/)
+        [true, false].each do |request_pty|
 
-          @ui.stderr.rewind
-          expect(@ui.stderr.read).to be_empty
+          it "should capture STDOUT #{request_pty ? "with" : "without"} PTY and send it to the STDOUT pipe" do
+            subject.config.request_pty = request_pty
+            data = "Hello World @ #{Time.now.utc}"
 
-          @ui.stdin.rewind
-          expect(@ui.stdin.read).to be_empty
+            subject.exec(%{echo "#{data}" >&1})
 
-          expect(subject.close).to be true
-        end
+            ui.stdout.rewind
+            expect(ui.stdout.read).to match(data)
 
-        it "should capture STDOUT (without PTY) and send it to the STDOUT pipe" do
-          subject.config do |config|
-            config.ui = @ui
+            ui.stderr.rewind
+            expect(ui.stderr.read).to be_empty
 
-            config.user = ENV["USER"]
-            config.host_name = "127.0.0.1"
-            config.proxy_user = ENV["USER"]
-            config.proxy_host_name = "127.0.0.1"
+            ui.stdin.rewind
+            expect(ui.stdin.read).to be_empty
 
-            config.request_pty = false
+            expect(subject.close).to be == true
           end
-          data = "Hello World @ #{Time.now.utc}"
-
-          subject.exec(%Q{echo "#{data}" >&1})
-
-          @ui.stdout.rewind
-          expect(@ui.stdout.read).to match(/#{data}/)
 
-          @ui.stderr.rewind
-          expect(@ui.stderr.read).to be_empty
-
-          @ui.stdin.rewind
-          expect(@ui.stdin.read).to be_empty
-
-          expect(subject.close).to be true
         end
 
-      end
-
-      describe "stderr" do
-
-        it "should capture STDERR (with PTY) and send it to the STDOUT pipe" do
-          subject.config do |config|
-            config.ui = @ui
-
-            config.user = ENV["USER"]
-            config.host_name = "127.0.0.1"
-            config.proxy_user = ENV["USER"]
-            config.proxy_host_name = "127.0.0.1"
-          end
-          data = "Hello World @ #{Time.now.utc}"
+      end #stdout
 
-          subject.exec(%Q{echo "#{data}" >&2})
+      describe "#stderr (#{connection_type})" do
 
-          @ui.stdout.rewind
-          expect(@ui.stdout.read).to match(/#{data}/)
+        [true, false].each do |request_pty|
 
-          @ui.stderr.rewind
-          expect(@ui.stderr.read).to be_empty
+          it "should capture STDERR #{request_pty ? "with" : "without"} PTY and send it to the #{request_pty ? "STDOUT" : "STDERR"} pipe" do
+            subject.config.request_pty = request_pty
+            data = "Hello World @ #{Time.now.utc}"
 
-          @ui.stdin.rewind
-          expect(@ui.stdin.read).to be_empty
+            subject.exec(%{echo "#{data}" >&2})
 
-          expect(subject.close).to be true
-        end
+            ui.stdout.rewind
+            expect(ui.stdout.read).to (request_pty ? match(data) : be_empty)
 
-        it "should capture STDERR (without PTY) and send it to the STDERR pipe" do
-          subject.config do |config|
-            config.ui = @ui
+            ui.stderr.rewind
+            expect(ui.stderr.read).to (request_pty ? be_empty : match(data))
 
-            config.user = ENV["USER"]
-            config.host_name = "127.0.0.1"
-            config.proxy_user = ENV["USER"]
-            config.proxy_host_name = "127.0.0.1"
+            ui.stdin.rewind
+            expect(ui.stdin.read).to be_empty
 
-            config.request_pty = false
+            expect(subject.close).to be == true
           end
-          data = "Hello World @ #{Time.now.utc}"
-
-          subject.exec(%Q{echo "#{data}" >&2})
-
-          @ui.stdout.rewind
-          expect(@ui.stdout.read).to be_empty
 
-          @ui.stderr.rewind
-          expect(@ui.stderr.read).to match(/#{data}/)
-
-          @ui.stdin.rewind
-          expect(@ui.stdin.read).to be_empty
-
-          expect(subject.close).to be true
         end
 
-      end
+      end #stderr
 
-    end
+    end #ui
 
-    describe "upload" do
+    describe "#upload (#{connection_type})" do
 
       [true, false].each do |use_scp|
-        it "should be able to upload a file to 127.0.0.1 as the current user #{use_scp ? 'scp' : 'sftp'} (your key must be in ssh-agent)" do
-          subject.config do |config|
-            config.ui = @ui
-
-            config.user = ENV["USER"]
-            config.host_name = "127.0.0.1"
-            config.proxy_user = ENV["USER"]
-            config.proxy_host_name = "127.0.0.1"
-          end
-
+        it "should be able to upload a file to 127.0.0.1 as the current user using #{use_scp ? 'scp' : 'sftp'} (your key must be in ssh-agent)" do
           data = "Hello World @ #{Time.now.utc}"
 
           remote_temp = Tempfile.new('remote')
@@ -678,32 +226,23 @@ EOBOOTSTRAP
             IO.write(local_file, data)
           end
 
-          File.exists?(remote_file).should == false
+          expect(File.exists?(remote_file)).to be false
           subject.upload(local_file, remote_file, :use_scp => use_scp)
-          File.exists?(remote_file).should == true
+          expect(File.exists?(remote_file)).to be == true
 
           File.exists?(remote_file) && File.delete(remote_file)
           File.exists?(local_file) && File.delete(local_file)
 
-          expect(subject.close).to be true
+          expect(subject.close).to be == true
         end
       end
 
-    end
+    end #upload
 
-    describe "download" do
+    describe "#download (#{connection_type})" do
 
       [true, false].each do |use_scp|
         it "should be able to download a file from 127.0.0.1 as the current user using #{use_scp ? 'scp' : 'sftp'} (your key must be in ssh-agent)" do
-          subject.config do |config|
-            config.ui = @ui
-
-            config.user = ENV["USER"]
-            config.host_name = "127.0.0.1"
-            config.proxy_user = ENV["USER"]
-            config.proxy_host_name = "127.0.0.1"
-          end
-
           data = "Hello World @ #{Time.now.utc}"
 
           local_temp = Tempfile.new('local')
@@ -722,18 +261,18 @@ EOBOOTSTRAP
             IO.write(remote_file, data)
           end
 
-          File.exists?(local_file).should == false
+          expect(File.exists?(local_file)).to be false
           subject.download(remote_file, local_file, :use_scp => use_scp)
-          File.exists?(local_file).should == true
+          expect(File.exists?(local_file)).to be == true
 
           File.exists?(local_file) && File.delete(local_file)
           File.exists?(remote_file) && File.delete(remote_file)
 
-          expect(subject.close).to be true
+          expect(subject.close).to be == true
         end
       end
 
-    end
+    end #download
 
   end