actionwebservice 0.8.1 → 0.9.1

data/CHANGELOG

@@ -1,3 +1,23 @@
+*0.9.1* (October 19th, 2005)
+
+* Upgraded to Action Pack 1.10.1 and Active Record 1.12.1
+
+
+*0.9.0* (October 16th, 2005)
+
+* Fix invalid XML request generation bug in test_invoke [Ken Barker]
+
+* Add XML-RPC 'system.multicall' support #1941 [jbonnar]
+
+* Fix duplicate XSD entries for custom types shared across delegated/layered services #1729 [Tyler Kovacs]
+
+* Allow multiple invocations in the same test method #1720 [dkhawk]
+
+* Added ActionWebService::API::Base.soap_client and ActionWebService::API::Base.xmlrpc_client helper methods to create the internal clients for an API, useful for testing from ./script/console
+
+* ActionWebService now always returns UTF-8 responses.
+
+
 *0.8.1* (11 July, 2005)
 
 * Fix scaffolding for Action Pack controller changes

data/README

@@ -215,6 +215,25 @@ custom types and message definition types:
 The default namespace used is 'urn:ActionWebService', if you don't supply
 one.
 
+
+== ActionWebService and UTF-8
+
+If you're going to be sending back strings containing non-ASCII UTF-8
+characters using the <tt>:string</tt> data type, you need to make sure that
+Ruby is using UTF-8 as the default encoding for its strings.
+
+The default in Ruby to use US-ASCII encoding for strings, which causes a string
+validation check in the Ruby SOAP library to fail and your string to be sent
+back as a Base-64 value, which may confuse clients that expected strings
+because of the WSDL.
+
+Two ways of doing setting the default string encoding are:
+
+* Start Ruby using the <tt>-Ku</tt> command-line option to the Ruby executable
+* Set the <tt>$KCODE</tt> flag in <tt>config/environment.rb</tt> to the
+  string <tt>'UTF8'</tt>
+
+
 == Testing your APIs
 
 

data/Rakefile

@@ -6,10 +6,11 @@ require 'rake/packagetask'
 require 'rake/gempackagetask'
 require 'rake/contrib/rubyforgepublisher'
 require 'fileutils'
+require File.join(File.dirname(__FILE__), 'lib', 'action_web_service', 'version')
 
 PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
 PKG_NAME      = 'actionwebservice'
-PKG_VERSION   = '0.8.1' + PKG_BUILD
+PKG_VERSION   = ActionWebService::Version::STRING + PKG_BUILD
 PKG_FILE_NAME   = "#{PKG_NAME}-#{PKG_VERSION}"
 PKG_DESTINATION = ENV["RAILS_PKG_DESTINATION"] || "../#{PKG_NAME}"
 
@@ -62,9 +63,9 @@ spec = Gem::Specification.new do |s|
   s.rubyforge_project = "aws"
   s.homepage = "http://www.rubyonrails.org"
 
-  s.add_dependency('actionpack', '= 1.9.1' + PKG_BUILD)
-  s.add_dependency('activerecord', '= 1.11.1' + PKG_BUILD)
-  s.add_dependency('activesupport', '= 1.1.1' + PKG_BUILD)
+  s.add_dependency('actionpack', '= 1.10.1' + PKG_BUILD)
+  s.add_dependency('activerecord', '= 1.12.1' + PKG_BUILD)
+  s.add_dependency('activesupport', '= 1.2.1' + PKG_BUILD)
 
   s.has_rdoc = true
   s.requirements << 'none'

data/lib/action_web_service/dispatcher/abstract.rb

@@ -16,11 +16,10 @@ module ActionWebService # :nodoc:
       private
         def invoke_web_service_request(protocol_request)
           invocation = web_service_invocation(protocol_request)
-          case web_service_dispatching_mode
-          when :direct
-            web_service_direct_invoke(invocation)
-          when :delegated, :layered
-            web_service_delegated_invoke(invocation)
+          if invocation.is_a?(Array) && protocol_request.protocol.is_a?(Protocol::XmlRpc::XmlRpcProtocol)
+            xmlrpc_multicall_invoke(invocation)
+          else
+            web_service_invoke(invocation)
           end
         end
       
