actionservice 0.2.100 → 0.2.102

data/test/abstract_soap.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + '/abstract_unit'
+require 'soap/rpc/element'
+
+class AbstractSoapTest < Test::Unit::TestCase
+  def default_test
+  end
+
+  protected
+    def service_name
+      raise NotImplementedError
+    end
+
+    def do_soap_call(public_method_name, *args)
+      mapper = @container.class.soap_mapper
+      param_def = []
+      i = 1
+      args.each do |arg|
+        mapping = mapper.lookup(arg.class)
+        param_def << ["in", "param#{i}", mapping.registry_mapping]
+        i += 1
+      end
+      qname = XSD::QName.new('urn:ActionService', public_method_name)
+      request = SOAP::RPC::SOAPMethodRequest.new(qname, param_def)
+      soap_args = []
+      i = 1
+      args.each do |arg|
+        soap_args << ["param#{i}", SOAP::Mapping.obj2soap(arg)]
+        i += 1
+      end
+      request.set_param(soap_args)
+      header = SOAP::SOAPHeader.new
+      body = SOAP::SOAPBody.new(request)
+      envelope = SOAP::SOAPEnvelope.new(header, body)
+      raw_request = SOAP::Processor.marshal(envelope)
+      test_request = ActionController::TestRequest.new
+      test_request.request_parameters['action'] = service_name
+      test_request.env['REQUEST_METHOD'] = "POST"
+      test_request.env['HTTP_CONTENTTYPE'] = 'text/xml'
+      test_request.env['HTTP_SOAPACTION'] = "/soap/#{service_name}/#{public_method_name}"
+      test_request.env['RAW_POST_DATA'] = raw_request
+      test_response = ActionController::TestResponse.new
+      response = yield test_request, test_response
+      raw_body = response.respond_to?(:body) ? response.body : response.raw_body
+      envelope = SOAP::Processor.unmarshal(raw_body)
+      SOAP::Mapping.soap2obj(envelope.body.response) if envelope.body.response
+    end
+end

data/test/base_test.rb

@@ -1,51 +1,53 @@
 require File.dirname(__FILE__) + '/abstract_unit'
 
-class BaseTestService < ActionService::Base
-  def add(a, b)
+module BaseTest
+  class Service < ActionService::Base
+    def add(a, b)
+    end
+  
+    def void
+    end
+  
+    export :add, :expects => [Integer, Integer], :returns => [Integer]
+    export :void
+  end
+  
+  class BaseTest::UnmangledOrReportedService < ActionService::Base
+    export_name_mangling false
+    report_exceptions false
+  
+    def custom_name_casing
+    end
+  
+    export :custom_name_casing
   end
-
-  def void
-  end
-
-  export :add, :expects => [Integer, Integer], :returns => [Integer]
-  export :void
-end
-
-class UnmangledOrReportedService < ActionService::Base
-  export_name_mangling false
-  report_exceptions false
-
-  def custom_name_casing
-  end
-
-  export :custom_name_casing
 end
 
-class BaseTest < Test::Unit::TestCase
+class TC_Base < Test::Unit::TestCase
   def test_exports
-    assert(BaseTestService.has_export?(:add))
-    assert(BaseTestService.exports.keys.map{|x|x.to_s}.sort == ['add', 'void'])
+    assert(BaseTest::Service.has_export?(:add))
+    assert(BaseTest::Service.exports.keys.map{|x|x.to_s}.sort == ['add', 'void'])
   end
 
   def test_signatures
-    expects = BaseTestService.exports[:add][:expects]
+    expects = BaseTest::Service.exports[:add][:expects]
     assert(expects == [Integer, Integer])
-    returns = BaseTestService.exports[:add][:returns]
+    returns = BaseTest::Service.exports[:add][:returns]
     assert(returns == [Integer])
   end
 
   def test_options
-    assert(UnmangledOrReportedService.export_name_mangling == false)
-    assert(UnmangledOrReportedService.report_exceptions == false)
+    assert(BaseTest::UnmangledOrReportedService.export_name_mangling == false)
+    assert(BaseTest::UnmangledOrReportedService.report_exceptions == false)
   end
 
   def test_mangling
-    assert(BaseTestService.has_public_export?('Add'))
-    assert(BaseTestService.internal_export_name('Add') == :add)
-    assert(UnmangledOrReportedService.public_export_name(:custom_name_casing) == 'custom_name_casing')
+    assert(BaseTest::Service.has_public_export?('Add'))
+    assert(BaseTest::Service.internal_export_name('Add') == :add)
+    assert(BaseTest::UnmangledOrReportedService.public_export_name(:custom_name_casing) == 'custom_name_casing')
   end
 
   def test_missing_method
-    assert(BaseTestService.has_public_export?('NoSuchMethod') == false)
+    assert(BaseTest::Service.has_public_export?('NoSuchMethod') == false)
   end
 end

