t2-server 1.1.0 → 1.2.0

data/test/{tc_secure.rb → tc_secure_live.rb}

@@ -40,7 +40,6 @@ class TestSecurity < Test::Unit::TestCase
   # User name and password for the test secure server.
   USERNAME = "testuser"
   PASSWORD = "testpasswd"
-  CERTPASS = "testcert"
 
   # Various URIs required.
   HEATER_HTTP  = "http://heater.cs.man.ac.uk:7070/"
@@ -52,34 +51,36 @@ class TestSecurity < Test::Unit::TestCase
   WS4          = "axis/services/HelloService-DigestPassword-Timestamp?wsdl"
 
   # Workflows
-  $wkf_basic_http   = File.read("test/workflows/secure/basic-http.t2flow")
-  $wkf_digest_http  = File.read("test/workflows/secure/digest-http.t2flow")
-  $wkf_ws_http      = File.read("test/workflows/secure/ws-http.t2flow")
-  $wkf_basic_https  = File.read("test/workflows/secure/basic-https.t2flow")
-  $wkf_digest_https = File.read("test/workflows/secure/digest-https.t2flow")
-  $wkf_ws_https     = File.read("test/workflows/secure/ws-https.t2flow")
-  $wkf_client_https = File.read("test/workflows/secure/client-https.t2flow")
+  WKF_BASIC_HTTP   = File.read("test/workflows/secure/basic-http.t2flow")
+  WKF_DIGEST_HTTP  = File.read("test/workflows/secure/digest-http.t2flow")
+  WKF_WS_HTTP      = File.read("test/workflows/secure/ws-http.t2flow")
+  WKF_BASIC_HTTPS  = File.read("test/workflows/secure/basic-https.t2flow")
+  WKF_DIGEST_HTTPS = File.read("test/workflows/secure/digest-https.t2flow")
+  WKF_WS_HTTPS     = File.read("test/workflows/secure/ws-https.t2flow")
+  WKF_CLIENT_HTTPS = File.read("test/workflows/secure/client-https.t2flow")
 
   # Server public key for HTTPS peer verification.
-  $heater_pk = "test/workflows/secure/heater-pk.pem"
+  HEATER_PK = "test/workflows/secure/heater-pk.pem"
 
   # Client private key for HTTPS authentication
-  $user_pk = "test/workflows/secure/user-cert.p12"
+  USER_PK = "test/workflows/secure/user-cert.p12"
+  CERTNAME = "{492EB700-ADBA-44B9-A263-D7DF9F2E0F2B}"
+  CERTPASS = "testcert"
 
   # HTTP Basic authentication
   def test_basic_creds_http
-    T2Server::Run.create($uri, $wkf_basic_http, $creds, $conn_params) do |run|
+    T2Server::Run.create($uri, WKF_BASIC_HTTP, $creds, $conn_params) do |run|
       run.add_password_credential(HEATER_HTTP, USERNAME, PASSWORD)
       run.start
       assert(run.running?)
       assert_nothing_raised(T2Server::RunStateError) { run.wait }
       assert(run.finished?)
-      assert_not_nil(run.output_port("out").value)
+      refute(run.output_port("out").error?)
       assert(run.delete)
     end
 
     # now test with no credential
-    T2Server::Run.create($uri, $wkf_basic_http, $creds, $conn_params) do |run|
+    T2Server::Run.create($uri, WKF_BASIC_HTTP, $creds, $conn_params) do |run|
       run.start
       assert(run.running?)
       assert_nothing_raised(T2Server::RunStateError) { run.wait }
@@ -91,19 +92,19 @@ class TestSecurity < Test::Unit::TestCase
 
   # HTTPS Basic authentication
   def test_basic_creds_https
-    T2Server::Run.create($uri, $wkf_basic_https, $creds, $conn_params) do |run|
+    T2Server::Run.create($uri, WKF_BASIC_HTTPS, $creds, $conn_params) do |run|
       run.add_password_credential(HEATER_HTTPS, USERNAME, PASSWORD)
-      run.add_trust($heater_pk)
+      run.add_trust(HEATER_PK)
       run.start
       assert(run.running?)
       assert_nothing_raised(T2Server::RunStateError) { run.wait }
       assert(run.finished?)
-      assert_not_nil(run.output_port("out").value)
+      refute(run.output_port("out").error?)
       assert(run.delete)
     end
 
     # now test with no server public key
