t2-server 0.9.3 → 1.0.0

data/lib/t2-server/xml/libxml.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2010-2012 The University of Manchester, UK.
+# Copyright (c) 2010-2013 The University of Manchester, UK.
 #
 # All rights reserved.
 #
@@ -80,7 +80,8 @@ module T2Server
       end
 
       def xpath_attr(doc, expr, attribute)
-        doc.find_first(expr, Namespaces::MAP).attributes[attribute]
+        node = xpath_first(doc, expr)
+        node.nil? ? nil : node.attributes[attribute]
       end
     end
   end

data/lib/t2-server/xml/nokogiri.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2010-2012 The University of Manchester, UK.
+# Copyright (c) 2010-2013 The University of Manchester, UK.
 #
 # All rights reserved.
 #
@@ -50,7 +50,7 @@ module T2Server
       end
 
       def xml_children(doc, &block)
-        doc.children.each &block
+        doc.children.each(&block)
       end
 
       def xml_node_name(node)
@@ -78,7 +78,8 @@ module T2Server
       end
 
       def xpath_attr(doc, expr, attribute)
-        doc.at_xpath(expr, Namespaces::MAP)[attribute]
+        node = xpath_first(doc, expr)
+        node.nil? ? nil : node[attribute]
       end
     end
   end

data/lib/t2-server/xml/rexml.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2010-2012 The University of Manchester, UK.
+# Copyright (c) 2010-2013 The University of Manchester, UK.
 #
 # All rights reserved.
 #
@@ -78,7 +78,8 @@ module T2Server
       end
 
       def xpath_attr(doc, expr, attribute)
-        REXML::XPath.first(doc, expr, Namespaces::MAP).attributes[attribute]
+        node = xpath_first(doc, expr)
+        node.nil? ? nil : node.attributes[attribute]
       end
     end
   end

data/lib/t2-server/xml/xml.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2010-2012 The University of Manchester, UK.
+# Copyright (c) 2010-2013 The University of Manchester, UK.
 #
 # All rights reserved.
 #
@@ -39,6 +39,7 @@ rescue LoadError
     require 't2-server/xml/rexml'
   end
 end
+require 't2-server/xml/xpath_cache'
 
 module T2Server
   module XML
@@ -58,54 +59,64 @@ module T2Server
     end
 
     module Fragments
-      WORKFLOW      = "<t2s:workflow xmlns:t2s=\"#{Namespaces::SERVER}\">\n" +
-                      "  %s\n</t2s:workflow>"
-      RUNINPUT      = "<t2sr:runInput xmlns:t2sr=\"#{Namespaces::REST}\">\n" +
-                      "  %s\n</t2sr:runInput>"
+      WORKFLOW      = "<t2s:workflow xmlns:t2s=\"#{Namespaces::SERVER}\">\n"\
+                        "  %s\n</t2s:workflow>"
+      RUNINPUT      = "<t2sr:runInput xmlns:t2sr=\"#{Namespaces::REST}\">\n"\
+                        "  %s\n</t2sr:runInput>"
       RUNINPUTVALUE = RUNINPUT % "<t2sr:value>%s</t2sr:value>"
       RUNINPUTFILE  = RUNINPUT % "<t2sr:file>%s</t2sr:file>"
-      UPLOAD        = "<t2sr:upload xmlns:t2sr=\"#{Namespaces::REST}\" " +
+      UPLOAD        = "<t2sr:upload xmlns:t2sr=\"#{Namespaces::REST}\" "\
                         "t2sr:name=\"%s\">\n  %s\n</t2sr:upload>"
-      MKDIR         = "<t2sr:mkdir xmlns:t2sr=\"#{Namespaces::REST}\" " +
+      MKDIR         = "<t2sr:mkdir xmlns:t2sr=\"#{Namespaces::REST}\" "\
                         "t2sr:name=\"%s\" />"
 