data/test/container_test.rb

@@ -1,46 +1,67 @@
 require File.dirname(__FILE__) + '/abstract_unit'
 
-class AbstractTestContainer
-end
-
-AbstractTestContainer.class_eval do
-  include ActionService::Container
-end
-
-$immediate_service = Object.new
-$deferred_service = Object.new
-
-class TestContainer < AbstractTestContainer
-  attr :flag
-  attr :previous_flag
-
-  def initialize
-    @previous_flag = nil
-    @flag = true
+module ContainerTest
+  class AbstractContainer
+  end
+  
+  AbstractContainer.class_eval do
+    include ActionService::Exporting
+    include ActionService::Container
+  end
+  
+  $immediate_service = Object.new
+  $deferred_service = Object.new
+  
+  class DelegateContainer < AbstractContainer
+    service_dispatching_mode :delegated
+  
+    attr :flag
+    attr :previous_flag
+  
+    def initialize
+      @previous_flag = nil
+      @flag = true
+    end
+  
+    service :immediate_service, $immediate_service
+    service(:deferred_service) { @previous_flag = @flag; @flag = false; $deferred_service }
+  end
+  
+  class DirectContainer < AbstractContainer
+    service_dispatching_mode :direct
+    export_name_mangling false
+  
+    def findNodes
+    end
+  
+    export :findNodes
   end
-
-  service :immediate_service, $immediate_service
-  service(:deferred_service) { @previous_flag = @flag; @flag = false; $deferred_service }
 end
 
-class ContainerTest < Test::Unit::TestCase
+class TC_Container < Test::Unit::TestCase
   def setup
-    @container = TestContainer.new
+    @delegate_container = ContainerTest::DelegateContainer.new
+    @direct_container = ContainerTest::DirectContainer.new
   end
 
   def test_registration
-    assert(TestContainer.has_service?(:immediate_service))
-    assert(TestContainer.has_service?(:deferred_service))
-    assert(!TestContainer.has_service?(:fake_service))
+    assert(ContainerTest::DelegateContainer.has_service?(:immediate_service))
+    assert(ContainerTest::DelegateContainer.has_service?(:deferred_service))
+    assert(!ContainerTest::DelegateContainer.has_service?(:fake_service))
   end
 
   def test_service_object
-    assert(@container.flag == true)
-    assert(@container.service_object(:immediate_service) == $immediate_service)
-    assert(@container.previous_flag.nil?)
-    assert(@container.flag == true)
-    assert(@container.service_object(:deferred_service) == $deferred_service)
-    assert(@container.previous_flag == true)
-    assert(@container.flag == false)
+    assert(@delegate_container.flag == true)
+    assert(@delegate_container.service_object(:immediate_service) == $immediate_service)
+    assert(@delegate_container.previous_flag.nil?)
+    assert(@delegate_container.flag == true)
+    assert(@delegate_container.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.has_export?(:findNodes))
+    assert(!ContainerTest::DirectContainer.has_export?(:fakeExport))
   end
 end

data/test/invocation_test.rb

@@ -1,105 +1,108 @@
 require File.dirname(__FILE__) + '/abstract_unit'
 
-class InvocationTestService < ActionService::Base
-  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
+module InvocationTest
+  class Service < ActionService::Base
+    attr_accessor :before_invoked
+    attr_accessor :after_invoked
+    attr_accessor :only_invoked
+    attr_accessor :invocation_result
   
-  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
-
-  def not_exported
-  end
-
-  export :add,             :expects => [Integer, Integer], :returns => [Integer]
-  export :transmogrify,    :expects_and_returns => [String]
-  export :fail_with_reason
-  export :fail_generic
-  export :no_before
-  export :no_after
-  export :only_one
-  export :only_two
-
-  before_invocation :intercept_before, :except => [:no_before]
-  after_invocation :intercept_after, :except => [:no_after]
-
-  before_invocation :intercept_only, :only => [:only_one, :only_two]
-
-  protected
-    def intercept_before(name, args)
-      @before_invoked = name
-      return [false, "permission denied"] if name == :fail_with_reason
-      return false if name == :fail_generic
+    def initialize
+      @before_invoked = nil
+      @after_invoked = nil
+      @only_invoked = nil
+      @invocation_result = nil
     end
-
-    def intercept_after(name, args, result)
-      @after_invoked = name
-      @invocation_result = result
+  
+    def add(a, b)
+      a + b
     end
-
-    def intercept_only(name, args)
-      raise "Interception error" unless name == :only_one || name == :only_two
-      @only_invoked = name
+  
+    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
+  
+    def not_exported
     end