-    T2Server::Run.create($uri, $wkf_basic_https, $creds, $conn_params) do |run|
+    T2Server::Run.create($uri, WKF_BASIC_HTTPS, $creds, $conn_params) do |run|
       run.add_password_credential(HEATER_HTTPS, USERNAME, PASSWORD)
       run.start
       assert(run.running?)
@@ -116,34 +117,34 @@ class TestSecurity < Test::Unit::TestCase
 
   # HTTP Digest authentication
   def test_digest_creds_http
-    T2Server::Run.create($uri, $wkf_digest_http, $creds, $conn_params) do |run|
+    T2Server::Run.create($uri, WKF_DIGEST_HTTP, $creds, $conn_params) do |run|
       run.add_password_credential(HEATER_HTTP, USERNAME, PASSWORD)
       run.start
       assert(run.running?)
       assert_nothing_raised(T2Server::RunStateError) { run.wait }
       assert(run.finished?)
-      assert_not_nil(run.output_port("out").value)
+      refute(run.output_port("out").error?)
       assert(run.delete)
     end
   end
 
   # HTTPS Digest authentication
   def test_digest_creds_https
-    T2Server::Run.create($uri, $wkf_digest_https, $creds, $conn_params) do |run|
+    T2Server::Run.create($uri, WKF_DIGEST_HTTPS, $creds, $conn_params) do |run|
       run.add_password_credential(HEATER_HTTPS, USERNAME, PASSWORD)
-      run.add_trust($heater_pk)
+      run.add_trust(HEATER_PK)
       run.start
       assert(run.running?)
       assert_nothing_raised(T2Server::RunStateError) { run.wait }
       assert(run.finished?)
-      assert_not_nil(run.output_port("out").value)
+      refute(run.output_port("out").error?)
       assert(run.delete)
     end
   end
 
   # HTTP WS-Security authentication
   def test_ws_creds_http
-    T2Server::Run.create($uri, $wkf_ws_http, $creds, $conn_params) do |run|
+    T2Server::Run.create($uri, WKF_WS_HTTP, $creds, $conn_params) do |run|
       run.add_password_credential(HEATER_HTTP + WS1, USERNAME, PASSWORD)
       run.add_password_credential(HEATER_HTTP + WS2, USERNAME, PASSWORD)
       run.add_password_credential(HEATER_HTTP + WS3, USERNAME, PASSWORD)
@@ -164,12 +165,12 @@ class TestSecurity < Test::Unit::TestCase
 
   # HTTPS WS-Security authentication
   def test_ws_creds_https
-    T2Server::Run.create($uri, $wkf_ws_https, $creds, $conn_params) do |run|
+    T2Server::Run.create($uri, WKF_WS_HTTPS, $creds, $conn_params) do |run|
       run.add_password_credential(HEATER_HTTPS + WS1, USERNAME, PASSWORD)
       run.add_password_credential(HEATER_HTTPS + WS2, USERNAME, PASSWORD)
       run.add_password_credential(HEATER_HTTPS + WS3, USERNAME, PASSWORD)
       run.add_password_credential(HEATER_HTTPS + WS4, USERNAME, PASSWORD)
-      run.add_trust($heater_pk)
+      run.add_trust(HEATER_PK)
       run.start
       assert(run.running?)
       assert_nothing_raised(T2Server::RunStateError) { run.wait }
@@ -186,14 +187,14 @@ class TestSecurity < Test::Unit::TestCase
 
   # HTTPS client certificate authentication
   def test_client_cert_auth_https
-    T2Server::Run.create($uri, $wkf_client_https, $creds, $conn_params) do |run|
-      run.add_keypair_credential(HEATER_CAUTH, $user_pk, CERTPASS)
-      run.add_trust($heater_pk)
+    T2Server::Run.create($uri, WKF_CLIENT_HTTPS, $creds, $conn_params) do |run|
+      run.add_keypair_credential(HEATER_CAUTH, USER_PK, CERTPASS, CERTNAME)
+      run.add_trust(HEATER_PK)
       run.start
       assert(run.running?)
       assert_nothing_raised(T2Server::RunStateError) { run.wait }
       assert(run.finished?)
-      assert_not_nil(run.output_port("out").value)
+      refute(run.output_port("out").error?)
       assert(run.delete)
     end
   end

data/test/tc_server.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2010-2013 The University of Manchester, UK.
+# Copyright (c) 2014 The University of Manchester, UK.
 #
 # All rights reserved.
 #
@@ -30,61 +30,134 @@
 #
 # Author: Robert Haines
 
+require 'mocked-server-responses/mocks'
 require 't2-server'
 
 class TestServer < Test::Unit::TestCase
+  include T2Server::Mocks
 
