ztk 0.2.4 → 0.2.5

data/lib/ztk/version.rb

@@ -19,5 +19,5 @@
 ################################################################################
 
 module ZTK
-  VERSION = "0.2.4" unless const_defined?(:VERSION)
+  VERSION = "0.2.5" unless const_defined?(:VERSION)
 end

data/spec/spec_helper.rb

@@ -28,6 +28,14 @@ SimpleCov.start do
   add_filter '/spec/'
 end if ENV["COVERAGE"]
 
+ENV['LOG_LEVEL'] = "DEBUG"
+
+WAIT_SMALL = 3
+
 $logger = ZTK::Logger.new(File.join("/tmp", "test.log"))
 
+$logger.info { "=" * 80 }
+$logger.info { "STARTING ZTK v#{ZTK::VERSION} TEST RUN @ #{Time.now.utc}" }
+$logger.info { "=" * 80 }
+
 ################################################################################

data/spec/ztk/base_spec.rb

@@ -0,0 +1,41 @@
+################################################################################
+#
+#      Author: Zachary Patten <zachary@jovelabs.net>
+#   Copyright: Copyright (c) Jove Labs
+#     License: Apache License, Version 2.0
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+################################################################################
+
+require "spec_helper"
+
+describe ZTK::Base do
+
+  subject { ZTK::Base }
+
+  before(:all) do
+    $stdout = File.open("/dev/null", "w")
+    $stderr = File.open("/dev/null", "w")
+    $stdin = File.open("/dev/null", "r")
+  end
+
+  describe "class" do
+
+    it "should be ZTK::Base" do
+      subject.should be ZTK::Base
+    end
+
+  end
+
+end

data/spec/ztk/benchmark_spec.rb

@@ -53,25 +53,23 @@ describe ZTK::Benchmark do
       mark.should be_an_instance_of Float
     end
 
-    it "should not write to STDOUT if not given a message or mark" do
+    it "should throw an exception if executed with a message but without a mark" do
       stdout = StringIO.new
-      ZTK::Benchmark.bench(:stdout => stdout) do
-        sleep(0.1)
-      end
-      stdout.size.should == 0
+      lambda {
+        ZTK::Benchmark.bench(:stdout => stdout, :message => "Hello World")
+      }.should raise_error ZTK::BenchmarkError
     end
 
-    it "should not write to STDOUT if not given a message" do
+    it "should throw an exception if executed without a message but with a mark" do
       stdout = StringIO.new
-      ZTK::Benchmark.bench(:stdout => stdout, :mark => "%0.4f") do
-        sleep(0.1)
-      end
-      stdout.size.should == 0
+      lambda {
+        ZTK::Benchmark.bench(:stdout => stdout, :mark => "%0.4f")
+      }.should raise_error ZTK::BenchmarkError
     end
 
-    it "should not write to STDOUT if not given a mark" do
+    it "should not write to STDOUT if not given a message or mark" do
       stdout = StringIO.new
-      ZTK::Benchmark.bench(:stdout => stdout, :message => "Hello World") do
+      ZTK::Benchmark.bench(:stdout => stdout) do
         sleep(0.1)
       end
       stdout.size.should == 0

data/spec/ztk/command_spec.rb

@@ -62,16 +62,149 @@ describe ZTK::Command do
 
   end
 