-      PERMISSION    = "<t2sr:userName>%s</t2sr:userName>" +
+      PERMISSION    = "<t2sr:userName>%s</t2sr:userName>"\
                       "<t2sr:permission>%s</t2sr:permission>"
-      PERM_UPDATE   = "<t2sr:permissionUpdate " +
-                      "xmlns:t2sr=\"#{Namespaces::REST}\">" +
-                      "#{PERMISSION}</t2sr:permissionUpdate>"
+      PERM_UPDATE   = "<t2sr:permissionUpdate "\
+                        "xmlns:t2sr=\"#{Namespaces::REST}\">"\
+                        "#{PERMISSION}</t2sr:permissionUpdate>"
 
       SERVICE_URI   = "<t2s:serviceURI>%s</t2s:serviceURI>"
-      CREDENTIAL    = "<t2sr:credential xmlns:t2sr=\"#{Namespaces::REST}\"" +
-                        " xmlns:t2s=\"#{Namespaces::SERVER}\">\n" +
-                      "%s\n</t2sr:credential>"
-      USERPASS_CRED = "<t2s:userpass>\n" +
-                      "  #{SERVICE_URI}\n" +
-                      "  <t2s:username>%s</t2s:username>\n" +
-                      "  <t2s:password>%s</t2s:password>\n" +
-                      "</t2s:userpass>"
+      CREDENTIAL    = "<t2sr:credential xmlns:t2sr=\"#{Namespaces::REST}\""\
+                        " xmlns:t2s=\"#{Namespaces::SERVER}\">\n"\
+                        "%s\n</t2sr:credential>"
+      USERPASS_CRED = "<t2s:userpass>\n"\
+                        "  #{SERVICE_URI}\n"\
+                        "  <t2s:username>%s</t2s:username>\n"\
+                        "  <t2s:password>%s</t2s:password>\n"\
+                        "</t2s:userpass>"
 
-      KEYPAIR_CRED  = "<t2s:keypair>\n" +
-                      "  #{SERVICE_URI}\n" +
-                      "  <t2s:credentialName>%s</t2s:credentialName>\n" +
-                      "  <t2s:credentialBytes>%s</t2s:credentialBytes>\n" +
-                      "  <t2s:fileType>%s</t2s:fileType>\n" +
-                      "  <t2s:unlockPassword>%s</t2s:unlockPassword>\n" +
-                      "</t2s:keypair>"
+      KEYPAIR_CRED  = "<t2s:keypair>\n"\
+                        "  #{SERVICE_URI}\n"\
+                        "  <t2s:credentialName>%s</t2s:credentialName>\n"\
+                        "  <t2s:credentialBytes>%s</t2s:credentialBytes>\n"\
+                        "  <t2s:fileType>%s</t2s:fileType>\n"\
+                        "  <t2s:unlockPassword>%s</t2s:unlockPassword>\n"\
+                        "</t2s:keypair>"
 
-      TRUST         = "<t2s:trustedIdentity " +
-                        "xmlns:t2s=\"#{Namespaces::SERVER}\">\n" +
-                      "  <t2s:certificateBytes>%s</t2s:certificateBytes>\n" +
-                      "  <t2s:fileType>%s</t2s:fileType>\n" +
-                      "</t2s:trustedIdentity>"
+      TRUST         = "<t2s:trustedIdentity "\
+                        "xmlns:t2s=\"#{Namespaces::SERVER}\">\n"\
+                        "  <t2s:certificateBytes>%s</t2s:certificateBytes>\n"\
+                        "  <t2s:fileType>%s</t2s:fileType>\n"\
+                        "</t2s:trustedIdentity>"
     end
 
     module Methods