-  def test_server_connection
-    assert_nothing_raised(T2Server::ConnectionError) do
-      T2Server::Server.new($uri, $conn_params)
-    end
+  WKF_PASS = "test/workflows/pass_through.t2flow"
+
+  # Server version is baked into the recorded server responses.
+  SERVER_VERSION = "2.5.4"
+
+  # Need to lock down the run UUID so recorded server responses make sense.
+  RUN_UUID = "a341b87f-25cc-4dfd-be36-f5b073a6ba74"
+
+  def setup
+    @server = T2Server::Server.new($uri, $conn_params)
+
+    # Register common mocks.
+    @mock_rest = mock("/rest/", :accept => "application/xml",
+      :output => "get-rest.raw")
+    @mock_policy = mock("/rest/policy", :accept => "application/xml",
+      :output => "get-rest-policy.raw")
+    mock("/rest/runs", :method => :post, :credentials => $userinfo,
+      :status => 201,
+      :location => "https://localhost/taverna/rest/runs/#{RUN_UUID}")
+  end
+
+  # A simple check that the server version is correctly parsed out of the xml.
+  def test_server_version
+    assert_equal SERVER_VERSION, @server.version.to_s
+
+    assert_requested @mock_rest, :times => 1
+    assert_not_requested @mock_policy
   end
 
-  def test_server_connection_no_params
-    assert_nothing_raised(T2Server::ConnectionError) do
-      T2Server::Server.new($uri)
+  def test_redirect
+    # Re-mock getting the rest endpoint so that it redirects.
+    mock("/rest/", :accept => "application/xml", :status => 302,
+      :location => "http://localhost/taverna/rest/")
+
+    # And now a webmock error should be triggered.
+    assert_raise(WebMock::NetConnectNotAllowedError) do
+      @server.run_limit($creds)
     end
   end
 
   def test_run_creation
-    T2Server::Server.new($uri, $conn_params) do |server|
-      assert_nothing_raised(T2Server::T2ServerError) do
-        run = server.create_run($wkf_pass, $creds)
-        run.delete
-      end
+    assert_nothing_raised(T2Server::T2ServerError) do
+      run = @server.create_run(WKF_PASS, $creds)
+
+      # Mock the deletion of this specific run.
+      mock("/rest/runs/#{run.id}", :method => :delete,
+        :credentials => $userinfo, :status => 204)
+
+      run.delete
     end
+
+    # Make sure we don't keep fetching this information.
+    assert_requested @mock_rest, :times => 1
+    assert_requested @mock_policy, :times => 1
   end
 
-  # Need to do these together so testing the limit is cleaned up!
   def test_server_limits_delete_all
-    T2Server::Server.new($uri, $conn_params) do |server|
-      limit = server.run_limit($creds)
-      max_runs = 0
-      assert_instance_of(Fixnum, limit)
-      assert_raise(T2Server::ServerAtCapacityError) do
-        # Detect the concurrent run limit and
-        # add 1 just in case there are no runs at this point
-        more = true
-        (limit + 1).times do
-          run = server.create_run($wkf_pass, $creds)
-          if more
-            run.input_port("IN").value = "Hello"
-            more = run.start
-            if more
-              max_runs += 1
-              assert(run.running?)
-            else
-              assert(run.initialized?)
-            end
-          end
-        end
-      end
-
-      assert(max_runs <= limit)
-
-      assert_nothing_raised(T2Server::T2ServerError) do
-        server.delete_all_runs($creds)
-      end
+    # Mock specific routes for these tests.
+    mock_limit = mock("/rest/policy/runLimit", :accept => "text/plain",
+      :credentials => $userinfo, :output => "get-rest-policy-runlimit.raw")
+
+    limit = @server.run_limit($creds)
+    assert_instance_of(Fixnum, limit)
+
+    # Mock creation of a run to work once then fail due to server capacity.
+    mock("/rest/runs", :method => :post, :credentials => $userinfo,
+      :status => [201, 503],
+      :location => "https://localhost/taverna/rest/runs/#{RUN_UUID}")
+
+
+
+    run = nil
+    assert_nothing_raised(T2Server::ServerAtCapacityError) do
+      run = @server.create_run(WKF_PASS, $creds)
+    end
+    assert_raise(T2Server::ServerAtCapacityError) do
+      @server.create_run(WKF_PASS, $creds)
+    end
+
+    assert_equal RUN_UUID, run.id
+
+    mock("/rest/runs", :accept => "application/xml",
+      :credentials => $userinfo, :output => "get-rest-runs.raw")
+
+    assert_equal 1, @server.runs($creds).length
+
+    # Mock for this specific run.
+    run_uri = "/rest/runs/#{run.id}"
+    mock_run = mock(run_uri, :accept => "application/xml",
+      :credentials => $userinfo, :output => "get-rest-run.raw")
+    mock("#{run_uri}/security", :accept => "application/xml",
+      :credentials => $userinfo, :output => "get-rest-run-security.raw")
+    mock_input = mock("#{run_uri}/input", :accept => "application/xml",
+      :credentials => $userinfo, :output => "get-rest-run-input.raw")
+    mock_status = mock("#{run_uri}/status", :accept => "text/plain",
+      :credentials => $userinfo, :body => "Initialized")
+    mock_input_exp = mock("#{run_uri}/input/expected",
+      :accept => "application/xml", :credentials => $userinfo,
+      :output => "get-rest-run-input-expected.raw")
+
+    # Mock starting a run to fail due to concurrent running limit.
+    mock_run_start = mock("#{run_uri}/status", :method => :put,
+      :status => 503, :credentials => $userinfo, :body => "Operating")
+
+    # Running limit reached: Run#start should return false and run should stay
+    # in the initialized state.
+    refute run.start
+    assert_equal :initialized, run.status
+
+    # Delete all runs but just need to mock deletion of the one run.
+    mock(run_uri, :method => :delete, :credentials => $userinfo,
+      :status => 204)
+
+    assert_nothing_raised(T2Server::T2ServerError) do
+      @server.delete_all_runs($creds)
     end
