actionservice 0.2.99 → 0.2.100

data/CHANGELOG

@@ -1,3 +1,3 @@
-*0.2*
+TBA
 
-* First release
+  * First public release

data/Rakefile

@@ -8,7 +8,7 @@ require 'rake/contrib/rubyforgepublisher'
 
 PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
 PKG_NAME      = 'actionservice'
-PKG_VERSION   = '0.2.99' + PKG_BUILD
+PKG_VERSION   = '0.2.100' + PKG_BUILD
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 
 desc "Default Task"

data/TODO

@@ -1,5 +1,4 @@
 = Features Remaining
-  - XML-RPC support
   - Support for ActiveRecord model classes as structure types as well, since
     we can reflect all the details to do proper mapping from model classes.
 
@@ -21,5 +20,11 @@
         * Use the return value of the action to send back to the client
 
 = Warts
+  - Come up with a cleaner way for supporting XML-RPC introspection that doesn't
+    involve throwing a SystemExportNotHandledError exception.
+  - Come up with a cleaner approach for 'default_export' implementations.
+    But NOT method_missing!
+  - Create abstract SOAP test that provides helpers for doing SOAP method
+    calls, get rid of the copy & paste SOAP crap in the SOAP protocol tests
   - Don't have clean way to go from SOAP Class object to the xsd:NAME type
     string

data/lib/action_service/base.rb

@@ -8,6 +8,7 @@ module ActionService
     class_inheritable_option :export_name_mangling, true
     class_inheritable_option :report_exceptions, true
     class_inheritable_option :logger
+    class_inheritable_option :default_export
 
     class << self
       def export(name, options={})
@@ -19,14 +20,6 @@ module ActionService
           expects = options[:expects]
           returns = options[:returns]
         end
-        if expects.nil?
-          arity = instance_method(name).arity
-          expects = [Object] * arity if arity > 0
-        end
-        if returns.nil?
-          returns = [NilClass]
-        end
-
         name = name.to_sym
         public_name = public_export_name(name)
         info = { :expects => expects, :returns => returns }

data/lib/action_service/container.rb

@@ -36,15 +36,6 @@ module ActionService
         read_inheritable_attribute("action_services") || {}
       end
 
-      def service_object(service_name)
-        info = services[service_name.to_sym]
-        unless info
-          raise(ContainerError, "no such service '#{service_name}'")
-        end
-        service = info[:block]
-        service ? instance_eval(&service) : info[:object]
-      end
-
       private
         def call_service_definition_callbacks(container_klass, service_name, service_info)
           (read_inheritable_attribute("action_service_definition_callbacks") || []).each do |block|
@@ -54,14 +45,64 @@ module ActionService
     end
 
     module InstanceMethods
+      def service_object(service_name)
+        info = self.class.services[service_name.to_sym]
+        unless info
+          raise(ContainerError, "no such service '#{service_name}'")
+        end
+        service = info[:block]
+        service ? instance_eval(&service) : info[:object]
+      end
+
       private
         def dispatch_service_invocation_request(protocol, info)
-          service = self.class.service_object(info.service_name)
-          method_name = service.class.internal_export_name(info.public_method_name)
-          export_info = service.class.exports[method_name]
-          params = protocol.unmarshal_request(info, export_info)
-          result = service.perform_invocation(method_name, params)
-          protocol.marshal_response(info, export_info, result)
+          service = service_object(info.service_name)
+          service_klass = service.class
+          method_name = service_klass.internal_export_name(info.public_method_name)
+          opts = {}
+          params = []
+          if method_name
+            export_info = service_klass.exports[method_name]
+            strict = true
+          else
+            system_exports = self.class.read_inheritable_attribute('default_system_exports') || {}
+            method_name = system_exports[protocol.class]
+            if method_name
+              opts[:system_call] = [info.public_method_name, system_exports[protocol.class]]
+              params.unshift service_klass
+            else
+              method_name = service_klass.default_export
+              method_name = method_name.to_sym if method_name
+              unless method_name
+                raise(ContainerError, "no such method /#{info.service_name}##{info.public_method_name}()")
+              end
+            end
+            export_info = {}
+            strict = false
+          end
+          opts[:require_exported] = false unless strict
+          params = params + protocol.unmarshal_request(info, export_info, strict)
+          canceled_reason = nil
+          canceled_block = lambda{|r| canceled_reason = r}
+          perform_invoke = lambda do
+            service.perform_invocation(method_name, params, opts, &canceled_block)
+          end
+          begin
+            result = perform_invoke.call
+          rescue ActionService::Protocol::SystemExportNotHandledError => e
+            params.shift
+            method_name = service_klass.default_export
+            opts.delete(:system_call)
+            if method_name
+              method_name = method_name.to_sym
+              export_info = {}
+              strict = false
+            else
+              raise(ContainerError, "no such method /#{info.service_name}##{info.public_method_name}()")
+            end
+            result = perform_invoke.call
+          end
+          protocol.marshal_response(info, export_info, result, strict)
         end
 
     end

data/lib/action_service/invocation.rb

@@ -86,7 +86,7 @@ module ActionService
         end
     end
 
-    module InstanceMethods # :nodoc:
+    module InstanceMethods
       def self.append_features(base)
         super
         base.class_eval do
@@ -95,19 +95,30 @@ module ActionService
         end
       end
 
-      def perform_invocation_with_interception(name, args=nil, &block)
+      def perform_invocation_with_interception(name, args=nil, options={}, &block)
         return if before_invocation(name, args, &block) == false
-        result = perform_invocation_without_interception(name, args)
+        result = perform_invocation_without_interception(name, args, options)
         after_invocation(name, args, result)
         result
       end
 
-      def perform_invocation(name, args=nil)
-        unless self.respond_to?(name) and self.class.has_export?(name)
-          raise InvocationError, "no such exported method '#{name}'"
+      def perform_invocation(name, args=nil, options={})
+        unless options[:require_exported] == false
+          unless self.respond_to?(name) && self.class.has_export?(name)
+            raise InvocationError, "no such exported method '#{name}'"
+          end
         end
         args ||= []
-        self.send(name, *args)
+        if options[:system_call]
+          name, block = options[:system_call]
+          if block.respond_to?('call')
+            block.call(name, *args)
+          else
+            self.send(block, *args)
+          end
+        else
+          self.send(name, *args)
+        end
       end
 
       def before_invocation(name, args, &block)

data/lib/action_service/protocol/abstract.rb

@@ -2,6 +2,8 @@ module ActionService
   module Protocol
     class ProtocolError < ActionService::ActionServiceError
     end
+    class SystemExportNotHandledError < ProtocolError
+    end
 
     class AbstractProtocol
       attr :container_klass
@@ -10,11 +12,11 @@ module ActionService
         @container_klass = container_klass
       end
 
-      def unmarshal_request(request_info, export_info)
+      def unmarshal_request(request_info, export_info, strict=true)
         raise NotImplementedError
       end
 
-      def marshal_response(request_info, export_info, return_value)
+      def marshal_response(request_info, export_info, return_value, strict=true)
         raise NotImplementedError
       end
 
@@ -22,13 +24,44 @@ module ActionService
         raise NotImplementedError
       end
 
-      def request_info(request)
+      def request_info
         raise NotImplementedError
       end
 
       def request_supported?(request)
         raise NotImplementedError
       end
+      
+      private
+        def validate_types(method_name, signature, params, kind)
+          unless signature.length == params.length
+            raise(ProtocolError, "signature/parameter mismatch")
+          end
+          case kind
+          when :in
+            extra_msg = ' (Input parameter %d of method "%s")'
+          when :out
+            extra_msg = ' (Return value %d of method "%s")'
+          end
+          i = 0
+          signature.each do |klass|
+            check_compatibility(params[i].class, klass, extra_msg % [i+1, method_name])
+            i += 1
+          end
+        end
+
+        def check_compatibility(given_klass, signature_klass, extra_msg=nil)
+          if (given_klass == TrueClass or given_klass == FalseClass) and \
+             (signature_klass == TrueClass or signature_klass == FalseClass)
+            return true
+          end
+          unless given_klass.ancestors.include?(signature_klass) || \
+                 signature_klass.ancestors.include?(given_klass)
+            raise(ProtocolError, "value of type #{given_klass.name} is not compatible " +
+                                 "with expected type #{signature_klass.name}" +
+                                 (extra_msg ? extra_msg : ''))
+          end
+        end
     end
 
     class ServiceRequestInfo
@@ -38,7 +71,7 @@ module ActionService
       attr :content_type
       attr :protocol_info
 
-      def initialize(service_name, public_method_name, raw_body, content_type, protocol_info)
+      def initialize(service_name, public_method_name, raw_body, content_type, protocol_info=nil)
         @service_name = service_name
         @public_method_name = public_method_name
         @raw_body = raw_body

data/lib/action_service/protocol/soap.rb

@@ -28,30 +28,52 @@ module ActionService
       end
 
       class SoapProtocol < AbstractProtocol