+  
+    export :add,             :expects => [Integer, Integer], :returns => [Integer]
+    export :transmogrify,    :expects_and_returns => [String]
+    export :fail_with_reason
+    export :fail_generic
+    export :no_before
+    export :no_after
+    export :only_one
+    export :only_two
+  
+    before_invocation :intercept_before, :except => [:no_before]
+    after_invocation :intercept_after, :except => [:no_after]
+  
+    before_invocation :intercept_only, :only => [:only_one, :only_two]
+  
+    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 InvocationTest < Test::Unit::TestCase
+class TC_Invocation < Test::Unit::TestCase
+  include ActionService::Invocation
 
   def setup
-    @service = InvocationTestService.new
+    @service = InvocationTest::Service.new
   end
 
   def test_invocation
-    assert(@service.perform_invocation(:add, [5, 10]) == 15)
-    assert(@service.perform_invocation(:transmogrify, "hello") == "HELLO")
-    assert_raises(ActionService::Invocation::InvocationError) do
-      @service.perform_invocation(:not_exported)
+    assert(perform_invocation(:add, 5, 10) == 15)
+    assert(perform_invocation(:transmogrify, "hello") == "HELLO")
+    assert_raises(InvocationError) do
+      perform_invocation(:not_exported)
     end
-    assert_raises(ActionService::Invocation::InvocationError) do
-      @service.perform_invocation(:nonexistent_method_xyzzy)
+    assert_raises(InvocationError) do
+      perform_invocation(:nonexistent_method_xyzzy)
     end
   end
 
   def test_interceptor_registration
-    assert(InvocationTestService.before_invocation_interceptors.length == 2)
-    assert(InvocationTestService.after_invocation_interceptors.length == 1)
+    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?)
-    @service.perform_invocation(:add, [20, 50])
+    perform_invocation(:add, 20, 50)
     assert(@service.before_invoked == :add)
     assert(@service.after_invoked == :add)
     assert(@service.invocation_result == 70)
@@ -107,14 +110,14 @@ class InvocationTest < Test::Unit::TestCase
 
   def test_interception_canceling
     reason = nil
-    @service.perform_invocation(:fail_with_reason){|r| reason = r}
+    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
-    @service.perform_invocation(:fail_generic){|r| reason = r}
+    perform_invocation(:fail_generic){|r| reason = r}
     assert(@service.before_invoked == :fail_generic)
     assert(@service.after_invoked.nil?)
     assert(@service.invocation_result.nil?)
@@ -122,12 +125,12 @@ class InvocationTest < Test::Unit::TestCase
   end
 
   def test_interception_except_conditions
-    @service.perform_invocation(:no_before)
+    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
-    @service.perform_invocation(:no_after)
+    perform_invocation(:no_after)
     assert(@service.before_invoked == :no_after)
     assert(@service.after_invoked.nil?)
     assert(@service.invocation_result.nil?)
@@ -135,10 +138,18 @@ class InvocationTest < Test::Unit::TestCase
 
   def test_interception_only_conditions
     assert(@service.only_invoked.nil?)
-    @service.perform_invocation(:only_one)
+    perform_invocation(:only_one)
     assert(@service.only_invoked == :only_one)
     @service.only_invoked = nil
-    @service.perform_invocation(:only_two)
+    perform_invocation(:only_two)
     assert(@service.only_invoked == :only_two)
   end
+
+  private
+    def perform_invocation(method_name, *args, &block)
+      public_method_name = @service.class.public_export_name(method_name)
+      args ||= []
+      request = InvocationRequest.new(ConcreteInvocation, public_method_name, method_name, args)
+      @service.perform_invocation(request, &block)
+    end
 end

data/test/protocol_registry_test.rb

@@ -13,21 +13,20 @@ module Foo
   end
 
   class FooFullProtocol < AbstractProtocol
-    def request_supported?(request)
-      true
+    def self.create_protocol_request(klass, request)
+      protocol = FooFullProtocol.new klass
+      ActionService::Protocol::ProtocolRequest.new(protocol, '', '', '', '')
     end
   end
 
   class FooMinimalProtocol < AbstractProtocol
-    def request_supported?(request)
-      true
+    def self.create_protocol_request(klass, request)
+      protocol = FooMinimalProtocol.new klass
+      ActionService::Protocol::ProtocolRequest.new(protocol, '', '', '', '')
     end
   end
 
   class FooMinimalProtocolTwo < AbstractProtocol
-    def request_supported?(request)
-      false
-    end
   end
 end
 
@@ -39,16 +38,16 @@ class ProtocolRegistry
     header_and_body_protocols + body_only_protocols
   end
 
-  def request_protocol
+  def protocol_request
     probe_request_protocol(nil)
   end
 end
 
 
-class ProtocolRegistryTest < Test::Unit::TestCase
+class TC_ProtocolRegistry < Test::Unit::TestCase
   def test_registration
     registry = ProtocolRegistry.new
     assert(registry.all_protocols.length == 4)
-    assert(registry.request_protocol.is_a?(Foo::FooFullProtocol))
+    assert(registry.protocol_request.protocol.is_a?(Foo::FooFullProtocol))
   end
 end