actionwebservice 0.7.1 → 0.8.0

data/lib/action_web_service/support/signature_types.rb

@@ -1,6 +1,19 @@
 module ActionWebService # :nodoc:
-  module SignatureTypes # :nodoc:
-    def canonical_signature(signature)
+  # Action Web Service supports the following base types in a signature:
+  #
+  # [<tt>:int</tt>]      Represents an integer value, will be cast to an integer using <tt>Integer(value)</tt>
+  # [<tt>:string</tt>]   Represents a string value, will be cast to an string using the <tt>to_s</tt> method on an object
+  # [<tt>:base64</tt>]   Represents a Base 64 value, will contain the binary bytes of a Base 64 value sent by the caller
+  # [<tt>:bool</tt>]     Represents a boolean value, whatever is passed will be cast to boolean (<tt>true</tt>, '1', 'true', 'y', 'yes' are taken to represent true; <tt>false</tt>, '0', 'false', 'n', 'no' and <tt>nil</tt> represent false)
+  # [<tt>:float</tt>]    Represents a floating point value, will be cast to a float using <tt>Float(value)</tt>
+  # [<tt>:time</tt>]     Represents a timestamp, will be cast to a <tt>Time</tt> object
+  # [<tt>:datetime</tt>] Represents a timestamp, will be cast to a <tt>DateTime</tt> object
+  # [<tt>:date</tt>]     Represents a date, will be cast to a <tt>Date</tt> object
+  #
+  # For structured types, you'll need to pass in the Class objects of
+  # ActionWebService::Struct and ActiveRecord::Base derivatives.
+  module SignatureTypes
+    def canonical_signature(signature) # :nodoc:
       return nil if signature.nil?
       unless signature.is_a?(Array)
         raise(ActionWebServiceError, "Expected signature to be an Array")
@@ -9,7 +22,7 @@ module ActionWebService # :nodoc:
       signature.map{ |spec| canonical_signature_entry(spec, i += 1) }
     end
 
-    def canonical_signature_entry(spec, i)
+    def canonical_signature_entry(spec, i) # :nodoc:
       orig_spec = spec
       name = "param#{i}"
       if spec.is_a?(Hash)
@@ -28,20 +41,22 @@ module ActionWebService # :nodoc:
       end
     end
 
-    def canonical_type(type)
+    def canonical_type(type) # :nodoc:
       type_name = symbol_name(type) || class_to_type_name(type)
       type = type_name || type
       return canonical_type_name(type) if type.is_a?(Symbol)
       type
     end
 
-    def canonical_type_name(name)
+    def canonical_type_name(name) # :nodoc:
       name = name.to_sym
       case name
         when :int, :integer, :fixnum, :bignum
           :int
-        when :string, :base64
+        when :string
           :string
+        when :base64
+          :base64
         when :bool, :boolean
           :bool
         when :float, :double
@@ -57,22 +72,24 @@ module ActionWebService # :nodoc:
       end
     end
 
-    def canonical_type_class(type)
+    def canonical_type_class(type) # :nodoc:
       type = canonical_type(type)
       type.is_a?(Symbol) ? type_name_to_class(type) : type
     end
 
-    def symbol_name(name)
+    def symbol_name(name) # :nodoc:
       return name.to_sym if name.is_a?(Symbol) || name.is_a?(String)
       nil
     end
 
-    def class_to_type_name(klass)
+    def class_to_type_name(klass) # :nodoc:
       klass = klass.class unless klass.is_a?(Class)
       if derived_from?(Integer, klass) || derived_from?(Fixnum, klass) || derived_from?(Bignum, klass)
         :int
       elsif klass == String
         :string
+      elsif klass == Base64
+        :base64
       elsif klass == TrueClass || klass == FalseClass
         :bool
       elsif derived_from?(Float, klass) || derived_from?(Precision, klass) || derived_from?(Numeric, klass)
@@ -88,12 +105,14 @@ module ActionWebService # :nodoc:
       end
     end
 
-    def type_name_to_class(name)
+    def type_name_to_class(name) # :nodoc:
       case canonical_type_name(name)
       when :int
         Integer
       when :string
         String
+      when :base64
+        Base64
       when :bool
         TrueClass
       when :float
@@ -109,7 +128,7 @@ module ActionWebService # :nodoc:
       end
     end
 
-    def derived_from?(ancestor, child)
+    def derived_from?(ancestor, child) # :nodoc:
       child.ancestors.include?(ancestor)
     end
 
@@ -150,6 +169,12 @@ module ActionWebService # :nodoc:
     def structured?
       false
     end
+
+    def human_name(show_name=true)
+      type_type = array? ? element_type.type.to_s : self.type.to_s
+      str = array? ? (type_type + '[]') : type_type
+      show_name ? (str + " " + name.to_s) : str
+    end
   end
 
   class ArrayType < BaseType # :nodoc:
@@ -191,4 +216,7 @@ module ActionWebService # :nodoc:
       true
     end
   end
+
+  class Base64 < String # :nodoc:
+  end
 end

data/lib/action_web_service/templates/scaffolds/layout.rhtml

@@ -28,7 +28,7 @@
 
     #ErrorExplanation {
       width: 400px;
-    	border: 2px solid #red;
+    	border: 2px solid 'red';
     	padding: 7px;
     	padding-bottom: 12px;
     	margin-bottom: 20px;

data/lib/action_web_service/templates/scaffolds/parameters.rhtml

@@ -10,13 +10,15 @@
 </p>
 
 <% if @scaffold_method.expects %>
+<% i = 0 %>
 
 <strong>Method Parameters:</strong><br />
 <% @scaffold_method.expects.each do |type| %>
   <p>
-  <label for="method_params[]"><%= type.name.to_s.camelize %></label><br />
-  <%= method_parameter_input_fields(@scaffold_method, type) %>
+  <label for="method_params[<%= i %>]"><%= method_parameter_label(type.name, type) %> </label><br />
+  <%= method_parameter_input_fields(@scaffold_method, type, "method_params[#{i}]") %>
   </p>
+  <% i += 1 %>
 <% end %>
 
 <% end %>

data/lib/action_web_service/test_invoke.rb

@@ -21,9 +21,6 @@ module Test # :nodoc:
 
         # invoke the specified layered API method on the correct service
         def invoke_layered(service_name, method_name, *args)
-          if protocol.is_a?(ActionWebService::Protocol::Soap::SoapProtocol)
-            raise "SOAP protocol support for :layered dispatching mode is not available"
-          end
           prepare_request('api', service_name, method_name, *args)
           @controller.process(@request, @response)
           decode_rpc_response
@@ -66,7 +63,7 @@ module Test # :nodoc:
 
         def public_method_name(service_name, api_method_name)
           public_name = service_api(service_name).public_api_method_name(api_method_name)
-          if @controller.web_service_dispatching_mode == :layered
+          if @controller.web_service_dispatching_mode == :layered && protocol.is_a?(ActionWebService::Protocol::XmlRpc::XmlRpcProtocol)
             '%s.%s' % [service_name.to_s, public_name]
           else
             public_name
@@ -84,13 +81,13 @@ module Test # :nodoc:
 
         def protocol
           if @protocol.nil?
-            @protocol ||= ActionWebService::Protocol::Soap::SoapProtocol.new
+            @protocol ||= ActionWebService::Protocol::Soap::SoapProtocol.new(@controller)
           else
             case @protocol
             when :xmlrpc
-              @protocol = ActionWebService::Protocol::XmlRpc::XmlRpcProtocol.new
+              @protocol = ActionWebService::Protocol::XmlRpc::XmlRpcProtocol.create(@controller)
             when :soap
-              @protocol = ActionWebService::Protocol::Soap::SoapProtocol.new
+              @protocol = ActionWebService::Protocol::Soap::SoapProtocol.create(@controller)
             else
               @protocol
             end

data/test/abstract_dispatcher.rb

@@ -4,6 +4,8 @@ require 'stringio'
 class ActionController::Base; def rescue_action(e) raise e end; end
 
 module DispatcherTest
+  WsdlNamespace = 'http://rubyonrails.com/some/namespace'
+
   class Node < ActiveRecord::Base
     def initialize(*args)
       super(*args)
@@ -56,6 +58,8 @@ module DispatcherTest
     api_method :hash_struct_return, :returns => [[Person]]
     api_method :thrower
     api_method :void
+    api_method :hex, :expects => [:base64], :returns => [:string]
+    api_method :unhex, :expects => [:string], :returns => [:base64]
   end
 
   class VirtualAPI < ActionWebService::API::Base
@@ -126,18 +130,21 @@ module DispatcherTest
 
   class AbstractController < ActionController::Base
     def generate_wsdl
+      @request ||= ::ActionController::TestRequest.new
       to_wsdl
     end
   end
  
   class DelegatedController < AbstractController
     web_service_dispatching_mode :delegated
+    wsdl_namespace WsdlNamespace
   
     web_service(:test_service) { @service ||= Service.new; @service }
   end
 
   class LayeredController < AbstractController
     web_service_dispatching_mode :layered
+    wsdl_namespace WsdlNamespace
 
     web_service(:mt) { @mt_service ||= MTService.new; @mt_service }
     web_service(:blogger) { @blogger_service ||= BloggerService.new; @blogger_service }
@@ -146,6 +153,7 @@ module DispatcherTest
   class DirectController < AbstractController
     web_service_api DirectAPI
     web_service_dispatching_mode :direct
+    wsdl_namespace WsdlNamespace
 
     before_filter :alwaysfail, :only => [:before_filtered]
     after_filter :alwaysok, :only => [:after_filtered]
@@ -215,6 +223,14 @@ module DispatcherTest
       @void_called = @method_params
     end
 
+    def hex(s)
+      return s.unpack("H*")[0]
+    end
+
+    def unhex(s)
+      return [s].pack("H*")
+    end
+
     protected
       def alwaysfail
         @before_filter_called = true
@@ -228,6 +244,7 @@ module DispatcherTest
 
   class VirtualController < AbstractController
     web_service_api VirtualAPI
+    wsdl_namespace WsdlNamespace
 
     def fallback
       "fallback!"
@@ -247,6 +264,8 @@ module DispatcherCommonTests
     result = do_method_call(@direct_controller, 'BaseStructReturn')
     assert(result[0].is_a?(DispatcherTest::Person))
     assert(result[1].is_a?(DispatcherTest::Person))
+    assert_equal("cafe", do_method_call(@direct_controller, 'Hex', "\xca\xfe"))
+    assert_equal("\xca\xfe", do_method_call(@direct_controller, 'Unhex', "cafe"))
   end
 
   def test_direct_entrypoint
@@ -294,7 +313,7 @@ module DispatcherCommonTests
       controller.class.web_service_exception_reporting = true
       send_garbage_request = lambda do
         service_name = service_name(controller)
-        request = @protocol.encode_action_pack_request(service_name, 'broken, method, name!', 'broken request body', :request_class => ActionController::TestRequest)
+        request = protocol.encode_action_pack_request(service_name, 'broken, method, name!', 'broken request body', :request_class => ActionController::TestRequest)
         response = ActionController::TestResponse.new
         controller.process(request, response)
         # puts response.body
@@ -335,21 +354,21 @@ module DispatcherCommonTests
     assert_equal person, @direct_controller.struct_pass_value
     assert !person.equal?(@direct_controller.struct_pass_value)
     result = do_method_call(@direct_controller, 'StructPass', {'id' => '1', 'name' => 'test'})
-    case @protocol
-    when ActionWebService::Protocol::Soap::SoapProtocol
+    case
+    when soap?
       assert_equal(person, @direct_controller.struct_pass_value)
       assert !person.equal?(@direct_controller.struct_pass_value)
-    when ActionWebService::Protocol::XmlRpc::XmlRpcProtocol
+    when xmlrpc?
       assert_equal(person, @direct_controller.struct_pass_value)
       assert !person.equal?(@direct_controller.struct_pass_value)
     end
     assert_equal person, do_method_call(@direct_controller, 'HashStructReturn')[0]
     result = do_method_call(@direct_controller, 'StructPass', {'id' => '1', 'name' => 'test', 'nonexistent_attribute' => 'value'})
-    case @protocol
-    when ActionWebService::Protocol::Soap::SoapProtocol
+    case
+    when soap?
       assert_equal(person, @direct_controller.struct_pass_value)
       assert !person.equal?(@direct_controller.struct_pass_value)
-    when ActionWebService::Protocol::XmlRpc::XmlRpcProtocol
+    when xmlrpc?
       assert_equal(person, @direct_controller.struct_pass_value)
       assert !person.equal?(@direct_controller.struct_pass_value)
     end