-        def unmarshal_request(request_info, export_info)
+        def unmarshal_request(request_info, export_info, strict=true)
           expects = export_info[:expects]
-          map_types(expects) if expects
-          envelope = SOAP::Processor.unmarshal(request_info.raw_body)
-          request = envelope.body.request
-          params = request.collect{|k, v| request[k]}
-          params = soap_to_ruby_array(params)
-          validate_types(request_info.public_method_name, expects, params, :in) if expects
-          params
+          unmarshal_soap_message = lambda do
+            envelope = SOAP::Processor.unmarshal(request_info.raw_body)
+            request = envelope.body.request
+            params = request.collect{|k, v| request[k]}
+            soap_to_ruby_array(params)
+          end if expects || !strict
+          if expects
+            map_types(expects)
+            params = unmarshal_soap_message.call
+            validate_types(request_info.public_method_name, expects, params, :in) if expects
+            params
+          else
+            if strict
+              []
+            else
+              unmarshal_soap_message.call
+            end
+          end
         end
 
-        def marshal_response(request_info, export_info, return_value)
+        def marshal_response(request_info, export_info, return_value, strict=true)
           returns = export_info[:returns]
+          create_param_def = lambda do |ret|
+            map_types(ret)
+            mapping = mapper.lookup(ret[0])
+            ret = [mapping.ruby_klass]
+            retval = fixup_array_types(mapping, return_value)
+            validate_types(request_info.public_method_name, ret, [retval], :out)
+            retval = ruby_to_soap(retval)
+            param_def = [['retval', 'return', mapping.registry_mapping]]
+            [param_def, ret, retval]
+          end if returns || !strict
           if returns
-            map_types(returns)
-            mapping = mapper.lookup(returns[0])
-            return_value = fixup_array_types(mapping, return_value)
+            param_def, returns, return_value = create_param_def.call(returns)
+          else
+            if strict
+              param_def = []
+            else
+              param_def, returns, return_value = create_param_def.call([return_value.class])
+            end
           end
-          validate_types(request_info.public_method_name, returns, [return_value], :out)
-          return_value = ruby_to_soap(return_value)
-          param_def = returns ? [['retval', 'return', mapping.registry_mapping]] : []
           qname = XSD::QName.new(mapper.custom_namespace, request_info.public_method_name)
           response = SOAP::RPC::SOAPMethodResponse.new(qname, param_def)
-          response.retval = return_value
+          response.retval = return_value if returns
           ServiceResponseInfo.new(create_response(response), 'text/xml')
         end
 
@@ -59,19 +81,20 @@ module ActionService
           ServiceResponseInfo.new(create_exception_response(exception), 'text/xml')
         end
 
-        def request_info(request)
+        def request_info
+          @request_info
+        end
+
+        def request_supported?(request)
           soap_action = extract_soap_action(request)
+          return false unless soap_action
           service_name = request.parameters['action']
           public_method_name = soap_action.gsub(/^[\/]+/, '').split(/[\/]+/)[-1]
-          ServiceRequestInfo.new(service_name,
+          @request_info = ServiceRequestInfo.new(service_name,
             public_method_name,
             request.raw_post,
-            request.env['HTTP_CONTENT_TYPE'] || 'text/xml',
-            :soap => { :action => soap_action })
-        end
-
-        def request_supported?(request)
-          extract_soap_action(request) ? true : false
+            request.env['HTTP_CONTENT_TYPE'] || 'text/xml')
+          true
         end
 
         private
@@ -89,9 +112,10 @@ module ActionService
             end
             if mapping.is_a?(SoapArrayMapping)
               obj = mapping.ruby_klass.new(obj)
-            else
-              obj
+              # man, this is going to be slow for big arrays :(
+              obj.each{|el| fixup_array_types(mapping.element_mapping, el)}
             end
+            obj
           end
 
           def extract_soap_action(request)
@@ -111,36 +135,6 @@ module ActionService
             types.collect{|type| mapper.map(type)}
           end
 
-          def validate_types(method_name, signature, params, kind)
-            unless signature.length == params.length
-              raise(ProtocolError, "signature/parameter mismatch")
-            end
-            case kind
-            when :in
-              extra_msg = ' (Input parameter %d of method "%s")'
-            when :out
-              extra_msg = ' (Return value %d of method "%s")'
-            end
-            i = 0
-            signature.each do |klass|
-              check_compatibility(params[i].class, klass, extra_msg % [i, method_name])
-              i += 1
-            end
-          end
-
-          def check_compatibility(klass1, klass2, extra_msg=nil)
-            if (klass1 == TrueClass or klass1 == FalseClass) and \
-               (klass2 == TrueClass or klass2 == FalseClass)
-              return true
-            end
-            unless klass1.ancestors.include?(klass2) || \
-                   klass2.ancestors.include?(klass1)
-              raise(ProtocolError, "value of type #{klass1.name} is not compatible " +
-                                   "with expected type #{klass2.name}" +
-                                   (extra_msg ? extra_msg : ''))
-            end
-          end
-
           def create_response(body, is_error=false)
             header = SOAP::SOAPHeader.new
             body = SOAP::SOAPBody.new(body)
