actionwebservice 0.5.0

data/test/container_test.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/abstract_unit'
+
+module ContainerTest
+ 
+  $immediate_service = Object.new
+  $deferred_service = Object.new
+  
+  class DelegateContainer < ActionController::Base
+    web_service_dispatching_mode :delegated
+  
+    attr :flag
+    attr :previous_flag
+  
+    def initialize
+      @previous_flag = nil
+      @flag = true
+    end
+  
+    web_service :immediate_service, $immediate_service
+    web_service(:deferred_service) { @previous_flag = @flag; @flag = false; $deferred_service }
+  end
+  
+  class DirectContainer < ActionController::Base
+    web_service_dispatching_mode :direct
+   end
+end
+
+class TC_Container < Test::Unit::TestCase
+  def setup
+    @delegate_container = ContainerTest::DelegateContainer.new
+    @direct_container = ContainerTest::DirectContainer.new
+  end
+
+  def test_registration
+    assert(ContainerTest::DelegateContainer.has_web_service?(:immediate_service))
+    assert(ContainerTest::DelegateContainer.has_web_service?(:deferred_service))
+    assert(!ContainerTest::DelegateContainer.has_web_service?(:fake_service))
+  end
+
+  def test_service_object
+    assert(@delegate_container.flag == true)
+    assert(@delegate_container.web_service_object(:immediate_service) == $immediate_service)
+    assert(@delegate_container.previous_flag.nil?)
+    assert(@delegate_container.flag == true)
+    assert(@delegate_container.web_service_object(:deferred_service) == $deferred_service)
+    assert(@delegate_container.previous_flag == true)
+    assert(@delegate_container.flag == false)
+  end
+
+  def test_direct_container
+    assert(ContainerTest::DirectContainer.web_service_dispatching_mode == :direct)
+  end
+end

data/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

data/test/gencov

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+rcov -x '.*_test\.rb,rubygems,abstract_,/run' ./run

data/test/invocation_test.rb

