fix WSDL generation, change the way protocols are instantiated, and add

the ability to override the namespace used in WSDL instead of always forcing
'urn:ActionWebService'


git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@1501 5ecf4fe2-1ee6-0310-87b1-e25e094e27de

3 files changed, 40 insertions, 22 deletions

diff --git a/actionwebservice/test/abstract_dispatcher.rb b/actionwebservice/test/abstract_dispatcher.rb
index 78243ee497..12ab08019f 100644
--- a/actionwebservice/test/abstract_dispatcher.rb
+++ b/actionwebservice/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)
@@ -135,12 +137,14 @@ module DispatcherTest
  
   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 }
@@ -149,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]
@@ -239,6 +244,7 @@ module DispatcherTest
 
   class VirtualController < AbstractController
     web_service_api VirtualAPI
+    wsdl_namespace WsdlNamespace
 
     def fallback
       "fallback!"
@@ -307,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
@@ -348,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
@@ -398,6 +404,18 @@ module DispatcherCommonTests
     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
@@ -417,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
@@ -425,26 +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
       check_response(ap_response)
-      public_method_name, return_value = @protocol.decode_response(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)
       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
diff --git a/actionwebservice/test/dispatcher_action_controller_soap_test.rb b/actionwebservice/test/dispatcher_action_controller_soap_test.rb
index aa57765b2c..6e332828f2 100644
--- a/actionwebservice/test/dispatcher_action_controller_soap_test.rb
+++ b/actionwebservice/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
@@ -90,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(controller, wsdl)
+      ensure_valid_wsdl(controller, wsdl, expected_namespace)
     end
 
-    def ensure_valid_wsdl(controller, 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|
@@ -108,7 +108,7 @@ 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)
@@ -125,6 +125,6 @@ class TC_DispatcherActionControllerSoap < Test::Unit::TestCase
       test_request.env['HTTP_HOST'] = 'localhost'
       test_response = ActionController::TestResponse.new
       wsdl = controller.process(test_request, test_response).body
-      ensure_valid_wsdl(controller, wsdl)
+      ensure_valid_wsdl(controller, wsdl, DispatcherTest::WsdlNamespace)
     end
 end
diff --git a/actionwebservice/test/dispatcher_action_controller_xmlrpc_test.rb b/actionwebservice/test/dispatcher_action_controller_xmlrpc_test.rb
index f1dc992818..be8d553fc9 100644
--- a/actionwebservice/test/dispatcher_action_controller_xmlrpc_test.rb
+++ b/actionwebservice/test/dispatcher_action_controller_xmlrpc_test.rb
@@ -5,11 +5,11 @@ class TC_DispatcherActionControllerXmlRpc < Test::Unit::TestCase
   include DispatcherCommonTests
 
   def setup
-    @protocol = ActionWebService::Protocol::XmlRpc::XmlRpcProtocol.new
     @direct_controller = DirectController.new
     @delegated_controller = DelegatedController.new
     @layered_controller = LayeredController.new
     @virtual_controller = VirtualController.new
+    @protocol = ActionWebService::Protocol::XmlRpc::XmlRpcProtocol.create(@direct_controller)
   end
 
   def test_layered_dispatching