@@ -47,10 +46,47 @@ module ActionWebService # :nodoc:
           if cancellation_reason
             raise(DispatcherError, "request canceled: #{cancellation_reason}")
           end
+          return_value
+        end
+        
+        def web_service_invoke(invocation)
+          case web_service_dispatching_mode
+          when :direct
+            return_value = web_service_direct_invoke(invocation)
+          when :delegated, :layered
+            return_value = web_service_delegated_invoke(invocation)
+          end
           web_service_create_response(invocation.protocol, invocation.protocol_options, invocation.api, invocation.api_method, return_value)
         end
+        
+        def xmlrpc_multicall_invoke(invocations)
+          responses = []
+          invocations.each do |invocation|
+            if invocation.is_a?(Hash)
+              responses << invocation
+              next
+            end
+            begin
+              case web_service_dispatching_mode
+              when :direct
+                return_value = web_service_direct_invoke(invocation)
+              when :delegated, :layered
+                return_value = web_service_delegated_invoke(invocation)
+              end
+              api_method = invocation.api_method
+              if invocation.api.has_api_method?(api_method.name)
+                return_value = api_method.cast_returns(return_value)
+              end
+              responses << [return_value]
+            rescue Exception => e
+              responses << { 'faultCode' => 3, 'faultString' => e.message }
+            end
+          end
+          invocation = invocations[0]
+          invocation.protocol.encode_response('system.multicall', responses, nil, invocation.protocol_options)
+        end
 
-        def web_service_invocation(request)
+        def web_service_invocation(request, level = 0)
           public_method_name = request.method_name
           invocation = Invocation.new
           invocation.protocol = request.protocol
@@ -70,6 +106,32 @@ module ActionWebService # :nodoc:
               end
             end
           end
+          if invocation.protocol.is_a? Protocol::XmlRpc::XmlRpcProtocol
+            if public_method_name == 'multicall' && invocation.service_name == 'system'
+              if level > 0
+                raise(DispatcherError, "Recursive system.multicall invocations not allowed")
+              end
+              multicall = request.method_params.dup
+              unless multicall.is_a?(Array) && multicall[0].is_a?(Array)
+                raise(DispatcherError, "Malformed multicall (expected array of Hash elements)")
+              end
+              multicall = multicall[0]
+              return multicall.map do |item|
+                raise(DispatcherError, "Multicall elements must be Hash") unless item.is_a?(Hash)
+                raise(DispatcherError, "Multicall elements must contain a 'methodName' key") unless item.has_key?('methodName')
+                method_name = item['methodName']
+                params = item.has_key?('params') ? item['params'] : []
+                multicall_request = request.dup
+                multicall_request.method_name = method_name
+                multicall_request.method_params = params
+                begin
+                  web_service_invocation(multicall_request, level + 1)
+                rescue Exception => e
+                  {'faultCode' => 4, 'faultMessage' => e.message}
+                end
+              end
+            end
+          end
           case web_service_dispatching_mode
           when :direct
             invocation.api = self.class.web_service_api

data/lib/action_web_service/dispatcher/action_controller_dispatcher.rb

@@ -195,7 +195,7 @@ module ActionWebService # :nodoc:
             custom_types = []
             apis.values.each do |api, bindings|
               bindings.each do |b|
-                custom_types << b
+                custom_types << b unless custom_types.include?(b)
               end
             end
 
@@ -347,29 +347,32 @@ module ActionWebService # :nodoc:
 
           def register_api(api, marshaler)
             bindings = {}
-            traverse_custom_types(api, marshaler) do |binding|
+            traverse_custom_types(api, marshaler, bindings) do |binding|
               bindings[binding] = nil unless bindings.has_key?(binding)
               element_binding = binding.element_binding
-              bindings[binding.element_binding] = nil if element_binding && !bindings.has_key?(element_binding)
+              bindings[element_binding] = nil if element_binding && !bindings.has_key?(element_binding)
             end
             bindings.keys
           end
 
-          def traverse_custom_types(api, marshaler, &block)
+          def traverse_custom_types(api, marshaler, bindings, &block)
             api.api_methods.each do |name, method|
               expects, returns = method.expects, method.returns