@@ -379,6 +398,24 @@ module DispatcherCommonTests
       raise NotImplementedError
     end
 
+    def update_request(ap_request)
+    end
+
+    def check_response(ap_response)
+    end
+
+    def protocol
+      @protocol
+    end
+
+    def soap?
+      protocol.is_a? ActionWebService::Protocol::Soap::SoapProtocol
+    end
+
+    def xmlrpc?
+      protocol.is_a? ActionWebService::Protocol::XmlRpc::XmlRpcProtocol
+    end
+
     def do_method_call(container, public_method_name, *params)
       request_env = {}
       mode = container.web_service_dispatching_mode
@@ -398,7 +435,7 @@ module DispatcherCommonTests
           service_name = $1
           real_method_name = $2
         end
-        if @protocol.is_a? ActionWebService::Protocol::Soap::SoapProtocol
+        if soap?
           public_method_name = real_method_name
           request_env['HTTP_SOAPACTION'] = "/soap/#{service_name}/#{real_method_name}"
         end
@@ -406,24 +443,26 @@ module DispatcherCommonTests
         method = api.public_api_method_instance(real_method_name)
         service_name = self.service_name(container)
       end
-      @protocol.register_api(api)
+      protocol.register_api(api)
       virtual = false
       unless method
         virtual = true
         method ||= ActionWebService::API::Method.new(public_method_name.underscore.to_sym, public_method_name, nil, nil)
       end
-      body = @protocol.encode_request(public_method_name, params.dup, method.expects)
+      body = protocol.encode_request(public_method_name, params.dup, method.expects)
       # puts body
-      ap_request = @protocol.encode_action_pack_request(service_name, public_method_name, body, :request_class => ActionController::TestRequest)
+      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
-      public_method_name, return_value = @protocol.decode_response(ap_response.body)
+      check_response(ap_response)
+      public_method_name, return_value = protocol.decode_response(ap_response.body)
       unless is_exception?(return_value) || virtual
         return_value = method.cast_returns(return_value)
       end
-      if @protocol.is_a?(ActionWebService::Protocol::Soap::SoapProtocol)
+      if soap?
         # http://dev.rubyonrails.com/changeset/920
         assert_match(/Response$/, public_method_name) unless public_method_name == "fault"
       end

data/test/api_test.rb

@@ -7,7 +7,7 @@ module APITest
     api_method :expects,             :expects => [:int, :bool]
     api_method :returns,             :returns => [:int, [:string]]
     api_method :named_signature,     :expects => [{:appkey=>:int}, {:publish=>:bool}]
-    api_method :string_types,        :expects => ['int', 'string', 'bool']
+    api_method :string_types,        :expects => ['int', 'string', 'bool', 'base64']
     api_method :class_types,         :expects => [TrueClass, Bignum, String]
   end
 end
@@ -45,7 +45,7 @@ class TC_API < Test::Unit::TestCase
     assert_equal([Integer, [String]], API.api_methods[:returns].returns.map{|x| x.array?? [x.element_type.type_class] : x.type_class})
     assert_equal([[:appkey, Integer], [:publish, TrueClass]], API.api_methods[:named_signature].expects.map{|x| [x.name, x.type_class]})
     assert_equal(nil, API.api_methods[:named_signature].returns)
-    assert_equal([Integer, String, TrueClass], API.api_methods[:string_types].expects.map{|x| x.type_class})
+    assert_equal([Integer, String, TrueClass, ActionWebService::Base64], API.api_methods[:string_types].expects.map{|x| x.type_class})
     assert_equal(nil, API.api_methods[:string_types].returns)
     assert_equal([TrueClass, Integer, String], API.api_methods[:class_types].expects.map{|x| x.type_class})
     assert_equal(nil, API.api_methods[:class_types].returns)

data/test/casting_test.rb

@@ -4,6 +4,7 @@ module CastingTest
   class API < ActionWebService::API::Base
     api_method :int,       :expects => [:int]
     api_method :str,       :expects => [:string]
+    api_method :base64,    :expects => [:base64]
     api_method :bool,      :expects => [:bool]
     api_method :float,     :expects => [:float]
     api_method :time,      :expects => [:time]
@@ -22,6 +23,9 @@ class TC_Casting < Test::Unit::TestCase
   def test_base_type_casting_valid
     assert_equal 10000,   cast_expects(:int, '10000')[0]
     assert_equal '10000', cast_expects(:str, 10000)[0]
