actionwebservice 0.5.0 → 0.6.0

data/test/abstract_unit.rb

@@ -1,4 +1,5 @@
 $:.unshift(File.dirname(__FILE__) + '/../lib')
+$:.unshift(File.dirname(__FILE__) + '/../lib/action_web_service/vendor')
 
 require 'test/unit'
 require 'action_web_service'

data/test/api_test.rb

@@ -41,7 +41,7 @@ class TC_API < Test::Unit::TestCase
     assert_equal({:expects=>nil, :returns=>[Integer, [String]]}, API.api_methods[:returns])
     assert_equal({:expects=>[{:appkey=>Integer}, {:publish=>TrueClass}], :returns=>nil}, API.api_methods[:named_signature])
     assert_equal({:expects=>[Integer, String, TrueClass], :returns=>nil}, API.api_methods[:string_types])
-    assert_equal({:expects=>[TrueClass, Bignum, String], :returns=>nil}, API.api_methods[:class_types])
+    assert_equal({:expects=>[TrueClass, Integer, String], :returns=>nil}, API.api_methods[:class_types])
   end
 
   def test_not_instantiable
@@ -49,4 +49,21 @@ class TC_API < Test::Unit::TestCase
       API.new
     end
   end
+
+  def test_api_errors
+    assert_raises(ActionWebService::ActionWebServiceError) do
+      klass = Class.new(ActionWebService::API::Base) do
+        api_method :test, :expects => [ActiveRecord::Base]
+      end
+    end
+    klass = Class.new(ActionWebService::API::Base) do
+      allow_active_record_expects true
+      api_method :test2, :expects => [ActiveRecord::Base]
+    end
+    assert_raises(ActionWebService::ActionWebServiceError) do
+      klass = Class.new(ActionWebService::API::Base) do
+        api_method :test, :invalid => [:int]
+      end
+    end
+  end
 end

data/test/apis/auto_load_api.rb

@@ -0,0 +1,3 @@
+class AutoLoadAPI < ActionWebService::API::Base
+  api_method :void
+end

data/test/apis/broken_auto_load_api.rb

@@ -0,0 +1,2 @@
+
+

data/test/client_soap_test.rb

@@ -12,10 +12,10 @@ module ClientSoapTest
       test_request.env['HTTP_CONTENTTYPE'] = 'text/xml'
       test_request.env['HTTP_SOAPACTION'] = req.header['soapaction'][0]
       test_request.env['RAW_POST_DATA'] = req.body
-      protocol_request = @controller.protocol_request(test_request)
-      response = @controller.dispatch_request(protocol_request)
+      response = ActionController::TestResponse.new
+      @controller.process(test_request, response)
       res.header['content-type'] = 'text/xml'
-      res.body = response.raw_body
+      res.body = response.body
     rescue Exception => e
       $stderr.puts e.message
       $stderr.puts e.backtrace.join("\n")
@@ -24,10 +24,15 @@ module ClientSoapTest
 
   class ClientContainer < ActionController::Base
     web_client_api :client, :soap, "http://localhost:#{PORT}/client/api", :api => ClientTest::API
+    web_client_api :invalid, :null, "", :api => true
 
     def get_client
       client
     end
+
+    def get_invalid
+      invalid
+    end
   end
 
   class SoapServer < ClientTest::AbstractServer
@@ -83,6 +88,7 @@ class TC_ClientSoap < Test::Unit::TestCase
 
   def test_client_container
     assert_equal(50, ClientContainer.new.get_client.client_container)
+    assert(ClientContainer.new.get_invalid.nil?)
   end
 
   def test_named_parameters
@@ -90,4 +96,11 @@ class TC_ClientSoap < Test::Unit::TestCase
     assert(@client.named_parameters("key", 5).nil?)
     assert_equal(["key", 5], @container.value_named_parameters)
   end
+
+  def test_capitalized_method_name
+    @container.value_normal = nil
+    assert_equal(5, @client.Normal(5, 6))
+    assert_equal([5, 6], @container.value_normal)
+    @container.value_normal = nil
+  end
 end

data/test/client_xmlrpc_test.rb