@@ -261,9 +255,9 @@ module ActionService
         end
         alias :map :lookup
         
-        def map_container_services(container_klass, &block)
-          container_klass.services.each do |service_name, service_info|
-            object = container_klass.service_object(service_name)
+        def map_container_services(container, &block)
+          container.class.services.each do |service_name, service_info|
+            object = container.service_object(service_name)
             service_klass = object.class
             service_exports = {}
             object.class.exports.each do |export_name, export_info|
@@ -286,7 +280,8 @@ module ActionService
                 mapping 
               end
               expects_signature = expects ? expects.map{|klass| lookup_proc.call(klass)} : nil
-              returns_signature = export_info[:returns].map{|klass| lookup_proc.call(klass)}
+              returns = export_info[:returns]
+              returns_signature = returns ? returns.map{|klass| lookup_proc.call(klass)} : nil
               service_exports[export_name] = {
                 :expects => expects_signature,
                 :returns => returns_signature
@@ -380,6 +375,8 @@ module ActionService
         def type_name
           super + "Array"
         end
+
+        def each_attribute(&block); end
       end
     end
   end

data/lib/action_service/protocol/xmlrpc.rb

@@ -0,0 +1,97 @@
+require 'xmlrpc/parser'
+require 'xmlrpc/utils'
+
+module ActionService
+  module Protocol
+    module XmlRpc
+      def self.append_features(base)
+        super
+        base.register_protocol(BodyOnly, XmlRpcProtocol)
+      end
+
+      class XmlRpcProtocol < AbstractProtocol
+        include XMLRPC::ParserWriterChooseMixin
+
+        def initialize(container_klass)
+          @container_klass = container_klass
+          @container_klass.write_inheritable_hash('default_system_exports', XmlRpcProtocol => method(:xmlrpc_default_system_handler))
+        end
+
+        def unmarshal_request(request_info, export_info, strict=true)
+          expects = export_info[:expects]
+          params = request_info.protocol_info[:xmlrpc][:params]
+          if expects
+            expects = array_types(expects)
+            validate_types(request_info.public_method_name, expects, params, :in)
+            params
+          else
+            strict ? [] : params
+          end
+        end
+  
+        def marshal_response(request_info, export_info, return_value, strict=true)
+          returns = export_info[:returns]
+          if returns
+            returns = array_types(returns)
+            validate_types(request_info.public_method_name, returns, [return_value], :out)
+            raw_response = create().methodResponse(true, return_value)
+          else
+            # XML-RPC doesn't have the concept of a void method, nor does it
+            # support a nil return value, so return true if we would have returned
+            # nil
+            if strict
+              raw_response = create().methodResponse(true, true)
+            else
+              return_value = true if return_value.nil?
+              raw_response = create().methodResponse(true, return_value)
+            end
+          end
+          ServiceResponseInfo.new(raw_response, 'text/xml')
+        end
+  
+        def marshal_exception(exception)
+          raw_response = create().methodResponse(false, exception)
+          ServiceResponseInfo.new(raw_response, 'text/xml')
+        end
+  
+        def request_info
+          @request_info
+        end
+  
+        def request_supported?(request)
+          begin
+            service_name = request.parameters['action']
+            methodname, params = parser().parseMethodCall(request.raw_post)
+            @request_info = ServiceRequestInfo.new(service_name,
+              methodname,
+              request.raw_post,
+              request.env['HTTP_CONTENT_TYPE'] || 'text/xml',
+              :xmlrpc => { :params => params })
+            true
+          rescue
+            false
+          end
+        end
+
+        private
+          def xmlrpc_default_system_handler(name, service_klass, *args)
+            case name
+            when 'system.listMethods'
+              methods = []
+              service_klass.exports.each do |name, info|
+                methods << service_klass.public_export_name(name)
+              end
+              methods.sort
+            else
+              raise SystemExportNotHandledError
+            end
+          end
+
+          def array_types(signature)
+            signature.map{|x| x.is_a?(Array) ? Array : x}
+          end
+      end
+
+    end
+  end
+end

data/lib/action_service/protocol.rb

@@ -1,3 +1,4 @@
 require 'action_service/protocol/abstract'
 require 'action_service/protocol/registry'
 require 'action_service/protocol/soap'
+require 'action_service/protocol/xmlrpc'

data/lib/action_service/router/action_controller.rb

@@ -19,7 +19,7 @@ module ActionService
             request_info = nil
             begin
               protocol = probe_request_protocol(self.request)
-              request_info = protocol.request_info(self.request)
+              request_info = protocol.request_info
               if request_info
                 log_request request_info
                 response_info = dispatch_service_invocation_request(protocol, request_info)
@@ -35,7 +35,7 @@ module ActionService
               end
             rescue Exception => e
               log_error e unless logger.nil?
-              service_object = self.class.service_object(request_info.service_name)
+              service_object = service_object(request_info.service_name)
               exc_response = nil
               if service_object.class.report_exceptions
                 exc_response_info = protocol.marshal_exception(e) rescue nil

data/lib/action_service/router/wsdl.rb

@@ -13,15 +13,15 @@ module ActionService
         SoapEncodingNs    = 'http://schemas.xmlsoap.org/soap/encoding/'
         SoapHttpTransport = 'http://schemas.xmlsoap.org/soap/http'
 
-        def to_wsdl(container_klass, uri, soap_action_base)
+        def to_wsdl(container, uri, soap_action_base)
           wsdl = ""
 
-          namespace = container_klass.soap_mapper.custom_namespace
+          namespace = container.class.soap_mapper.custom_namespace
           wsdl_service_name = namespace.split(/:/)[1]
 
           mapper = ActionService::Protocol::Soap::SoapMapper.new(namespace)
           services = {}
-          mapper.map_container_services(container_klass) do |name, klass, exports|
+          mapper.map_container_services(container) do |name, klass, exports|
             services[name] = [klass, exports]
           end
           custom_types = mapper.custom_types
@@ -78,7 +78,9 @@ module ActionService
                   xm.message('name' => msg_name) do
                     sym = nil
                     if direction == :out
-                      xm.part('name' => 'return', 'type' => export_signature[:returns][0].qualified_type_name)
+                      if export_signature[:returns]
+                        xm.part('name' => 'return', 'type' => export_signature[:returns][0].qualified_type_name)
+                      end
                     else
                       mapping_list = export_signature[:expects]
                       i = 1
@@ -165,7 +167,7 @@ module ActionService
             begin
               uri = "http://#{@request.env['HTTP_HOST']||@request.env['SERVER_NAME']}/#{controller_name}/"
               soap_action_base = "/#{controller_name}"
-              xml = self.class.to_wsdl(self.class, uri, soap_action_base)
+              xml = self.class.to_wsdl(self, uri, soap_action_base)
               send_data(xml, :type => 'text/xml', :disposition => 'inline')
             rescue Exception => e
               render_text('', "500 #{e.message}")

data/lib/action_service.rb

@@ -45,6 +45,7 @@ ActionController::Base.class_eval do
   include ActionService::Container
   include ActionService::Protocol::Registry
   include ActionService::Protocol::Soap
+  include ActionService::Protocol::XmlRpc
   include ActionService::Router::ActionController
   include ActionService::Router::Wsdl
 end

data/test/base_test.rb

@@ -44,4 +44,8 @@ class BaseTest < Test::Unit::TestCase
     assert(BaseTestService.internal_export_name('Add') == :add)
     assert(UnmangledOrReportedService.public_export_name(:custom_name_casing) == 'custom_name_casing')
   end
+
+  def test_missing_method
+    assert(BaseTestService.has_public_export?('NoSuchMethod') == false)
+  end
 end

data/test/container_test.rb

@@ -11,11 +11,23 @@ $immediate_service = Object.new
 $deferred_service = Object.new
 
 class TestContainer < AbstractTestContainer
+  attr :flag
+  attr :previous_flag
+
+  def initialize
+    @previous_flag = nil
+    @flag = true
+  end
+
   service :immediate_service, $immediate_service
-  service(:deferred_service) { $deferred_service }
+  service(:deferred_service) { @previous_flag = @flag; @flag = false; $deferred_service }
 end
 
 class ContainerTest < Test::Unit::TestCase
+  def setup
+    @container = TestContainer.new
+  end
+
   def test_registration
     assert(TestContainer.has_service?(:immediate_service))
     assert(TestContainer.has_service?(:deferred_service))
@@ -23,7 +35,12 @@ class ContainerTest < Test::Unit::TestCase
   end
 
   def test_service_object
-    assert(TestContainer.service_object(:immediate_service) == $immediate_service)
-    assert(TestContainer.service_object(:deferred_service) == $deferred_service)
+    assert(@container.flag == true)
+    assert(@container.service_object(:immediate_service) == $immediate_service)
+    assert(@container.previous_flag.nil?)
+    assert(@container.flag == true)
+    assert(@container.service_object(:deferred_service) == $deferred_service)
+    assert(@container.previous_flag == true)
+    assert(@container.flag == false)
   end
 end

data/test/protocol_soap_test.rb

@@ -4,10 +4,13 @@ require 'soap/rpc/element'
 class SoapService < ActionService::Base
   attr :int
   attr :string
+  attr :values
+  attr :default_args
 
   def initialize
     @int = 20
     @string = "wrong string value"
+    @default_args = nil
   end
 
   def some_method(int, string)
@@ -16,7 +19,19 @@ class SoapService < ActionService::Base
     true
   end
 
+  def array_returner
+    @values = [1, 2, 3]
+  end
+
+  def default(*args)
+    @default_args = args
+    nil
+  end
+
   export :some_method, :expects => [Integer, String], :returns => [TrueClass]
+  export :array_returner, :returns => [[Integer]]
+
+  default_export :default
 end
 
 class SoapContainer
@@ -68,7 +83,7 @@ class ProtocolSoapTest < Test::Unit::TestCase
     test_request.env['RAW_POST_DATA'] = raw_request
     protocol = @container.request_protocol(test_request)
     assert(protocol.is_a?(ActionService::Protocol::Soap::SoapProtocol))
-    request_info = protocol.request_info(test_request)
+    request_info = protocol.request_info
     assert(request_info.service_name == service_name)
     assert(request_info.public_method_name == public_method_name)
     method_name = SoapService.internal_export_name(public_method_name)
@@ -77,7 +92,7 @@ class ProtocolSoapTest < Test::Unit::TestCase
     assert(params.length == 2)
     assert(params == [int_value, string_value])
     response = @container.dispatch_request(protocol, request_info)
-    service = SoapContainer.service_object(:soap_service)
+    service = @container.service_object(:soap_service)
     assert(service.int == int_value)
     assert(service.string == string_value)
     raw_response = response.raw_body
@@ -91,4 +106,76 @@ class ProtocolSoapTest < Test::Unit::TestCase
   def test_service_name
     assert(SoapContainer.soap_mapper.custom_namespace == 'urn:Test')
   end
+
+  def test_array_returning
+    service_name = 'soap_service'
+    public_method_name = 'ArrayReturner'
+    qname = XSD::QName.new('urn:ActionService', public_method_name)
+    request = SOAP::RPC::SOAPMethodRequest.new(qname)
+    header = SOAP::SOAPHeader.new
+    body = SOAP::SOAPBody.new(request)
+    envelope = SOAP::SOAPEnvelope.new(header, body)
+    raw_request = SOAP::Processor.marshal(envelope)
+    test_request = ActionController::TestRequest.new
+    test_request.request_parameters['action'] = service_name
+    test_request.env['REQUEST_METHOD'] = "POST"
+    test_request.env['HTTP_CONTENTTYPE'] = 'text/xml'
+    test_request.env['HTTP_SOAPACTION'] = "/soap/#{service_name}/#{public_method_name}"
+    test_request.env['RAW_POST_DATA'] = raw_request
+    protocol = @container.request_protocol(test_request)
+    assert(protocol.is_a?(ActionService::Protocol::Soap::SoapProtocol))
+    request_info = protocol.request_info
+    method_name = SoapService.internal_export_name(public_method_name)
+    export_info = SoapService.exports[method_name]
+    response = @container.dispatch_request(protocol, request_info)
+    service = @container.service_object(:soap_service)
+    assert(service.values == [1, 2, 3])
+    raw_response = response.raw_body
+    envelope = SOAP::Processor.unmarshal(raw_response)
+    assert(envelope.is_a?(SOAP::SOAPEnvelope))
+    resp = envelope.body.response
+    assert(resp.is_a?(SOAP::SOAPArray))
+    assert(SOAP::Mapping.soap2obj(resp) == [1, 2, 3])
+  end
+
+  def test_default_export
+    service_name = 'soap_service'
+    public_method_name = 'NonExistentMethodName'
+    qname = XSD::QName.new('urn:ActionService', public_method_name)
+    int_value = 50
+    bool_value = false
+    param_def = [
+      ['in', 'param1', [SOAP::SOAPInt]],
+      ['in', 'param2', [SOAP::SOAPBoolean]],
+    ]
+    request = SOAP::RPC::SOAPMethodRequest.new(qname, param_def)
+    request.set_param([
+      ['param1', SOAP::Mapping.obj2soap(int_value)],
+      ['param2', SOAP::Mapping.obj2soap(bool_value)]
+    ])
+    header = SOAP::SOAPHeader.new
+    body = SOAP::SOAPBody.new(request)
+    envelope = SOAP::SOAPEnvelope.new(header, body)
+    raw_request = SOAP::Processor.marshal(envelope)
+    test_request = ActionController::TestRequest.new
+    test_request.request_parameters['action'] = service_name
+    test_request.env['REQUEST_METHOD'] = "POST"
+    test_request.env['HTTP_CONTENTTYPE'] = 'text/xml'
+    test_request.env['HTTP_SOAPACTION'] = "/soap/#{service_name}/#{public_method_name}"
+    test_request.env['RAW_POST_DATA'] = raw_request
+    protocol = @container.request_protocol(test_request)
+    assert(protocol.is_a?(ActionService::Protocol::Soap::SoapProtocol))
+    request_info = protocol.request_info
+    method_name = SoapService.internal_export_name(public_method_name)
+    export_info = SoapService.exports[method_name]
+    service = @container.service_object(:soap_service)
+    assert(service.default_args.nil?)
+    response = @container.dispatch_request(protocol, request_info)
+    raw_response = response.raw_body
+    envelope = SOAP::Processor.unmarshal(raw_response)
+    assert(envelope.is_a?(SOAP::SOAPEnvelope))
+    resp = envelope.body.response
+    assert(resp.is_a?(SOAP::SOAPNil))
+    assert(service.default_args == [50, false])
+  end
 end

data/test/protocol_xmlrpc_test.rb

@@ -0,0 +1,130 @@
+require File.dirname(__FILE__) + '/abstract_unit'
+require 'xmlrpc/parser'
+require 'xmlrpc/create'
+require 'xmlrpc/config'
+
+module XMLRPC
+  class XmlRpcHelper
+    include ParserWriterChooseMixin
+  
+    def create_request(methodName, *args)
+      create().methodCall(methodName, *args)
+    end
+
+    def parse_response(response)
+      parser().parseMethodResponse(response)
+    end
+  end
+end
+
+class XmlRpcService < ActionService::Base
+  attr :result
+  attr :hashvalue
+  attr :default_args
+
+  def initialize
+    @result = nil
+    @hashvalue = nil
+    @default_args = nil
+  end
+
+  def add(a, b)
+    @result = a + b
+  end
+
+  def something_hash(hash)
+    @hashvalue = hash
+  end
+
+  def array_returner
+    [1, 2, 3]
+  end
+  
+  def hash_returner
+    {'name' => 1, 'value' => 2}
+  end
+
+  def default(*args)
+    @default_args = args
+    nil
+  end
+
+  export :add,            :expects => [Integer, Integer], :returns => [Integer]
+  export :hash_returner,  :returns => [Hash]
+  export :array_returner, :returns => [[Integer]]
+  export :something_hash, :expects => [Hash]
+
+  default_export :default
+end
+
+$service = XmlRpcService.new
+
+class XmlRpcContainer
+  include ActionService::Container
+  include ActionService::Protocol::Registry
+  include ActionService::Protocol::Soap
+  include ActionService::Protocol::XmlRpc
+
+  def request_protocol(request)
+    probe_request_protocol(request)
+  end
+
+  def dispatch_request(protocol, info)
+    dispatch_service_invocation_request(protocol, info)
+  end
+
+  service :xmlrpc, $service
+end
+
+class ProtocolXmlRpcTest < Test::Unit::TestCase
+  def setup
+    @helper = XMLRPC::XmlRpcHelper.new
+    @container = XmlRpcContainer.new
+  end
+
+  def test_xmlrpc_request_dispatching
+    retval = do_xmlrpc_call('Add', 50, 30)
+    assert(retval == [true, 80])
+  end
+
+  def test_array_returning
+    retval = do_xmlrpc_call('ArrayReturner')
+    assert(retval == [true, [1, 2, 3]])
+  end
+
+  def test_hash_returning
+    retval = do_xmlrpc_call('HashReturner')
+    assert(retval == [true, {'name' => 1, 'value' => 2}])
+  end
+
+  def test_hash_parameter
+    retval = do_xmlrpc_call('SomethingHash', {'name' => 1, 'value' => 2})
+    assert(retval == [true, true])
+    assert($service.hashvalue == {'name' => 1, 'value' => 2})
+  end
+
+  def test_default_export
+    retval = do_xmlrpc_call('SomeNonexistentMethod', 'test', [1, 2], {'name'=>'value'})
+    assert(retval == [true, true])
+    assert($service.default_args == ['test', [1, 2], {'name'=>'value'}])
+  end
+
+  def test_xmlrpc_introspection
+    retval = do_xmlrpc_call('system.listMethods', 'test', [1, 2], {'name'=>'value'})
+    assert(retval == [true,  ["Add", "ArrayReturner", "HashReturner", "SomethingHash"]])
+  end
+
+  private
+    def do_xmlrpc_call(public_method_name, *args)
+      service_name = 'xmlrpc'
+      raw_request = @helper.create_request(public_method_name, *args)
+      test_request = ActionController::TestRequest.new
+      test_request.request_parameters['action'] = service_name
+      test_request.env['REQUEST_METHOD'] = "POST"
+      test_request.env['HTTP_CONTENTTYPE'] = 'text/xml'
+      test_request.env['RAW_POST_DATA'] = raw_request
+      protocol = @container.request_protocol(test_request)
+      response = @container.dispatch_request(protocol, protocol.request_info)
+      @helper.parse_response(response.raw_body)
+    end
+end

data/test/router_wsdl_test.rb

@@ -17,8 +17,12 @@ class WsdlTestService < ActionService::Base
     []
   end
 
+  def nil_returner
+  end
+
   export :add, :expects => [Integer, Integer], :returns => [Integer]
   export :find_people, :returns => [[TestPerson]]
+  export :nil_returner
 end
 
 class WsdlController < ActionController::Base
@@ -27,7 +31,7 @@ end
 
 class RouterWsdlTest < Test::Unit::TestCase
   def test_wsdl_generation
-    wsdl = WsdlController.to_wsdl(WsdlController, 'http://localhost:3000/test/', '/test')
+    wsdl = WsdlController.to_wsdl(WsdlController.new, 'http://localhost:3000/test/', '/test')
     assert(WSDL::Parser.new.parse(wsdl).is_a?(WSDL::Definitions))
   end
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.4
 specification_version: 1
 name: actionservice
 version: !ruby/object:Gem::Version 
-  version: 0.2.99
-date: 2005-02-07
+  version: 0.2.100
+date: 2005-02-08
 summary: Web service support for Action Pack.
 require_paths: 
   - lib
@@ -35,38 +35,40 @@ files:
   - CHANGELOG
   - MIT-LICENSE
   - examples/soap
-  - examples/soap/app
   - examples/soap/lib
   - examples/soap/README
+  - examples/soap/app
+  - examples/soap/lib/google_search_service.rb
   - examples/soap/app/controllers
   - examples/soap/app/controllers/search_controller.rb
-  - examples/soap/lib/google_search_service.rb
   - lib/action_service
   - lib/action_service.rb
-  - lib/action_service/router
   - lib/action_service/protocol
-  - lib/action_service/invocation.rb
-  - lib/action_service/router.rb
-  - lib/action_service/protocol.rb
-  - lib/action_service/container.rb
-  - lib/action_service/struct.rb
+  - lib/action_service/router
   - lib/action_service/base.rb
+  - lib/action_service/container.rb
   - lib/action_service/support
+  - lib/action_service/protocol.rb
+  - lib/action_service/router.rb
+  - lib/action_service/struct.rb
+  - lib/action_service/invocation.rb
+  - lib/action_service/protocol/registry.rb
+  - lib/action_service/protocol/soap.rb
+  - lib/action_service/protocol/xmlrpc.rb
+  - lib/action_service/protocol/abstract.rb
   - lib/action_service/router/action_controller.rb
   - lib/action_service/router/wsdl.rb
-  - lib/action_service/protocol/abstract.rb
-  - lib/action_service/protocol/soap.rb
-  - lib/action_service/protocol/registry.rb
   - lib/action_service/support/class_inheritable_options.rb
+  - test/struct_test.rb
+  - test/abstract_unit.rb
   - test/base_test.rb
   - test/container_test.rb
-  - test/invocation_test.rb
-  - test/router_action_controller_test.rb
-  - test/abstract_unit.rb
+  - test/protocol_registry_test.rb
   - test/protocol_soap_test.rb
-  - test/struct_test.rb
+  - test/invocation_test.rb
   - test/router_wsdl_test.rb
-  - test/protocol_registry_test.rb
+  - test/protocol_xmlrpc_test.rb
+  - test/router_action_controller_test.rb
 test_files: []
 rdoc_options: []
 extra_rdoc_files: []