@@ -0,0 +1,149 @@
+require File.dirname(__FILE__) + '/abstract_unit'
+
+module InvocationTest
+  class API < ActionWebService::API::Base
+    api_method :add,             :expects => [:int, :int], :returns => [:int]
+    api_method :transmogrify,    :expects_and_returns => [:string]
+    api_method :fail_with_reason
+    api_method :fail_generic
+    api_method :no_before
+    api_method :no_after
+    api_method :only_one
+    api_method :only_two
+  end
+
+  class Service < ActionWebService::Base
+    web_service_api API
+
+    before_invocation :intercept_before, :except => [:no_before]
+    after_invocation :intercept_after, :except => [:no_after]
+    before_invocation :intercept_only, :only => [:only_one, :only_two]
+
+    attr_accessor :before_invoked
+    attr_accessor :after_invoked
+    attr_accessor :only_invoked
+    attr_accessor :invocation_result
+  
+    def initialize
+      @before_invoked = nil
+      @after_invoked = nil
+      @only_invoked = nil
+      @invocation_result = nil
+    end
+  
+    def add(a, b)
+      a + b
+    end
+  
+    def transmogrify(str)
+      str.upcase
+    end
+    
+    def fail_with_reason
+    end
+  
+    def fail_generic
+    end
+  
+    def no_before
+      5
+    end
+  
+    def no_after
+    end
+  
+    def only_one
+    end
+  
+    def only_two
+    end
+  
+    protected
+      def intercept_before(name, args)
+        @before_invoked = name
+        return [false, "permission denied"] if name == :fail_with_reason
+        return false if name == :fail_generic
+      end
+  
+      def intercept_after(name, args, result)
+        @after_invoked = name
+        @invocation_result = result
+      end
+  
+      def intercept_only(name, args)
+        raise "Interception error" unless name == :only_one || name == :only_two
+        @only_invoked = name
+      end
+  end
+end
+
+class TC_Invocation < Test::Unit::TestCase
+  include ActionWebService::Invocation
+
+  def setup
+    @service = InvocationTest::Service.new
+  end
+
+  def test_invocation
+    assert(perform_invocation(:add, 5, 10) == 15)
+    assert(perform_invocation(:transmogrify, "hello") == "HELLO")
+    assert_raises(NoMethodError) do
+      perform_invocation(:nonexistent_method_xyzzy)
+    end
+  end
+
+  def test_interceptor_registration
+    assert(InvocationTest::Service.before_invocation_interceptors.length == 2)
+    assert(InvocationTest::Service.after_invocation_interceptors.length == 1)
+  end
+
+  def test_interception
+    assert(@service.before_invoked.nil? && @service.after_invoked.nil? && @service.only_invoked.nil? && @service.invocation_result.nil?)
+    perform_invocation(:add, 20, 50)
+    assert(@service.before_invoked == :add)
+    assert(@service.after_invoked == :add)
+    assert(@service.invocation_result == 70)
+  end
+
+  def test_interception_canceling
+    reason = nil
+    perform_invocation(:fail_with_reason){|r| reason = r}
+    assert(@service.before_invoked == :fail_with_reason)
+    assert(@service.after_invoked.nil?)
+    assert(@service.invocation_result.nil?)
+    assert(reason == "permission denied")
+    reason = true
+    @service.before_invoked = @service.after_invoked = @service.invocation_result = nil
+    perform_invocation(:fail_generic){|r| reason = r}
+    assert(@service.before_invoked == :fail_generic)
+    assert(@service.after_invoked.nil?)
+    assert(@service.invocation_result.nil?)
+    assert(reason == true)
+  end
+
+  def test_interception_except_conditions
+    perform_invocation(:no_before)
+    assert(@service.before_invoked.nil?)
+    assert(@service.after_invoked == :no_before)
+    assert(@service.invocation_result == 5)
+    @service.before_invoked = @service.after_invoked = @service.invocation_result = nil
+    perform_invocation(:no_after)
+    assert(@service.before_invoked == :no_after)
+    assert(@service.after_invoked.nil?)
+    assert(@service.invocation_result.nil?)
+  end
+
+  def test_interception_only_conditions
+    assert(@service.only_invoked.nil?)
+    perform_invocation(:only_one)
+    assert(@service.only_invoked == :only_one)
+    @service.only_invoked = nil
+    perform_invocation(:only_two)
+    assert(@service.only_invoked == :only_two)
+  end
+
+  private
+    def perform_invocation(method_name, *args, &block)
+      @service.perform_invocation(method_name, args, &block)
+    end
+end

data/test/protocol_registry_test.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/abstract_unit'
+
+
+module Foo
+  include ActionWebService::Protocol
+
+  def self.append_features(base)
+    super
+    base.register_protocol(BodyOnly, FooMinimalProtocol)
+    base.register_protocol(HeaderAndBody, FooMinimalProtocolTwo)
+    base.register_protocol(HeaderAndBody, FooMinimalProtocolTwo)
+    base.register_protocol(HeaderAndBody, FooFullProtocol)
+  end
+
+  class FooFullProtocol < AbstractProtocol
+    def self.create_protocol_request(klass, request)
+      protocol = FooFullProtocol.new klass
+      ActionWebService::Protocol::ProtocolRequest.new(protocol, '', '', '', '')
+    end
+  end
+
+  class FooMinimalProtocol < AbstractProtocol
+    def self.create_protocol_request(klass, request)
+      protocol = FooMinimalProtocol.new klass
+      ActionWebService::Protocol::ProtocolRequest.new(protocol, '', '', '', '')
+    end
+  end
+
+  class FooMinimalProtocolTwo < AbstractProtocol
+  end
+end
+
+class ProtocolRegistry
+  include ActionWebService::Protocol::Registry
+  include Foo
+
+  def all_protocols
+    header_and_body_protocols + body_only_protocols
+  end
+
+  def protocol_request
+    probe_request_protocol(nil)
+  end
+end
+
+
+class TC_ProtocolRegistry < Test::Unit::TestCase
+  def test_registration
+    registry = ProtocolRegistry.new
+    assert(registry.all_protocols.length == 4)
+    assert(registry.protocol_request.protocol.is_a?(Foo::FooFullProtocol))
+  end
+end