@@ -9,12 +9,12 @@ module ClientXmlRpcTest
       test_request = ActionController::TestRequest.new
       test_request.request_parameters['action'] = req.path.gsub(/^\//, '').split(/\//)[1]
       test_request.env['REQUEST_METHOD'] = "POST"
-      test_request.env['HTTP_CONTENTTYPE'] = 'text/xml'
+      test_request.env['HTTP_CONTENT_TYPE'] = 'text/xml'
       test_request.env['RAW_POST_DATA'] = req.body
-      protocol_request = @controller.protocol_request(test_request)
-      response = @controller.dispatch_request(protocol_request)
+      response = ActionController::TestResponse.new
+      @controller.process(test_request, response)
       res.header['content-type'] = 'text/xml'
-      res.body = response.raw_body
+      res.body = response.body
     rescue Exception => e
       $stderr.puts e.message
       $stderr.puts e.backtrace.join("\n")
@@ -89,4 +89,16 @@ class TC_ClientXmlRpc < Test::Unit::TestCase
     assert_equal(true, @client.named_parameters("xxx", 7))
     assert_equal(["xxx", 7], @container.value_named_parameters)
   end
+
+  def test_exception
+    assert_raises(ActionWebService::Client::ClientError) do
+      assert(@client.thrower)
+    end
+  end
+
+  def test_invalid_signature
+    assert_raises(ActionWebService::Client::ClientError) do
+      @client.normal
+    end
+  end
 end

data/test/container_test.rb

@@ -1,7 +1,6 @@
 require File.dirname(__FILE__) + '/abstract_unit'
 
 module ContainerTest
- 
   $immediate_service = Object.new
   $deferred_service = Object.new
   
@@ -22,22 +21,34 @@ module ContainerTest
   
   class DirectContainer < ActionController::Base
     web_service_dispatching_mode :direct
-   end
+  end
+
+  class InvalidContainer
+    include ActionWebService::Container::Direct
+  end
 end
 
 class TC_Container < Test::Unit::TestCase
+  include ContainerTest
+
   def setup
-    @delegate_container = ContainerTest::DelegateContainer.new
-    @direct_container = ContainerTest::DirectContainer.new
+    @delegate_container = DelegateContainer.new
+    @direct_container = DirectContainer.new
   end
 
   def test_registration
-    assert(ContainerTest::DelegateContainer.has_web_service?(:immediate_service))
-    assert(ContainerTest::DelegateContainer.has_web_service?(:deferred_service))
-    assert(!ContainerTest::DelegateContainer.has_web_service?(:fake_service))
+    assert(DelegateContainer.has_web_service?(:immediate_service))
+    assert(DelegateContainer.has_web_service?(:deferred_service))
+    assert(!DelegateContainer.has_web_service?(:fake_service))
+    assert_raises(ActionWebService::Container::Delegated::ContainerError) do
+      DelegateContainer.web_service('invalid')
+    end
   end
 
   def test_service_object
+    assert_raises(ActionWebService::Container::Delegated::ContainerError) do
+      @delegate_container.web_service_object(:nonexistent)
+    end
     assert(@delegate_container.flag == true)
     assert(@delegate_container.web_service_object(:immediate_service) == $immediate_service)
     assert(@delegate_container.previous_flag.nil?)
@@ -48,6 +59,15 @@ class TC_Container < Test::Unit::TestCase
   end
 
   def test_direct_container
-    assert(ContainerTest::DirectContainer.web_service_dispatching_mode == :direct)
+    assert(DirectContainer.web_service_dispatching_mode == :direct)
+  end
+
+  def test_validity
+    assert_raises(ActionWebService::Container::Direct::ContainerError) do 
+      InvalidContainer.web_service_api :test
+    end
+    assert_raises(ActionWebService::Container::Direct::ContainerError) do 
+      InvalidContainer.web_service_api 50.0
+    end
   end
 end

data/test/dispatcher_action_controller_soap_test.rb

@@ -0,0 +1,106 @@
+$:.unshift(File.dirname(__FILE__) + '/apis')
+require File.dirname(__FILE__) + '/abstract_dispatcher'
+require 'wsdl/parser'
+
+class AutoLoadController < ActionController::Base; end
+class FailingAutoLoadController < ActionController::Base; end
+class BrokenAutoLoadController < ActionController::Base; end
+
+class TC_DispatcherActionControllerSoap < Test::Unit::TestCase
+  include DispatcherTest
+  include DispatcherCommonTests
+
+  def setup
+    @encoder = WS::Encoding::SoapRpcEncoding.new 'urn:ActionWebService'
+    @marshaler = WS::Marshaling::SoapMarshaler.new 'urn:ActionWebService'
+    @direct_controller = DirectController.new
+    @delegated_controller = DelegatedController.new
+    @virtual_controller = VirtualController.new
+  end
+
+  def test_wsdl_generation
+    ensure_valid_wsdl_generation DelegatedController.new
+    ensure_valid_wsdl_generation DirectController.new
+  end
+
+  def test_wsdl_action
+    delegated_types = ensure_valid_wsdl_action DelegatedController.new
+    delegated_names = delegated_types.map{|x| x.name.name}
+    assert(delegated_names.include?('DispatcherTest..NodeArray'))
+    assert(delegated_names.include?('DispatcherTest..Node'))
+    direct_types = ensure_valid_wsdl_action DirectController.new
+    direct_names = direct_types.map{|x| x.name.name}
+    assert(direct_names.include?('DispatcherTest..NodeArray'))
+    assert(direct_names.include?('DispatcherTest..Node'))
+    assert(direct_names.include?('IntegerArray'))
+  end
+
+  def test_autoloading
+    assert(!AutoLoadController.web_service_api.nil?)
+    assert(AutoLoadController.web_service_api.has_public_api_method?('Void'))
+    assert(FailingAutoLoadController.web_service_api.nil?)
+    assert_raises(LoadError, NameError) do
+      FailingAutoLoadController.require_web_service_api :blah
+    end
+    assert_raises(ArgumentError) do
+      FailingAutoLoadController.require_web_service_api 50.0
+    end
+    assert(BrokenAutoLoadController.web_service_api.nil?)
+  end
+
+  protected
+    def exception_message(soap_fault_exception)
+      soap_fault_exception.detail.cause.message
+    end
+
+    def is_exception?(obj)
+      obj.respond_to?(:detail) && obj.detail.respond_to?(:cause) && \
+      obj.detail.cause.is_a?(Exception)
+    end
+
+    def create_ap_request(container, body, public_method_name, *args)
+      test_request = ActionController::TestRequest.new
+      test_request.request_parameters['action'] = service_name(container)
+      test_request.env['REQUEST_METHOD'] = "POST"
+      test_request.env['HTTP_CONTENT_TYPE'] = 'text/xml'
+      test_request.env['HTTP_SOAPACTION'] = "/soap/#{service_name(container)}/#{public_method_name}"
+      test_request.env['RAW_POST_DATA'] = body
+      test_request
+    end
+
+    def service_name(container)
+      container.is_a?(DelegatedController) ? 'test_service' : 'api'
+    end
+
+    def ensure_valid_wsdl_generation(controller)
+      wsdl = controller.generate_wsdl
+      ensure_valid_wsdl(wsdl)
+    end
+
+    def ensure_valid_wsdl(wsdl)
+      definitions = WSDL::Parser.new.parse(wsdl)
+      assert(definitions.is_a?(WSDL::Definitions))
+      definitions.bindings.each do |binding|
+        assert(binding.name.name.index(':').nil?)
+      end
+      definitions.services.each do |service|
+        service.ports.each do |port|
+          assert(port.name.name.index(':').nil?)
+        end
+      end
+      types = definitions.collect_complextypes.map{|x| x.name}
+      types.each do |type|
+        assert(type.namespace == 'urn:ActionWebService')
+      end
+      definitions.collect_complextypes
+    end
+
+    def ensure_valid_wsdl_action(controller)
+      test_request = ActionController::TestRequest.new({ 'action' => 'wsdl' })
+      test_request.env['REQUEST_METHOD'] = 'GET'
+      test_request.env['HTTP_HOST'] = 'localhost:3000'
+      test_response = ActionController::TestResponse.new
+      wsdl = controller.process(test_request, test_response).body
+      ensure_valid_wsdl(wsdl)
+    end
+end

data/test/dispatcher_action_controller_xmlrpc_test.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/abstract_dispatcher'
+
+class TC_DispatcherActionControllerXmlRpc < Test::Unit::TestCase
+  include DispatcherTest
+  include DispatcherCommonTests
+
+  def setup
+    @encoder = WS::Encoding::XmlRpcEncoding.new
+    @marshaler = WS::Marshaling::XmlRpcMarshaler.new
+    @direct_controller = DirectController.new
+    @delegated_controller = DelegatedController.new
+    @layered_controller = LayeredController.new
+    @virtual_controller = VirtualController.new
+  end
+
+  def test_layered_dispatching
+    mt_cats = do_method_call(@layered_controller, 'mt.getCategories')
+    assert_equal(["mtCat1", "mtCat2"], mt_cats)
+    blogger_cats = do_method_call(@layered_controller, 'blogger.getCategories')
+    assert_equal(["bloggerCat1", "bloggerCat2"], blogger_cats)
+  end
+
+  protected
+    def exception_message(xmlrpc_fault_exception)
+      xmlrpc_fault_exception.faultString
+    end
+
+    def is_exception?(obj)
+      obj.is_a?(XMLRPC::FaultException)
+    end
+
+    def create_ap_request(container, body, public_method_name, *args)
+      test_request = ActionController::TestRequest.new
+      test_request.request_parameters['action'] = service_name(container)
+      test_request.env['REQUEST_METHOD'] = "POST"
+      test_request.env['HTTP_CONTENT_TYPE'] = 'text/xml'
+      test_request.env['RAW_POST_DATA'] = body
+      test_request
+    end
+
+    def service_name(container)
+      container.is_a?(DelegatedController) ? 'test_service' : 'api'
+    end
+end

data/test/gencov

@@ -1,3 +1,3 @@
 #!/bin/sh
 
-rcov -x '.*_test\.rb,rubygems,abstract_,/run' ./run
+rcov -x '.*_test\.rb,rubygems,abstract_,/run,/apis' ./run

data/test/invocation_test.rb

@@ -12,23 +12,46 @@ module InvocationTest
     api_method :only_two
   end
 
+  class Interceptor
+    attr :args
+
+    def initialize
+      @args = nil
+    end
+
+    def intercept(*args)
+      @args = args
+    end
+  end
+
+  InterceptorClass = Interceptor.new 
+
   class Service < ActionWebService::Base
     web_service_api API
 
     before_invocation :intercept_before, :except => [:no_before]
     after_invocation :intercept_after, :except => [:no_after]
-    before_invocation :intercept_only, :only => [:only_one, :only_two]
+    prepend_after_invocation :intercept_after_first, :except => [:no_after]
+    prepend_before_invocation :intercept_only, :only => [:only_one, :only_two]
+    after_invocation(:only => [:only_one]) do |*args| 
+      args[0].instance_variable_set('@block_invoked', args[1])
+    end
+    after_invocation InterceptorClass, :only => [:only_one]
 
     attr_accessor :before_invoked
     attr_accessor :after_invoked
+    attr_accessor :after_first_invoked
     attr_accessor :only_invoked
+    attr_accessor :block_invoked
     attr_accessor :invocation_result
   
     def initialize
       @before_invoked = nil
       @after_invoked = nil
+      @after_first_invoked = nil
       @only_invoked = nil
       @invocation_result = nil
+      @block_invoked = nil
     end
   
     def add(a, b)
@@ -69,6 +92,10 @@ module InvocationTest
         @after_invoked = name
         @invocation_result = result
       end
+
+      def intercept_after_first(name, args, result)
+        @after_first_invoked = name
+      end
   
       def intercept_only(name, args)
         raise "Interception error" unless name == :only_one || name == :only_two
@@ -94,11 +121,17 @@ class TC_Invocation < Test::Unit::TestCase
 
   def test_interceptor_registration
     assert(InvocationTest::Service.before_invocation_interceptors.length == 2)
-    assert(InvocationTest::Service.after_invocation_interceptors.length == 1)
+    assert(InvocationTest::Service.after_invocation_interceptors.length == 4)
+    assert_equal(:intercept_only, InvocationTest::Service.before_invocation_interceptors[0])
+    assert_equal(:intercept_after_first, InvocationTest::Service.after_invocation_interceptors[0])
   end
 
   def test_interception
-    assert(@service.before_invoked.nil? && @service.after_invoked.nil? && @service.only_invoked.nil? && @service.invocation_result.nil?)
+    assert(@service.before_invoked.nil?)
+    assert(@service.after_invoked.nil?)
+    assert(@service.only_invoked.nil?)
+    assert(@service.block_invoked.nil?)
+    assert(@service.invocation_result.nil?)
     perform_invocation(:add, 20, 50)
     assert(@service.before_invoked == :add)
     assert(@service.after_invoked == :add)
@@ -124,6 +157,7 @@ class TC_Invocation < Test::Unit::TestCase
   def test_interception_except_conditions
     perform_invocation(:no_before)
     assert(@service.before_invoked.nil?)
+    assert(@service.after_first_invoked == :no_before)
     assert(@service.after_invoked == :no_before)
     assert(@service.invocation_result == 5)
     @service.before_invoked = @service.after_invoked = @service.invocation_result = nil
@@ -137,6 +171,8 @@ class TC_Invocation < Test::Unit::TestCase
     assert(@service.only_invoked.nil?)
     perform_invocation(:only_one)
     assert(@service.only_invoked == :only_one)
+    assert(@service.block_invoked == :only_one)
+    assert(InvocationTest::InterceptorClass.args[1] == :only_one)
     @service.only_invoked = nil
     perform_invocation(:only_two)
     assert(@service.only_invoked == :only_two)

data/test/run

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
-
-Dir[File.join(File.dirname(__FILE__), '*_test.rb')].each do |f|
-  require f
-end
+require 'test/unit'
+args = Dir[File.join(File.dirname(__FILE__), '*_test.rb')] + Dir[File.join(File.dirname(__FILE__), 'ws/*_test.rb')]
+(r = Test::Unit::AutoRunner.new(true)).process_args(args)
+exit r.run