-      # The methods in this namespace are provided by the particular XML
-      # library selected above. The xpath_compile method needs to be declared
-      # as a module method so it can be used as a class method when it is
-      # mixed in.
-      module_function :xpath_compile
+      # Most methods in this module are provided by the particular XML
+      # library selected above.
+
+      # Given a list of xpath keys, extract the href URIs from those elements.
+      def get_uris_from_doc(doc, keys)
+        cache = XPathCache.instance
+        uris = {}
+
+        keys.each do |key|
+          uri = xpath_attr(doc, cache[key], "href")
+          uris[key] = uri.nil? ? nil : URI.parse(uri)
+        end
+
+        uris
+      end
     end
   end
 end

data/lib/{t2server.rb → t2-server/xml/xpath_cache.rb}

@@ -1,4 +1,4 @@
-# Copyright (c) 2010, 2011 The University of Manchester, UK.
+# Copyright (c) 2010-2013 The University of Manchester, UK.
 #
 # All rights reserved.
 #
@@ -30,9 +30,31 @@
 #
 # Author: Robert Haines
 
-# This is simply here to provide backwards compatibility. Old versions had an
-# inconsistancy between the gem name and the file to require to use it.
-warn "[DEPRECATION] Code should no longer require 't2server'. Please use " +
-  "require 't2-server' as this is consistent with the gem name. In version " +
-  "1.0 require 't2server' will cease to work."
-require 't2-server'
+require 'singleton'
+
+module T2Server
+  module XML
+    class XPathCache
+      include Singleton
+      include XML::Methods
+
+      def initialize
+        @cache = {}
+        @xpaths = {}
+      end
+
+      def [](key)
+        return nil unless @xpaths.has_key? key
+        return @cache[key] if @cache.has_key? key
+
+        xpath = @xpaths[key]
+        @cache[key] = xpath_compile(xpath)
+      end
+
+      def register_xpaths(xpaths)
+        @xpaths.merge! xpaths
+      end
+
+    end
+  end
+end

data/t2-server.gemspec

@@ -5,13 +5,13 @@
 
 Gem::Specification.new do |s|
   s.name = "t2-server"
-  s.version = "0.9.3"
+  s.version = "1.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Robert Haines"]
-  s.date = "2013-05-20"
+  s.authors = ["Robert Haines", "Finn Bacall"]
+  s.date = "2013-11-05"
   s.description = "This gem provides access to the Taverna 2 Server REST interface from Ruby."