-  it "should be able to execute the command \"hostname -f\"" do
-    stdout = StringIO.new
-    subject.config do |config|
-      config.stdout = stdout
+  describe "behaviour" do
+
+    describe "execute" do
+
+      it "should be able to execute the command \"hostname -f\"" do
+        stdout = StringIO.new
+        subject.config do |config|
+          config.stdout = stdout
+        end
+        hostname = %x(hostname -f).chomp
+        status = subject.exec("hostname -f")
+        status.exit_code.should == 0
+        stdout.rewind
+        stdout.read.chomp.should == hostname
+      end
+
+      it "should timeout after the period specified" do
+        stdout = StringIO.new
+        subject.config do |config|
+          config.stdout = stdout
+          config.timeout = WAIT_SMALL
+        end
+        hostname = %x(hostname -f).chomp
+        lambda { subject.exec("hostname -f ; sleep 10") }.should raise_error ZTK::CommandError
+      end
+
+      it "should throw an exception if the exit status is not as expected" do
+        stdout = StringIO.new
+        subject.config do |config|
+          config.stdout = stdout
+        end
+        lambda { subject.exec("/bin/bash -c 'exit 64'") }.should raise_error ZTK::CommandError
+      end
+
+      it "should return a instance of an OpenStruct object" do
+        stdout = StringIO.new
+        subject.config do |config|
+          config.stdout = stdout
+        end
+        result = subject.exec(%q{echo "Hello World"})
+        result.should be_an_instance_of OpenStruct
+      end
+
+      it "should return the exit code" do
+        stdout = StringIO.new
+        subject.config do |config|
+          config.stdout = stdout
+        end
+        data = 64
+
+        result = subject.exec(%Q{/bin/bash -c 'exit #{data}'}, :exit_code => data)
+        result.exit_code.should == data
+      end
+
+      it "should return the output" do
+        stdout = StringIO.new
+        subject.config do |config|
+          config.stdout = stdout
+        end
+        data = "Hello World @ #{Time.now.utc}"
+
+        result = subject.exec(%Q{echo "#{data}"})
+        result.output.match(data).should_not be nil
+      end
+
+      it "should allow us to change the expected exit code" do
+        stdout = StringIO.new
+        subject.config do |config|
+          config.stdout = stdout
+        end
+        data = 32
+        result = subject.exec(%Q{/bin/bash -c 'exit #{data}'}, :exit_code => data)
+      end
+
+      describe "stdout" do
+
+        it "should capture STDOUT and send it to the appropriate pipe" do
+          stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
+
+          subject.config do |config|
+            config.stdout = stdout
+            config.stderr = stderr
+            config.stdin = stdin
+          end
+          data = "Hello World @ #{Time.now.utc}"
+
+          subject.exec(%Q{echo "#{data}" -f >&1})
+
+          stdout.rewind
+          stdout.read.match(data).should_not be nil
+
+          stderr.rewind
+          stderr.read.match(data).should be nil
+
+          stdin.rewind
+          stdin.read.match(data).should be nil
+        end
+
+      end
+
+      describe "stderr" do
+
+        it "should capture STDERR and send it to the appropriate pipe" do
+          stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
+
+          subject.config do |config|
+            config.stdout = stdout
+            config.stderr = stderr
+            config.stdin = stdin
+          end
+          data = "Hello World @ #{Time.now.utc}"
+
+          subject.exec(%Q{echo "#{data}" -f >&2})
+
+          stdout.rewind
+          stdout.read.match(data).should be nil
+
+          stderr.rewind
+          stderr.read.match(data).should_not be nil
+
+          stdin.rewind
+          stdin.read.match(data).should be nil
+        end
+      end
+
     end
-    hostname = %x( hostname -f ).chomp
-    status = subject.exec("hostname -f")
-    status.exit.exitstatus.should == 0
-    stdout.rewind
-    stdout.read.chomp.should == hostname
+
+    describe "upload" do
+
+      it "should raise a 'Not Supported' exception when attempting to upload" do
+        lambda { subject.upload("abc", "123") }.should raise_error
+      end
+
+    end
+
+    describe "download" do
+
+      it "should raise a 'Not Supported' exception when attempting to download" do
+        lambda { subject.download("abc", "123") }.should raise_error
+      end
+
+    end
+
   end
 
 end

data/spec/ztk/config_spec.rb

@@ -45,26 +45,26 @@ describe ZTK::Config do
 
     end
 
-    describe "behaviour" do
+  end
 
-      it "should allow setting of arbratary configuration keys" do
-        subject.thing = "something"
-        subject.thing.should == "something"
-        subject[:thing].should == "something"
-      end
+  describe "behaviour" do
 
-      it "should allow hash bracket style access to configuration keys" do
-        subject[:thing] = "nothing"
-        subject[:thing].should == "nothing"
-      end
+    it "should allow setting of arbratary configuration keys" do
+      subject.thing = "something"
+      subject.thing.should == "something"
+      subject[:thing].should == "something"
+    end
 
-      it "should allow loading of configurations from disk" do
-        config_file = File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "test-config.rb"))
-        subject.from_file(config_file)
-        subject.message.should == "Hello World"
-        subject.thing.should == 2
-      end
+    it "should allow hash bracket style access to configuration keys" do
+      subject[:thing] = "nothing"
+      subject[:thing].should == "nothing"
+    end
 
+    it "should allow loading of configurations from disk" do
+      config_file = File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "test-config.rb"))
+      subject.from_file(config_file)
+      subject.message.should == "Hello World"
+      subject.thing.should == 2
     end
 
   end

