From 418d487020d24e69b528fdbedfecb20a87f99fcb Mon Sep 17 00:00:00 2001 From: Leon Breedt Date: Sat, 19 Feb 2005 08:29:42 +0000 Subject: refactoring: * move dispatching out of the Container into Dispatcher, it makes more sense for Container to only contain the list of web services defined in it. * collapse Wsdl and ActionController "routers" into an ActionController-specific module, no advantage to having them seperate as they were quite tightly coupled. rename to Dispatcher, to avoi confusion with Routing. * add a "_thing" suffix to concept-specific filenames. this is so that we don't end up with many soap.rb files, for example. * remove "virtual invocation" support. adds complexity, and it doesn't seem to add any value. git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@679 5ecf4fe2-1ee6-0310-87b1-e25e094e27de --- .../test/dispatcher_action_controller_test.rb | 186 +++++++++++++++++++++ 1 file changed, 186 insertions(+) create mode 100644 actionwebservice/test/dispatcher_action_controller_test.rb (limited to 'actionwebservice/test/dispatcher_action_controller_test.rb') diff --git a/actionwebservice/test/dispatcher_action_controller_test.rb b/actionwebservice/test/dispatcher_action_controller_test.rb new file mode 100644 index 0000000000..11ab21c6a6 --- /dev/null +++ b/actionwebservice/test/dispatcher_action_controller_test.rb @@ -0,0 +1,186 @@ +require File.dirname(__FILE__) + '/abstract_soap' +require 'wsdl/parser' + +module DispatcherActionControllerTest + class API < ActionWebService::API::Base + api_method :add, :expects => [:int, :int], :returns => [:int] + end + + class DirectAPI < ActionWebService::API::Base + api_method :add, :expects => [{:a=>:int}, {:b=>:int}], :returns => [:int] + api_method :before_filtered + api_method :after_filtered, :returns => [:int] + api_method :thrower + end + + class Service < ActionWebService::Base + web_service_api API + + attr :added + + def add(a, b) + @added = a + b + end + end + + class AbstractController < ActionController::Base + def generate_wsdl(container, uri, soap_action_base) + to_wsdl(container, uri, soap_action_base) + end + end + + class DelegatedController < AbstractController + web_service_dispatching_mode :delegated + + web_service(:test_service) { @service ||= Service.new; @service } + end + + class DirectController < AbstractController + web_service_api DirectAPI + web_service_dispatching_mode :direct + + before_filter :alwaysfail, :only => [:before_filtered] + after_filter :alwaysok, :only => [:after_filtered] + + attr :added + attr :before_filter_called + attr :before_filter_target_called + attr :after_filter_called + attr :after_filter_target_called + + def initialize + @before_filter_called = false + @before_filter_target_called = false + @after_filter_called = false + @after_filter_target_called = false + end + + def add + @added = @params['a'] + @params['b'] + end + + def before_filtered + @before_filter_target_called = true + end + + def after_filtered + @after_filter_target_called = true + 5 + end + + def thrower + raise "Hi, I'm a SOAP exception" + end + + protected + def alwaysfail + @before_filter_called = true + false + end + + def alwaysok + @after_filter_called = true + end + end +end + +class TC_DispatcherActionController < AbstractSoapTest + include DispatcherActionControllerTest + + def test_direct_dispatching + @container = DirectController.new + assert(do_soap_call('Add', 20, 50) == 70) + assert(@container.added == 70) + end + + def test_direct_entrypoint + @container = DirectController.new + assert(@container.respond_to?(:api)) + end + + def test_direct_filtering + @container = DirectController.new + assert(@container.before_filter_called == false) + assert(@container.before_filter_target_called == false) + assert(do_soap_call('BeforeFiltered').nil?) + assert(@container.before_filter_called == true) + assert(@container.before_filter_target_called == false) + assert(@container.after_filter_called == false) + assert(@container.after_filter_target_called == false) + assert(do_soap_call('AfterFiltered') == 5) + assert(@container.after_filter_called == true) + assert(@container.after_filter_target_called == true) + end + + def test_delegated_dispatching + @container = DelegatedController.new + assert(do_soap_call('Add', 50, 80) == 130) + assert(service.added == 130) + end + + def test_exception_marshaling + @container = DirectController.new + result = do_soap_call('Thrower') + exception = result.detail + assert(exception.cause.is_a?(RuntimeError)) + assert_equal("Hi, I'm a SOAP exception", exception.cause.message) + @container.web_service_exception_reporting = false + assert_raises(SoapTestError) do + do_soap_call('Thrower') + end + end + + def test_wsdl_generation + ensure_valid_wsdl_generation DelegatedController.new + ensure_valid_wsdl_generation DirectController.new + end + + def + + def test_wsdl_action + ensure_valid_wsdl_action DelegatedController.new + ensure_valid_wsdl_action DirectController.new + end + + protected + def service_name + @container.is_a?(DelegatedController) ? 'test_service' : 'api' + end + + def service + @container.web_service_object(:test_service) + end + + def do_soap_call(public_method_name, *args) + super(public_method_name, *args) do |test_request, test_response| + response = @container.process(test_request, test_response) + end + end + + def ensure_valid_wsdl_generation(controller) + wsdl = controller.generate_wsdl(controller, 'http://localhost:3000/test/', '/test') + ensure_valid_wsdl(wsdl) + end + + def ensure_valid_wsdl(wsdl) + definitions = WSDL::Parser.new.parse(wsdl) + assert(definitions.is_a?(WSDL::Definitions)) + definitions.bindings.each do |binding| + assert(binding.name.name.index(':').nil?) + end + definitions.services.each do |service| + service.ports.each do |port| + assert(port.name.name.index(':').nil?) + end + end + end + + def ensure_valid_wsdl_action(controller) + test_request = ActionController::TestRequest.new({ 'action' => 'wsdl' }) + test_request.env['REQUEST_METHOD'] = 'GET' + test_request.env['HTTP_HOST'] = 'localhost:3000' + test_response = ActionController::TestResponse.new + wsdl = controller.process(test_request, test_response).body + ensure_valid_wsdl(wsdl) + end +end -- cgit v1.2.3