-  s.email = ["rhaines@manchester.ac.uk"]
+  s.email = ["support@mygrid.org.uk"]
   s.executables = ["t2-delete-runs", "t2-run-workflow", "t2-server-info", "t2-get-output", "t2-server-admin"]
   s.extra_rdoc_files = [
     "CHANGES.rdoc",
@@ -28,14 +28,17 @@ Gem::Specification.new do |s|
     "bin/t2-run-workflow",
     "bin/t2-server-admin",
     "bin/t2-server-info",
+    "extras/t2-server-stress",
     "lib/t2-server-cli.rb",
     "lib/t2-server.rb",
     "lib/t2-server/admin.rb",
     "lib/t2-server/exceptions.rb",
+    "lib/t2-server/interaction.rb",
     "lib/t2-server/net/connection.rb",
     "lib/t2-server/net/credentials.rb",
     "lib/t2-server/net/parameters.rb",
     "lib/t2-server/port.rb",
+    "lib/t2-server/run-cache.rb",
     "lib/t2-server/run.rb",
     "lib/t2-server/server.rb",
     "lib/t2-server/util.rb",
@@ -43,9 +46,10 @@ Gem::Specification.new do |s|
     "lib/t2-server/xml/nokogiri.rb",
     "lib/t2-server/xml/rexml.rb",
     "lib/t2-server/xml/xml.rb",
-    "lib/t2server.rb",
+    "lib/t2-server/xml/xpath_cache.rb",
     "t2-server.gemspec",
     "test/tc_admin.rb",
+    "test/tc_misc.rb",
     "test/tc_params.rb",
     "test/tc_perms.rb",
     "test/tc_run.rb",
@@ -59,6 +63,7 @@ Gem::Specification.new do |s|
     "test/workflows/in.txt",
     "test/workflows/list_and_value.t2flow",
     "test/workflows/list_with_errors.t2flow",
+    "test/workflows/missing_outputs.t2flow",
     "test/workflows/no-ports.t2flow",
     "test/workflows/pass_through.t2flow",
     "test/workflows/secure/basic-http.t2flow",
@@ -90,8 +95,10 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<nokogiri>, [">= 1.5.0"])
       s.add_development_dependency(%q<rdoc>, [">= 3.9.4"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_development_dependency(%q<launchy>, ["~> 2.2.0"])
       s.add_runtime_dependency(%q<net-http-persistent>, ["~> 2.6"])
       s.add_runtime_dependency(%q<taverna-baclava>, ["~> 1.0.0"])
+      s.add_runtime_dependency(%q<ratom>, ["~> 0.8.2"])
       s.add_runtime_dependency(%q<hirb>, [">= 0.4.0"])
     else
       s.add_dependency(%q<rake>, ["~> 0.9.2"])
@@ -99,8 +106,10 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<nokogiri>, [">= 1.5.0"])
       s.add_dependency(%q<rdoc>, [">= 3.9.4"])
       s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_dependency(%q<launchy>, ["~> 2.2.0"])
       s.add_dependency(%q<net-http-persistent>, ["~> 2.6"])
       s.add_dependency(%q<taverna-baclava>, ["~> 1.0.0"])
+      s.add_dependency(%q<ratom>, ["~> 0.8.2"])
       s.add_dependency(%q<hirb>, [">= 0.4.0"])
     end
   else
@@ -109,8 +118,10 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<nokogiri>, [">= 1.5.0"])
     s.add_dependency(%q<rdoc>, [">= 3.9.4"])
     s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+    s.add_dependency(%q<launchy>, ["~> 2.2.0"])
     s.add_dependency(%q<net-http-persistent>, ["~> 2.6"])
     s.add_dependency(%q<taverna-baclava>, ["~> 1.0.0"])
+    s.add_dependency(%q<ratom>, ["~> 0.8.2"])
     s.add_dependency(%q<hirb>, [">= 0.4.0"])
   end
 end

data/test/tc_misc.rb

@@ -0,0 +1,61 @@
+# Copyright (c) 2013 The University of Manchester, UK.
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#  * Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+#
+#  * Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+#  * Neither the names of The University of Manchester nor the names of its
+#    contributors may be used to endorse or promote products derived from this
+#    software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# Author: Robert Haines
+
+require 't2-server'
+
+class TestMisc < Test::Unit::TestCase
+
+  # Test a run with the missing output data bug to check that the library can
+  # workaround it ok. Bug is: http://dev.mygrid.org.uk/issues/browse/T2-2100
+  def test_missing_ports
+    T2Server::Run.create($uri, $wkf_miss_o, $creds, $conn_params) do |run|
+      assert_nothing_raised { run.start }
+      assert(run.running?)
+      run.wait
+
+      run.output_ports.each do |_, port|
+        # Check that outputs are the correct depth
+        assert_equal(port.depth, 2)
+
+        # Check that output lists are the correct length
+        assert_equal(port.value.length, 3)
+        assert_equal(port[0].length, 10)
+
+        # Check that there are empty lists in the correct places
+        assert_equal(port.value[1], [])
+      end
+
+      assert(run.delete)
+    end
+  end
+
+end

data/test/tc_perms.rb

@@ -34,19 +34,27 @@ require 't2-server'
 
 class TestPermissions < Test::Unit::TestCase
 
-  def test_ownership
+  def test_ownership_and_revokation
     server = T2Server::Server.new($uri, $conn_params)
 
     server.create_run($wkf_pass, $creds) do |run|
       assert(run.owner?)
       assert_equal(run.owner, $creds.username)
 
+      assert_equal(run.permission($creds1.username), :none)
       run.grant_permission($creds1.username, :read)