+    base64 = cast_expects(:base64, 10000)[0]
+    assert_equal '10000', base64
+    assert_instance_of ActionWebService::Base64, base64
     [1, '1', 'true', 'y', 'yes'].each do |val|
       assert_equal true, cast_expects(:bool, val)[0]
     end
@@ -62,8 +66,8 @@ class TC_Casting < Test::Unit::TestCase
 
   def test_array_type_casting
     assert_equal [1, 2, 3213992, 4], cast_expects(:int_array, ['1', '2', '3213992', '4'])[0]
-    assert_equal ['one', 'two', '5.0', '200', '', 'true'], cast_expects(:str_array, [:one, 'two', 5.0, 200, nil, true])[0]
-    assert_equal [true, false, true, true, false], cast_expects(:bool_array, ['1', nil, 'y', true, 'false'])[0]
+    assert_equal ['one', 'two', '5.0', '200', nil, 'true'], cast_expects(:str_array, [:one, 'two', 5.0, 200, nil, true])[0]
+    assert_equal [true, nil, true, true, false], cast_expects(:bool_array, ['1', nil, 'y', true, 'false'])[0]
   end
 
   def test_array_type_casting_failure

data/test/dispatcher_action_controller_soap_test.rb

@@ -27,12 +27,12 @@ class TC_DispatcherActionControllerSoap < Test::Unit::TestCase
     @delegated_controller = DelegatedController.new
     @virtual_controller = VirtualController.new
     @layered_controller = LayeredController.new
-    @protocol = ActionWebService::Protocol::Soap::SoapProtocol.new
+    @protocol = ActionWebService::Protocol::Soap::SoapProtocol.create(@direct_controller)
   end
 
   def test_wsdl_generation
-    ensure_valid_wsdl_generation DelegatedController.new
-    ensure_valid_wsdl_generation DirectController.new
+    ensure_valid_wsdl_generation DelegatedController.new, DispatcherTest::WsdlNamespace
+    ensure_valid_wsdl_generation DirectController.new, DispatcherTest::WsdlNamespace
   end
 
   def test_wsdl_action
@@ -68,6 +68,15 @@ class TC_DispatcherActionControllerSoap < Test::Unit::TestCase
   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 exception_message(soap_fault_exception)
       soap_fault_exception.detail.cause.message
     end
@@ -81,12 +90,12 @@ class TC_DispatcherActionControllerSoap < Test::Unit::TestCase
       container.is_a?(DelegatedController) ? 'test_service' : 'api'
     end
 
-    def ensure_valid_wsdl_generation(controller)
+    def ensure_valid_wsdl_generation(controller, expected_namespace)
       wsdl = controller.generate_wsdl
-      ensure_valid_wsdl(wsdl)
+      ensure_valid_wsdl(controller, wsdl, expected_namespace)
     end
 
-    def ensure_valid_wsdl(wsdl)
+    def ensure_valid_wsdl(controller, wsdl, expected_namespace)
       definitions = WSDL::Parser.new.parse(wsdl)
       assert(definitions.is_a?(WSDL::Definitions))
       definitions.bindings.each do |binding|
@@ -99,7 +108,13 @@ class TC_DispatcherActionControllerSoap < Test::Unit::TestCase
       end
       types = definitions.collect_complextypes.map{|x| x.name}
       types.each do |type|
-        assert(type.namespace == 'urn:ActionWebService')
+        assert(type.namespace == expected_namespace)
+      end
+      location = definitions.services[0].ports[0].soap_address.location
+      if controller.is_a?(DelegatedController)
+        assert_match %r{http://localhost/dispatcher_test/delegated/test_service$}, location
+      elsif controller.is_a?(DirectController)
+        assert_match %r{http://localhost/dispatcher_test/direct/api$}, location
       end
       definitions.collect_complextypes
     end
@@ -107,9 +122,9 @@ class TC_DispatcherActionControllerSoap < Test::Unit::TestCase
     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_request.env['HTTP_HOST'] = 'localhost'
       test_response = ActionController::TestResponse.new
       wsdl = controller.process(test_request, test_response).body
-      ensure_valid_wsdl(wsdl)
+      ensure_valid_wsdl(controller, wsdl, DispatcherTest::WsdlNamespace)
     end
 end