+
+    # Make sure we don't keep fetching this information.
+    assert_requested @mock_rest, :times => 1
+    assert_requested @mock_policy, :times => 1
+    assert_requested mock_limit, :times => 1
+    assert_requested mock_run, :times => 1
   end
+
 end

data/test/tc_server_live.rb

@@ -0,0 +1,92 @@
+# Copyright (c) 2010-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 TestServer < Test::Unit::TestCase
+
+  WKF_PASS = "test/workflows/pass_through.t2flow"
+
+  def test_server_connection
+    assert_nothing_raised(T2Server::ConnectionError) do
+      T2Server::Server.new($uri, $conn_params)
+    end
+  end
+
+  def test_server_connection_no_params
+    assert_nothing_raised(T2Server::ConnectionError) do
+      T2Server::Server.new($uri)
+    end
+  end
+
+  def test_run_creation
+    T2Server::Server.new($uri, $conn_params) do |server|
+      assert_nothing_raised(T2Server::T2ServerError) do
+        run = server.create_run(WKF_PASS, $creds)
+        run.delete
+      end
+    end
+  end
+
+  # Need to do these together so testing the limit is cleaned up!
+  def test_server_limits_delete_all
+    T2Server::Server.new($uri, $conn_params) do |server|
+      limit = server.run_limit($creds)
+      max_runs = 0
+      assert_instance_of(Fixnum, limit)
+      assert_raise(T2Server::ServerAtCapacityError) do
+        # Detect the concurrent run limit and
+        # add 1 just in case there are no runs at this point
+        more = true
+        (limit + 1).times do
+          run = server.create_run(WKF_PASS, $creds)
+          if more
+            run.input_port("IN").value = "Hello"
+            more = run.start
+            if more
+              max_runs += 1
+              assert(run.running?)
+            else
+              assert(run.initialized?)
+            end
+          end
+        end
+      end
+
+      assert(max_runs <= limit)
+
+      assert_nothing_raised(T2Server::T2ServerError) do
+        server.delete_all_runs($creds)
+      end
+    end
+  end
+end

data/test/tc_server_version.rb

@@ -68,6 +68,25 @@ class TestServerVersion < Test::Unit::TestCase
     assert @v240 < @v241
     assert @v251 > @v241
     assert @v251 > @v250
+    assert @v24 <= @v240
+    assert @v240 <= @v241
+    assert @v250 >= @v241
+    assert @v250 >= @v250
+    assert @v250 != @v240
+  end
+
+  def test_version_comparison_strings
+    assert @v24 == "2.4.0"
+    assert @v240 == "2.4"
+    assert @v240 < "2.4.1"
+    assert @v250 < "2.5.1"
+    assert @v250 > "2.4.10"
+    assert @v251 > "2.5"
+    assert @v240 <= "2.4"
+    assert @v240 <= "2.4.1"
+    assert @v250 >= "2.4.1"
+    assert @v251 >= "2.5"
+    assert @v251 != "2.5"
   end
 
   def test_version_components