data/spec/ztk/logger_spec.rb

@@ -85,7 +85,7 @@ describe ZTK::Logger do
 
     it "should allow writing directly to the log device" do
       data = "Hello World"
-      IO.write(subject.logdev, data)
+      subject.logdev.write(data)
       IO.read(@logfile).match(data).should_not be nil
     end
 

data/spec/ztk/rescue_retry_spec.rb

@@ -46,7 +46,7 @@ describe ZTK::RescueRetry do
       }.should raise_error ZTK::RescueRetryError, "You must supply a block!"
     end
 
-    it "should retry on all exceptions" do
+    it "should retry on all exceptions by default if one is not supplied" do
       $counter = 0
       lambda {
         ZTK::RescueRetry.try(:tries => 3) do
@@ -57,7 +57,7 @@ describe ZTK::RescueRetry do
       $counter.should == 3
     end
 
-    it "should retry on specific exceptions" do
+    it "should retry on supplied exception" do
       $counter = 0
       lambda {
         ZTK::RescueRetry.try(:tries => 3, :on => EOFError) do
@@ -68,7 +68,7 @@ describe ZTK::RescueRetry do
       $counter.should == 3
     end
 
-    it "should not retry on specific exceptions if exceptions do not match" do
+    it "should not retry on exception if it does not match the supplied exception" do
       $counter = 0
       lambda {
         ZTK::RescueRetry.try(:tries => 3, :on => EOFError) do

data/spec/ztk/spinner_spec.rb

@@ -0,0 +1,51 @@
+################################################################################
+#
+#      Author: Zachary Patten <zachary@jovelabs.net>
+#   Copyright: Copyright (c) Jove Labs
+#     License: Apache License, Version 2.0
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+################################################################################
+
+require "spec_helper"
+
+describe ZTK::Spinner do
+
+  subject { ZTK::Spinner }
+
+  before(:all) do
+    $stdout = File.open("/dev/null", "w")
+    $stderr = File.open("/dev/null", "w")
+    $stdin = File.open("/dev/null", "r")
+  end
+
+  describe "class" do
+
+    it "should be ZTK::Spinner" do
+      subject.should be ZTK::Spinner
+    end
+
+  end
+
+  describe "behaviour" do
+
+    it "should throw an exception if executed without a block" do
+      lambda {
+        ZTK::Spinner.spin
+      }.should raise_error ZTK::SpinnerError, "You must supply a block!"
+    end
+
+  end
+
+end

data/spec/ztk/ssh_spec.rb

@@ -60,183 +60,449 @@ describe ZTK::SSH do
 
     end
 
-    # this stuff doesn't work as is under travis-ci
-    if !ENV['CI'] && !ENV['TRAVIS']
+  end
 
-      describe "direct behaviour" do
+  # this stuff doesn't work as is under travis-ci right now
+  describe "direct SSH behaviour" do
 
-        describe "execute" 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
-            stdout, stderr = StringIO.new, StringIO.new
-            subject.config do |config|
-              config.stdout = stdout
-              config.stderr = stderr
-              config.user = ENV["USER"]
-              config.host_name = "127.0.0.1"
-            end
+      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
+        stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
+        subject.config do |config|
+          config.stdout, config.stderr, config.stdin = stdout, stderr, stdin
 
-            data = %x(hostname -f).chomp
+          config.user = ENV["USER"]
+          config.host_name = "127.0.0.1"
+        end
 
-            status = subject.exec("hostname -f")
-            status.exit.exitstatus.should == 0
-            stdout.rewind
-            stdout.read.chomp.should == data
-          end
+        data = %x(hostname -f).chomp
 
+        status = subject.exec("hostname -f")
+        status.exit_code.should == 0
+        stdout.rewind
+        stdout.read.chomp.should == data
+      end
+
+      it "should timeout after the period specified" do
+        stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
+        subject.config do |config|
+          config.stdout, config.stderr, config.stdin = stdout, stderr, stdin
+
+          config.user = ENV["USER"]
+          config.host_name = "127.0.0.1"
+          config.timeout = WAIT_SMALL
         end
+        hostname = %x(hostname -f).chomp
+        lambda { subject.exec("hostname -f ; sleep 10") }.should raise_error ZTK::SSHError
+      end
 
-        describe "upload" do
+      it "should throw an exception if the exit status is not as expected" do
+        stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
+        subject.config do |config|
+          config.stdout, config.stderr, config.stdin = stdout, stderr, stdin
 
-          it "should be able to upload a file to 127.0.0.1 as the current user and execute a command (your key must be in ssh-agent)" do
-            stdout, stderr = StringIO.new, StringIO.new
-            subject.config do |config|
-              config.stdout = stdout
-              config.stderr = stderr
-              config.user = ENV["USER"]
-              config.host_name = "127.0.0.1"
-            end
+          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
+      end
 
-            data = "Hello World"
+      it "should return a instance of an OpenStruct object" do
+        stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
+        subject.config do |config|
+          config.stdout, config.stderr, config.stdin = stdout, stderr, stdin
 
-            remote_file = File.join("/tmp", "ssh-upload-remote")
-            File.exists?(remote_file) && File.delete(remote_file)
+          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
+      end
 
-            local_file = File.join("/tmp", "ssh-upload-local")
-            IO.write(local_file, data)
+      it "should return the exit code" do
+        stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
+        subject.config do |config|
+          config.stdout, config.stderr, config.stdin = stdout, stderr, stdin
 
-            File.exists?(remote_file).should == false
-            subject.upload(local_file, remote_file)
-            File.exists?(remote_file).should == true
+          config.user = ENV["USER"]
+          config.host_name = "127.0.0.1"
+        end
+        data = 64
 
-            File.exists?(remote_file) && File.delete(remote_file)
-            File.exists?(local_file) && File.delete(local_file)
-          end
+        result = subject.exec(%Q{/bin/bash -c 'exit #{data}'}, :exit_code => data)
+        result.exit_code.should == data
+      end
 
+      it "should return the output" do
+        stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
+        subject.config do |config|
+          config.stdout, config.stderr, config.stdin = stdout, stderr, stdin
+
+          config.user = ENV["USER"]
+          config.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
+      end
+
+      it "should allow us to change the expected exit code" do
+        stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
+        subject.config do |config|
+          config.stdout, config.stderr, config.stdin = stdout, stderr, stdin
+
+          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)
+      end
 
-        describe "download" do
+      describe "stdout" do
 
-          it "should be able to download a file from 127.0.0.1 as the current user and execute a command (your key must be in ssh-agent)" do
-            stdout, stderr = StringIO.new, StringIO.new
-            subject.config do |config|
-              config.stdout = stdout
-              config.stderr = stderr
-              config.user = ENV["USER"]
-              config.host_name = "127.0.0.1"
-            end
+        it "should capture STDOUT and send it to the appropriate pipe" do
+          stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
+          subject.config do |config|
+            config.stdout, config.stderr, config.stdin = stdout, stderr, stdin
 
-            data = "Hello World"
+            config.user = ENV["USER"]
+            config.host_name = "127.0.0.1"
+          end
+          data = "Hello World @ #{Time.now.utc}"
+
+          subject.exec(%Q{echo "#{data}" -f >&1})
+
+          stdout.rewind
+          stdout.read.match(data).should_not be nil
+
+          stderr.rewind
+          stderr.read.match(data).should be nil
 
-            local_file = File.join("/tmp", "ssh-download-local")
-            File.exists?(local_file) && File.delete(local_file)
+          stdin.rewind
+          stdin.read.match(data).should be nil
+        end
+
+      end
 
-            remote_file = File.join("/tmp", "ssh-download-remote")
-            IO.write(remote_file, data)
+      describe "stderr" do
 
-            File.exists?(local_file).should == false
-            subject.download(remote_file, local_file)
-            File.exists?(local_file).should == true
+        it "should capture STDERR and send it to the appropriate pipe" do
+          stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
+          subject.config do |config|
+            config.stdout, config.stderr, config.stdin = stdout, stderr, stdin
 
-            File.exists?(local_file) && File.delete(local_file)
-            File.exists?(remote_file) && File.delete(remote_file)
+            config.user = ENV["USER"]
+            config.host_name = "127.0.0.1"
           end
+          data = "Hello World @ #{Time.now.utc}"
 
+          subject.exec(%Q{echo "#{data}" -f >&2})
+
+          stdout.rewind
+          stdout.read.match(data).should be nil
+
+          stderr.rewind
+          stderr.read.match(data).should_not be nil
+
+          stdin.rewind
+          stdin.read.match(data).should be nil
+        end
+      end
+
+    end
+
+    describe "upload" do
+
+      it "should be able to upload a file to 127.0.0.1 as the current user and execute a command (your key must be in ssh-agent)" do
+        stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
+        subject.config do |config|
+          config.stdout, config.stderr, config.stdin = stdout, stderr, stdin
+
+          config.user = ENV["USER"]
+          config.host_name = "127.0.0.1"
+        end
+
+        data = "Hello World @ #{Time.now.utc}"
+
+        remote_file = File.join("/tmp", "ssh-upload-remote")
+        File.exists?(remote_file) && File.delete(remote_file)
+
+        local_file = File.join("/tmp", "ssh-upload-local")
+        IO.write(local_file, data)
+
+        File.exists?(remote_file).should == false
+        subject.upload(local_file, remote_file)
+        File.exists?(remote_file).should == true
+
+        File.exists?(remote_file) && File.delete(remote_file)
+        File.exists?(local_file) && File.delete(local_file)
+      end
+
+    end
+
+    describe "download" do
+
+      it "should be able to download a file from 127.0.0.1 as the current user and execute a command (your key must be in ssh-agent)" do
+        stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
+        subject.config do |config|
+          config.stdout, config.stderr, config.stdin = stdout, stderr, stdin
+
+          config.user = ENV["USER"]
+          config.host_name = "127.0.0.1"
         end
 
+        data = "Hello World @ #{Time.now.utc}"
+
+        local_file = File.join("/tmp", "ssh-download-local")
+        File.exists?(local_file) && File.delete(local_file)
+
+        remote_file = File.join("/tmp", "ssh-download-remote")
+        IO.write(remote_file, data)
+
+        File.exists?(local_file).should == false
+        subject.download(remote_file, local_file)
+        File.exists?(local_file).should == true
+
+        File.exists?(local_file) && File.delete(local_file)
+        File.exists?(remote_file) && File.delete(remote_file)
       end
 
-      describe "proxy behaviour" do
+    end
 
-        describe "execute" do
+  end if !ENV['CI'] && !ENV['TRAVIS']
 
-          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
-            stdout, stderr = StringIO.new, StringIO.new
-            subject.config do |config|
-              config.stdout = stdout
-              config.stderr = stderr
-              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 "proxy SSH behaviour" do
 
-            data = %x( hostname -f ).chomp
+    describe "execute" do
 
-            status = subject.exec("hostname -f")
-            status.exit.exitstatus.should == 0
-            stdout.rewind
-            stdout.read.chomp.should == data
-          end
+      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
+        stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
+        subject.config do |config|
+          config.stdout, config.stderr, config.stdin = stdout, stderr, stdin
 
+          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 "upload" do
+        data = %x( hostname -f ).chomp
 
-          it "should be able to upload a file to 127.0.0.1 as the current user and execute a command (your key must be in ssh-agent)" do
-            stdout, stderr = StringIO.new, StringIO.new
-            subject.config do |config|
-              config.stdout = stdout
-              config.stderr = stderr
-              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
+        status = subject.exec("hostname -f")
+        status.exit_code.should == 0
+        stdout.rewind
+        stdout.read.chomp.should == data
+      end
 
-            data = "Hello World"
+      it "should timeout after the period specified" do
+        stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
+        subject.config do |config|
+          config.stdout, config.stderr, config.stdin = stdout, stderr, stdin
 
-            remote_file = File.join("/tmp", "ssh-upload-remote")
-            File.exists?(remote_file) && File.delete(remote_file)
+          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 -f).chomp
+        lambda { subject.exec("hostname -f ; sleep 10") }.should raise_error ZTK::SSHError
+      end
 
-            local_file = File.join("/tmp", "ssh-upload-local")
-            IO.write(local_file, data)
+      it "should throw an exception if the exit status is not as expected" do
+        stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
+        subject.config do |config|
+          config.stdout, config.stderr, config.stdin = stdout, stderr, stdin
 
-            File.exists?(remote_file).should == false
-            subject.upload(local_file, remote_file)
-            File.exists?(remote_file).should == true
+          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
+      end
 
-            File.exists?(remote_file) && File.delete(remote_file)
-            File.exists?(local_file) && File.delete(local_file)
-          end
+      it "should return a instance of an OpenStruct object" do
+        stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
+        subject.config do |config|
+          config.stdout, config.stderr, config.stdin = stdout, stderr, stdin
+
+          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
+      end
 
+      it "should return the exit code" do
+        stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
+        subject.config do |config|
+          config.stdout, config.stderr, config.stdin = stdout, stderr, stdin
+
+          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
 
-        describe "download" do
+        result = subject.exec(%Q{/bin/bash -c 'exit #{data}'}, :exit_code => data)
+        result.exit_code.should == data
+      end
+
+      it "should return the output" do
+        stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
+        subject.config do |config|
+          config.stdout, config.stderr, config.stdin = stdout, stderr, stdin
+
+          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}"
 