+      assert_equal(run.permission($creds1.username), :read)
       run_id = run.identifier
       run1 = server.run(run_id, $creds1)
 
       assert(!run1.owner?)
       assert_not_equal(run1.owner, $creds1.username)
+
+      assert(run.revoke_permission($creds1.username))
+      assert_equal(run.permission($creds1.username), :none)
+      assert(run.revoke_permission($creds1.username))
+
+      assert(run.delete)
     end
   end
 
@@ -81,6 +89,10 @@ class TestPermissions < Test::Unit::TestCase
       assert_raise(T2Server::AccessForbiddenError) do
         run1.delete
       end
+
+      assert_nothing_raised(T2Server::AccessForbiddenError) do
+        run.delete
+      end
     end
   end
 
@@ -106,6 +118,10 @@ class TestPermissions < Test::Unit::TestCase
       assert_raise(T2Server::AccessForbiddenError) do
         run1.delete
       end
+
+      assert_nothing_raised(T2Server::AccessForbiddenError) do
+        run.delete
+      end
     end
   end
 

data/test/tc_run.rb

@@ -32,12 +32,38 @@
 
 require 't2-server'
 
+# A class to test data streaming.
+class TestCache
+  attr_reader :data
+
+  def initialize
+    @data = ""
+  end
+
+  def write(data)
+    @data += data
+    data.size
+  end
+
+  def size
+    return @data.size
+  end
+end
+
 class TestRun < Test::Unit::TestCase
 
   # Test run connection
-  def test_run_misc
+  def test_run_create_and_delete
     assert_nothing_raised(T2Server::ConnectionError) do
-      T2Server::Run.create($uri, $wkf_pass, $creds, $conn_params)
+      run = T2Server::Run.create($uri, $wkf_pass, $creds, $conn_params)
+      assert_equal(run.status, :initialized)
+      assert(run.delete)
+      assert(run.deleted?)
+      assert_equal(run.status, :deleted)
+      assert_nothing_raised(T2Server::AttributeNotFoundError) do
+        assert(run.delete) # Should still return true, not raise 404
+      end
+      assert(run.delete) # Should still return true
     end
   end
 
@@ -71,7 +97,23 @@ class TestRun < Test::Unit::TestCase
 
       # get zip file
       assert_nothing_raised(T2Server::T2ServerError) do
-        assert_not_equal(run.zip_output, "")
+        zip_out = run.zip_output
+        assert_not_equal(zip_out, "")
+      end
+
+      # test streaming zip data
+      assert_nothing_raised(T2Server::T2ServerError) do
+        zip_cache = TestCache.new
+        run.zip_output(zip_cache)
+      end
+
+      # show getting a zip file of a singleton port does nothing
+      assert_nothing_raised(T2Server::T2ServerError) do
+        assert_nil(run.output_port("OUT").zip)
+
+        zip_cache = TestCache.new
+        run.output_port("OUT").zip(zip_cache)
+        assert_equal(zip_cache.data, "")
       end
 
       # deletion
@@ -79,14 +121,53 @@ class TestRun < Test::Unit::TestCase
     end
   end
 
-  # Test run with no input or output
+  # Test run naming. This is different for different versions of server.
+  def test_run_naming
+    T2Server::Server.new($uri, $conn_params) do |server|
+      vc = server.version_components
+      v250plus = vc[0] > 2 || (vc[0] == 2 && vc[1] >= 5)
+      server.create_run($wkf_no_io, $creds) do |run|
+        if v250plus
+          # Read initial name.
+          assert(run.name.length > 0)
+          assert_equal("Workflow1", run.name[0...9])
+
+          # Set a new name and test.
+          name = "No input or output"
+          assert(run.name = name)
+          assert(run.name.length == 18)
+          assert_equal(name, run.name)
+
+          # Set a name that is too long
+          long_name = "0123456789012345678901234567890123456789ABCDEFGHIJ"
+          assert(run.name = long_name)
+          assert(run.name.length == 48)
+          assert_equal(long_name[0...48], run.name)
+        else
+          # Read initial name.
+          assert(run.name.length == 0)
+          assert_equal("", run.name)
+
+          # "Set" a new name and test.
+          assert(run.name = "test")
+          assert(run.name.length == 0)
+          assert_equal("", run.name)
+        end
+      end
+    end
+  end
+
+  # Test run with no input or output. Also, pre-load workflow into a String.
   def test_run_no_ports
-    T2Server::Run.create($uri, $wkf_no_io, $creds, $conn_params) do |run|
+    workflow = File.read($wkf_no_io)
+
+    T2Server::Run.create($uri, workflow, $creds, $conn_params) do |run|
       assert_nothing_raised { run.input_ports }
       assert_nothing_raised { run.start }
       assert(run.running?)
       run.wait
       assert_nothing_raised { run.output_ports }
+      assert(run.delete)
     end
   end
 
@@ -105,6 +186,19 @@ class TestRun < Test::Unit::TestCase
 
       assert_equal(run.output_port("MANY").value, many)
       assert_equal(run.output_port("SINGLE").value, single_out)
+
+      # get zip file of a single port and test streaming
+      assert_nothing_raised(T2Server::T2ServerError) do
+        zip_out = run.output_port("MANY").zip
+        assert_not_equal(zip_out, "")
+      end
+
+      assert_nothing_raised(T2Server::T2ServerError) do
+        zip_cache = TestCache.new
+        run.output_port("MANY").zip(zip_cache)
+      end
+
+      assert(run.delete)
     end
   end
 
@@ -122,6 +216,19 @@ class TestRun < Test::Unit::TestCase
 
       assert_equal(run.output_port("list_out").value, list_out)
       assert_equal(run.output_port("singleton_out").value, "Hello, World!")
+
+      # Get the log file
+      assert_nothing_raised(T2Server::T2ServerError) do
+        assert_not_equal(run.log, "")
+      end
+
+      assert_nothing_raised(T2Server::T2ServerError) do
+        log_cache = TestCache.new
+        run.log(log_cache)
+        assert_not_equal(log_cache.size, 0)
+      end
+
+      assert(run.delete)
     end
   end
 
@@ -134,11 +241,14 @@ class TestRun < Test::Unit::TestCase
       run.start
       run.wait
       assert_equal(run.output_port("nodes").value, ["hello", "world"])
+      assert(run.delete)
     end
   end
 
+  # Test run with file input. Also pass workflow as File object.
   def test_run_file_input
-    # run with file input
+    workflow = File.open($wkf_pass, "r")
+
     T2Server::Run.create($uri, $wkf_pass, $creds, $conn_params) do |run|
 
       assert_nothing_raised(T2Server::AttributeNotFoundError) do
@@ -149,7 +259,10 @@ class TestRun < Test::Unit::TestCase
       assert(run.running?)
       assert_nothing_raised(T2Server::RunStateError) { run.wait }
       assert_equal(run.output_port("OUT").value, "Hello, World!")
+      assert(run.delete)
     end
+
+    workflow.close
   end
 
   # Test run that returns list of lists, some empty, using baclava for input
@@ -171,11 +284,14 @@ class TestRun < Test::Unit::TestCase
       assert_nothing_raised(T2Server::RunStateError) { run.wait }
       assert_equal(run.output_ports.keys.sort, ["MANY", "SINGLE"])
       assert_equal(run.output_port("SINGLE").value, [])
+      assert(!run.output_port("SINGLE").empty?)
       assert_equal(run.output_port("MANY").value,
         [[["boo"]], [["", "Hello"]], [], [[], ["test"], []]])
       assert_equal(run.output_port("MANY").total_size, 12)
+      assert(run.output_port("MANY")[1][0][0].empty?)
       assert_equal(run.output_port("MANY")[1][0][1].value(1..3), "ell")
       assert_raise(NoMethodError) { run.output_port("SINGLE")[0].value }