-              expects.each{ |type| traverse_type(marshaler, type, &block) if type.custom? } if expects
-              returns.each{ |type| traverse_type(marshaler, type, &block) if type.custom? } if returns
+              expects.each{ |type| traverse_type(marshaler, type, bindings, &block) if type.custom? } if expects
+              returns.each{ |type| traverse_type(marshaler, type, bindings, &block) if type.custom? } if returns
             end
           end
 
-          def traverse_type(marshaler, type, &block)
-            yield marshaler.register_type(type)
+          def traverse_type(marshaler, type, bindings, &block)
+            binding = marshaler.register_type(type)
+            return if bindings.has_key?(binding)
+            bindings[binding] = nil
+            yield binding
             if type.array?
               yield marshaler.register_type(type.element_type)
               type = type.element_type
             end
-            type.each_member{ |name, type| traverse_type(marshaler, type, &block) } if type.structured?
+            type.each_member{ |name, type| traverse_type(marshaler, type, bindings, &block) } if type.structured?
           end
        end
     end

data/lib/action_web_service/protocol/abstract.rb

@@ -41,7 +41,7 @@ module ActionWebService # :nodoc:
 
     class Request # :nodoc:
       attr :protocol
-      attr :method_name
+      attr_accessor :method_name
       attr_accessor :method_params
       attr :service_name
       attr_accessor :api

data/lib/action_web_service/protocol/soap_protocol.rb

@@ -1,7 +1,16 @@
 require 'action_web_service/protocol/soap_protocol/marshaler'
 require 'soap/streamHandler'
+require 'action_web_service/client/soap_client'
 
 module ActionWebService # :nodoc:
+  module API # :nodoc:
+    class Base # :nodoc:
+      def self.soap_client(endpoint_uri, options={})
+        ActionWebService::Client::Soap.new self, endpoint_uri, options
+      end
+    end
+  end
+
   module Protocol # :nodoc:
     module Soap # :nodoc:
       def self.included(base)
@@ -11,7 +20,8 @@ module ActionWebService # :nodoc:
       end
       
       class SoapProtocol < AbstractProtocol # :nodoc:
-        DefaultEncoding = 'utf-8'
+        AWSEncoding = 'UTF-8'
+        XSDEncoding = 'UTF8'
 
         attr :marshaler
 
@@ -27,10 +37,10 @@ module ActionWebService # :nodoc:
         def decode_action_pack_request(action_pack_request)
           return nil unless soap_action = has_valid_soap_action?(action_pack_request)
           service_name = action_pack_request.parameters['action']
-          charset = parse_charset(action_pack_request.env['HTTP_CONTENT_TYPE'])
+          input_encoding = parse_charset(action_pack_request.env['HTTP_CONTENT_TYPE'])
           protocol_options = { 
             :soap_action => soap_action,
-            :charset  => charset
+            :charset  => input_encoding
           }
           decode_request(action_pack_request.raw_post, service_name, protocol_options)
         end
@@ -42,8 +52,7 @@ module ActionWebService # :nodoc:
         end
 
         def decode_request(raw_request, service_name, protocol_options={})
-          charset = protocol_options[:charset] || DefaultEncoding
-          envelope = SOAP::Processor.unmarshal(raw_request, :charset => charset)
+          envelope = SOAP::Processor.unmarshal(raw_request, :charset => protocol_options[:charset])
           unless envelope
             raise ProtocolError, "Failed to parse SOAP request message"
           end
@@ -109,8 +118,17 @@ module ActionWebService # :nodoc:
             end
           end
           envelope = create_soap_envelope(response)
-          charset = protocol_options[:charset] || DefaultEncoding
-          Response.new(SOAP::Processor.marshal(envelope, :charset => charset), "text/xml; charset=#{charset}", return_value)
+
+          # FIXME: This is not thread-safe, but StringFactory_ in SOAP4R only
+          #        reads target encoding from the XSD::Charset.encoding variable.
+          #        This is required to ensure $KCODE strings are converted
+          #        correctly to UTF-8 for any values of $KCODE.
+          previous_encoding = XSD::Charset.encoding
+          XSD::Charset.encoding = XSDEncoding
+          response_body = SOAP::Processor.marshal(envelope, :charset => AWSEncoding)
+          XSD::Charset.encoding = previous_encoding
+
+          Response.new(response_body, "text/xml; charset=#{AWSEncoding}", return_value)
         end
 
         def protocol_client(api, protocol_name, endpoint_uri, options={})