-          it "should be able to download a file from 127.0.0.1 as the current user and execute a command (your key must be in ssh-agent)" do
-            stdout, stderr = StringIO.new, StringIO.new
-            subject.config do |config|
-              config.stdout = stdout
-              config.stderr = stderr
-              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 "#{data}"})
+        result.output.match(data).should_not be nil
+      end
 
-            data = "Hello World"
+      it "should allow us to change the expected exit code" do
+        stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
+        subject.config do |config|
+          config.stdout, config.stderr, config.stdin = stdout, stderr, stdin
 
-            local_file = File.join("/tmp", "ssh-download-local")
-            File.exists?(local_file) && File.delete(local_file)
+          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)
+      end
 
-            remote_file = File.join("/tmp", "ssh-download-remote")
-            IO.write(remote_file, data)
+      describe "stdout" do
 
-            File.exists?(local_file).should == false
-            subject.download(remote_file, local_file)
-            File.exists?(local_file).should == true
+        it "should capture STDOUT and send it to the appropriate pipe" do
+          stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
+          subject.config do |config|
+            config.stdout, config.stderr, config.stdin = stdout, stderr, stdin
 
-            File.exists?(local_file) && File.delete(local_file)
-            File.exists?(remote_file) && File.delete(remote_file)
+            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}"
+
+          subject.exec(%Q{echo "#{data}" -f >&1})
 
+          stdout.rewind
+          stdout.read.match(data).should_not be nil
+
+          stderr.rewind
+          stderr.read.match(data).should be nil
+
+          stdin.rewind
+          stdin.read.match(data).should be nil
         end
 
       end
 
+      describe "stderr" do
+
+        it "should capture STDERR and send it to the appropriate pipe" do
+          stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
+          subject.config do |config|
+            config.stdout, config.stderr, config.stdin = stdout, stderr, stdin
+
+            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}"
+
+          subject.exec(%Q{echo "#{data}" -f >&2})
+
+          stdout.rewind
+          stdout.read.match(data).should be nil
+
+          stderr.rewind
+          stderr.read.match(data).should_not be nil
+
+          stdin.rewind
+          stdin.read.match(data).should be nil
+        end
+      end
+
     end
 
-  end
+    describe "upload" do
+
+      it "should be able to upload a file to 127.0.0.1 as the current user and execute a command (your key must be in ssh-agent)" do
+        stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
+        subject.config do |config|
+          config.stdout, config.stderr, config.stdin = stdout, stderr, stdin
+
+          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}"
+
+        remote_file = File.join("/tmp", "ssh-upload-remote")
+        File.exists?(remote_file) && File.delete(remote_file)
+
+        local_file = File.join("/tmp", "ssh-upload-local")
+        IO.write(local_file, data)
+
+        File.exists?(remote_file).should == false
+        subject.upload(local_file, remote_file)
+        File.exists?(remote_file).should == true
+
+        File.exists?(remote_file) && File.delete(remote_file)
+        File.exists?(local_file) && File.delete(local_file)
+      end
+
+    end
+
+    describe "download" do
+
+      it "should be able to download a file from 127.0.0.1 as the current user and execute a command (your key must be in ssh-agent)" do
+        stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
+        subject.config do |config|
+          config.stdout, config.stderr, config.stdin = stdout, stderr, stdin
+
+          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_file = File.join("/tmp", "ssh-download-local")
+        File.exists?(local_file) && File.delete(local_file)
+
+        remote_file = File.join("/tmp", "ssh-download-remote")
+        IO.write(remote_file, data)
+
+        File.exists?(local_file).should == false
+        subject.download(remote_file, local_file)
+        File.exists?(local_file).should == true
+
+        File.exists?(local_file) && File.delete(local_file)
+        File.exists?(remote_file) && File.delete(remote_file)
+      end
+
+    end
+
+  end if !ENV['CI'] && !ENV['TRAVIS']
 
 end