+      assert(run.delete)
     end
   end
 
@@ -192,9 +308,18 @@ class TestRun < Test::Unit::TestCase
       assert(run.running?)
       assert_nothing_raised(T2Server::RunStateError) { run.wait }
 
+      # Test normal and streamed output
       assert_nothing_raised(T2Server::AccessForbiddenError) do
         output = run.baclava_output
+
+        out_stream = ""
+        run.baclava_output do |chunk|
+          out_stream += chunk
+        end
+        assert_equal(output, out_stream)
       end
+
+      assert(run.delete)
     end
   end
 
@@ -209,44 +334,44 @@ class TestRun < Test::Unit::TestCase
       run.start
       run.wait
 
-      # get total data size (without downloading the data)
+      # Get total data size (without downloading the data).
       assert_equal(run.output_port("OUT").total_size, 100)
       assert_equal(run.output_port("OUT").size, 100)
 
-      # no data downloaded yet
-      assert(run.output_port("OUT").value(:debug).nil?)
+      # Stream just the first 10 bytes.
+      stream = ""
+      run.output_port("OUT").value(0...10) do |chunk|
+        stream += chunk
+      end
+      assert_equal(stream, "123456789\n")
 
-      # get just the first 10 bytes
-      assert_equal(run.output_port("OUT").value(0...10),
-        "123456789\n")
+      # Get just the second 10 bytes.
+      assert_equal(run.output_port("OUT").value(10...20),
+        "223456789\n")
 
-      # get a bad range - should return the first 10 bytes
-      assert_equal(run.output_port("OUT").value(-10...10),
-        "123456789\n")
+      # Stream the first 20 bytes.
+      stream = ""
+      run.output_port("OUT").value(0...20) do |chunk|
+        stream += chunk
+      end
+      assert_equal(stream, "123456789\n223456789\n")
 
-      # confirm only the first 10 bytes have been downloaded
-      assert_equal(run.output_port("OUT").value(:debug),
+      # Get a bad range - should return the first 10 bytes.
+      assert_equal(run.output_port("OUT").value(-10...10),
         "123456789\n")
 
-      # ask for a separate 10 byte range
-      assert_equal(run.output_port("OUT").value(20...30),
-        "323456789\n")
-
-      # confirm that enough was downloaded to connect the two ranges
-      assert_equal(run.output_port("OUT").value(:debug),
-        "123456789\n223456789\n323456789\n")
-
-      # ask for a range that we already have
-      assert_equal(run.output_port("OUT").value(5..25),
-        "6789\n223456789\n323456")
-
-      # confirm that no more has actually been downloaded
-      assert_equal(run.output_port("OUT").value(:debug),
-        "123456789\n223456789\n323456789\n")
+      # Stream the lot and check total length. There should be two chunks.
+      stream = ""
+      run.output_port("OUT").value do |chunk|
+        stream += chunk
+      end
+      assert_equal(stream.length, 100)
 
-      # now get the lot and check its size
+      # Now get the lot and check its size.
       out = run.output_port("OUT").value
       assert_equal(out.length, 100)
+
+      assert(run.delete)
     end
   end
 
@@ -255,16 +380,21 @@ class TestRun < Test::Unit::TestCase
     T2Server::Run.create($uri, $wkf_fail, $creds, $conn_params) do |run|
       run.start
       run.wait
-      assert(run.output_port("OUT").value.nil?)
+      assert_not_nil(run.output_port("OUT").value)
       assert(run.output_port("OUT").error?)
+      assert(run.delete)
     end
   end
 
   def test_errors
     T2Server::Run.create($uri, $wkf_errors, $creds, $conn_params) do |run|
       run.start
+      assert(!run.error?)
       run.wait
+      assert_not_nil(run.output_port("OUT").value)
       assert(run.output_port("OUT").error?)
+      assert(run.error?)
+      assert(run.delete)
     end
   end
 end