@@ -138,20 +156,20 @@ module ActionWebService # :nodoc:
             soap_action
           end
 
+          def create_soap_envelope(body)
+            header = SOAP::SOAPHeader.new
+            body = SOAP::SOAPBody.new(body)
+            SOAP::SOAPEnvelope.new(header, body)
+          end
+
           def parse_charset(content_type)
-            return DefaultEncoding if content_type.nil?
+            return AWSEncoding if content_type.nil?
             if /^text\/xml(?:\s*;\s*charset=([^"]+|"[^"]+"))$/i =~ content_type
               $1
             else
-              DefaultEncoding
+              AWSEncoding
             end
           end
-
-          def create_soap_envelope(body)
-            header = SOAP::SOAPHeader.new
-            body = SOAP::SOAPBody.new(body)
-            SOAP::SOAPEnvelope.new(header, body)
-          end
       end
     end
   end

data/lib/action_web_service/protocol/xmlrpc_protocol.rb

@@ -1,4 +1,5 @@
 require 'xmlrpc/marshal'
+require 'action_web_service/client/xmlrpc_client'
 
 module XMLRPC # :nodoc:
   class FaultException # :nodoc:
@@ -7,6 +8,14 @@ module XMLRPC # :nodoc:
 end
 
 module ActionWebService # :nodoc:
+  module API # :nodoc: 
+    class Base # :nodoc:
+      def self.xmlrpc_client(endpoint_uri, options={})
+        ActionWebService::Client::XmlRpc.new self, endpoint_uri, options
+      end
+    end
+  end
+
   module Protocol # :nodoc:
     module XmlRpc # :nodoc:
       def self.included(base)

data/lib/action_web_service/scaffolding.rb

@@ -40,7 +40,7 @@ module ActionWebService
       # can then be used as the entry point for invoking API methods from a web browser.
       def web_service_scaffold(action_name)
         add_template_helper(Helpers)
-        module_eval <<-END, __FILE__, __LINE__
+        module_eval <<-"end_eval", __FILE__, __LINE__
           def #{action_name}
             if request.method == :get
               setup_invocation_assigns
@@ -112,8 +112,17 @@ module ActionWebService
             def render_invocation_scaffold(action)
               customized_template = "\#{self.class.controller_path}/#{action_name}/\#{action}"
               default_template = scaffold_path(action)
-              @content_for_layout = template_exists?(customized_template) ? @template.render_file(customized_template) : @template.render_file(default_template, false)
-              self.active_layout ? render_file(self.active_layout, "200 OK", true) : render_file(scaffold_path("layout"))
+              if template_exists?(customized_template)
+                content = @template.render_file(customized_template)
+              else
+                content = @template.render_file(default_template, false)
+              end
+              @template.instance_variable_set("@content_for_layout", content)
+              if self.active_layout.nil?
+                render_file(scaffold_path("layout"))
+              else
+                render_file(self.active_layout, "200 OK", true)
+              end
             end
 
             def scaffold_path(template_name)
@@ -159,7 +168,7 @@ module ActionWebService
               rescue_action(exception)
               true
             end
-        END
+        end_eval
       end
     end
 

data/lib/action_web_service/test_invoke.rb

@@ -29,6 +29,7 @@ module Test # :nodoc:
         # ---------------------- internal ---------------------------
 
         def prepare_request(action, service_name, api_method_name, *args)
+          @request.recycle!
           @request.request_parameters['action'] = action
           @request.env['REQUEST_METHOD'] = 'POST'
           @request.env['HTTP_CONTENT_TYPE'] = 'text/xml'
@@ -81,7 +82,7 @@ module Test # :nodoc:
 
         def protocol
           if @protocol.nil?
-            @protocol ||= ActionWebService::Protocol::Soap::SoapProtocol.new(@controller)
+            @protocol ||= ActionWebService::Protocol::Soap::SoapProtocol.create(@controller)
           else
             case @protocol
             when :xmlrpc

data/lib/action_web_service/version.rb

@@ -0,0 +1,9 @@
+module ActionWebService
+  module Version
+    MAJOR = 0
+    MINOR = 9
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/test/abstract_dispatcher.rb

@@ -4,6 +4,7 @@ require 'stringio'
 class ActionController::Base; def rescue_action(e) raise e end; end
 
 module DispatcherTest
+  Utf8String = "One World Caf\303\251"
   WsdlNamespace = 'http://rubyonrails.com/some/namespace'
 
   class Node < ActiveRecord::Base
@@ -58,6 +59,7 @@ module DispatcherTest
     api_method :hash_struct_return, :returns => [[Person]]
     api_method :thrower
     api_method :void
+    api_method :test_utf8, :returns => [:string]
     api_method :hex, :expects => [:base64], :returns => [:string]
     api_method :unhex, :expects => [:string], :returns => [:base64]
   end
@@ -105,11 +107,15 @@ module DispatcherTest
   class MTAPI < ActionWebService::API::Base
     inflect_names false
     api_method :getCategories, :returns => [[:string]]
+    api_method :bool, :returns => [:bool]
+    api_method :alwaysFail
   end
 
   class BloggerAPI < ActionWebService::API::Base
     inflect_names false
     api_method :getCategories, :returns => [[:string]]
+    api_method :str, :expects => [:int], :returns => [:string]
+    api_method :alwaysFail
   end
 
   class MTService < ActionWebService::Base
@@ -118,6 +124,14 @@ module DispatcherTest
     def getCategories
       ["mtCat1", "mtCat2"]
     end
+    
+    def bool
+      'y'
+    end
+    
+    def alwaysFail
+      raise "MT AlwaysFail"
+    end
   end
 
   class BloggerService < ActionWebService::Base
@@ -126,6 +140,17 @@ module DispatcherTest
     def getCategories
       ["bloggerCat1", "bloggerCat2"]
     end
+
+    def str(int)
+      unless int.is_a?(Integer)
+        raise "Not an integer!"
+      end
+      500 + int
+    end
+
+    def alwaysFail
+      raise "Blogger AlwaysFail"
+    end
   end
 
   class AbstractController < ActionController::Base
@@ -223,6 +248,10 @@ module DispatcherTest
       @void_called = @method_params
     end
 
+    def test_utf8
+      Utf8String
+    end
+
     def hex(s)
       return s.unpack("H*")[0]
     end
@@ -398,12 +427,6 @@ module DispatcherCommonTests
       raise NotImplementedError
     end
 
-    def update_request(ap_request)
-    end
-
-    def check_response(ap_response)
-    end
-
     def protocol
       @protocol
     end
@@ -439,8 +462,8 @@ module DispatcherCommonTests
           public_method_name = real_method_name
           request_env['HTTP_SOAPACTION'] = "/soap/#{service_name}/#{real_method_name}"
         end
-        api = container.web_service_object(service_name.to_sym).class.web_service_api
-        method = api.public_api_method_instance(real_method_name)
+        api = container.web_service_object(service_name.to_sym).class.web_service_api rescue nil
+        method = api.public_api_method_instance(real_method_name) rescue nil
         service_name = self.service_name(container)
       end
       protocol.register_api(api)
@@ -453,11 +476,10 @@ module DispatcherCommonTests
       # puts body
       ap_request = protocol.encode_action_pack_request(service_name, public_method_name, body, :request_class => ActionController::TestRequest)
       ap_request.env.update(request_env)
-      update_request(ap_request)
       ap_response = ActionController::TestResponse.new
       container.process(ap_request, ap_response)
       # puts ap_response.body
-      check_response(ap_response)
+      @response_body = ap_response.body
       public_method_name, return_value = protocol.decode_response(ap_response.body)
       unless is_exception?(return_value) || virtual
         return_value = method.cast_returns(return_value)

data/test/dispatcher_action_controller_soap_test.rb

@@ -67,16 +67,25 @@ class TC_DispatcherActionControllerSoap < Test::Unit::TestCase
     assert_equal(["bloggerCat1", "bloggerCat2"], blogger_cats)
   end
 
-  protected
-    def update_request(ap_request)
-      ap_request.env.update('HTTP_CONTENT_TYPE' => 'text/xml; charset=us-ascii')
-    end
-
-    def check_response(ap_response)
-      assert_equal 'text/xml; charset=us-ascii', ap_response.headers['Content-Type']
-      assert_match /xml.*?encoding="us-ascii"/, ap_response.body
-    end
+  def test_utf8
+    @direct_controller.web_service_exception_reporting = true
+    $KCODE = 'u'
+    assert_equal(Utf8String, do_method_call(@direct_controller, 'TestUtf8'))
+    retval = SOAP::Processor.unmarshal(@response_body).body.response
+    assert retval.is_a?(SOAP::SOAPString)
+
+    # If $KCODE is not set to UTF-8, any strings with non-ASCII UTF-8 data
+    # will be sent back as base64 by SOAP4R. By the time we get it here though,
+    # it will be decoded back into a string. So lets read the base64 value
+    # from the message body directly.
+    $KCODE = 'NONE'
+    do_method_call(@direct_controller, 'TestUtf8')
+    retval = SOAP::Processor.unmarshal(@response_body).body.response
+    assert retval.is_a?(SOAP::SOAPBase64)
+    assert_equal "T25lIFdvcmxkIENhZsOp", retval.data.to_s
+  end
 
+  protected
     def exception_message(soap_fault_exception)
       soap_fault_exception.detail.cause.message
     end

data/test/dispatcher_action_controller_xmlrpc_test.rb

@@ -19,6 +19,29 @@ class TC_DispatcherActionControllerXmlRpc < Test::Unit::TestCase
     assert_equal(["bloggerCat1", "bloggerCat2"], blogger_cats)
   end
 
+  def test_multicall
+    response = do_method_call(@layered_controller, 'system.multicall', [
+      {'methodName' => 'mt.getCategories'},
+      {'methodName' => 'blogger.getCategories'},
+      {'methodName' => 'mt.bool'},
+      {'methodName' => 'blogger.str', 'params' => ['2000']},
+      {'methodName' => 'mt.alwaysFail'},
+      {'methodName' => 'blogger.alwaysFail'},
+      {'methodName' => 'mt.blah'},
+      {'methodName' => 'blah.blah'}
+    ])
+    assert_equal [
+      [["mtCat1", "mtCat2"]],
+      [["bloggerCat1", "bloggerCat2"]],
+      [true],
+      ["2500"],
+      {"faultCode" => 3, "faultString" => "MT AlwaysFail"},
+      {"faultCode" => 3, "faultString" => "Blogger AlwaysFail"},
+      {"faultCode" => 4, "faultMessage" => "no such method 'blah' on API DispatcherTest::MTAPI"},
+      {"faultCode" => 4, "faultMessage" => "no such web service 'blah'"}
+    ], response
+  end
+
   protected
     def exception_message(xmlrpc_fault_exception)
       xmlrpc_fault_exception.faultString

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.10
 specification_version: 1
 name: actionwebservice
 version: !ruby/object:Gem::Version 
-  version: 0.8.1
-date: 2005-07-11
+  version: 0.9.1
+date: 2005-10-19
 summary: Web service support for Action Pack.
 require_paths: 
   - lib
@@ -72,6 +72,7 @@ files:
   - lib/action_web_service/support
   - lib/action_web_service/templates
   - lib/action_web_service/test_invoke.rb
+  - lib/action_web_service/version.rb
   - lib/action_web_service/client/base.rb
   - lib/action_web_service/client/soap_client.rb
   - lib/action_web_service/client/xmlrpc_client.rb
@@ -129,7 +130,7 @@ dependencies:
         - 
           - "="
           - !ruby/object:Gem::Version 
-            version: 1.9.1
+            version: 1.10.1
       version: 
   - !ruby/object:Gem::Dependency 
     name: activerecord
@@ -139,7 +140,7 @@ dependencies:
         - 
           - "="
           - !ruby/object:Gem::Version 
-            version: 1.11.1
+            version: 1.12.1
       version: 
   - !ruby/object:Gem::Dependency 
     name: activesupport
@@ -149,5 +150,5 @@ dependencies:
         - 
           - "="
           - !ruby/object:Gem::Version 
-            version: 1.1.1
+            version: 1.2.1
       version: