actionservice 0.2.100 → 0.2.102

data/test/protocol_soap_test.rb

@@ -1,181 +1,147 @@
-require File.dirname(__FILE__) + '/abstract_unit'
-require 'soap/rpc/element'
-
-class SoapService < ActionService::Base
-  attr :int
-  attr :string
-  attr :values
-  attr :default_args
-
-  def initialize
-    @int = 20
-    @string = "wrong string value"
-    @default_args = nil
+require File.dirname(__FILE__) + '/abstract_soap'
+
+module ProtocolSoapTest
+  class Person < ActionService::Struct
+    member :id, Integer
+    member :names, [String]
+    member :lastname, String
+    member :deleted, TrueClass
+
+    def ==(other)
+      id == other.id && names == other.names && lastname == other.lastname && deleted == other.deleted
+    end
   end
 
-  def some_method(int, string)
-    @int = int
-    @string = string
-    true
+  class Service < ActionService::Base
+    attr :int
+    attr :string
+    attr :array
+    attr :values
+    attr :person
+    attr :default_args
+  
+    def initialize
+      @int = 20
+      @string = "wrong string value"
+      @default_args = nil
+    end
+  
+    def argument_passing(int, string, array)
+      @int = int
+      @string = string
+      @array = array
+      true
+    end
+  
+    def array_returner
+      @values = [1, 2, 3]
+    end
+  
+    def nil_returner
+      nil
+    end
+  
+    def struct_array_returner
+      @person = Person.new
+      @person.id = 5
+      @person.names = ["one", "two"]
+      @person.lastname = "test"
+      @person.deleted = false
+      [@person]
+    end
+  
+    def exception_thrower
+      raise "Hi, I'm a SOAP error"
+    end
+  
+    def default(*args)
+      @default_args = args
+      nil
+    end
+  
+    export :argument_passing, :expects => [Integer, String, [Integer]], :returns => [TrueClass]
+    export :array_returner, :returns => [[Integer]]
+    export :nil_returner
+    export :struct_array_returner, :returns => [[Person]]
+    export :exception_thrower
+  
+    default_export :default
   end
-
-  def array_returner
-    @values = [1, 2, 3]
-  end
-
-  def default(*args)
-    @default_args = args
-    nil
+  
+  class Container
+    include ActionService::Container
+    include ActionService::Protocol::Registry
+    include ActionService::Protocol::Soap
+  
+    def protocol_request(request)
+      probe_request_protocol(request)
+    end
+  
+    def dispatch_request(protocol_request)
+      dispatch_service_request(protocol_request)
+    end
+  
+    wsdl_service_name 'Test'
+    service_dispatching_mode :delegated
+    service :protocol_soap_service, Service.new
   end
-
-  export :some_method, :expects => [Integer, String], :returns => [TrueClass]
-  export :array_returner, :returns => [[Integer]]
-
-  default_export :default
 end
 
-class SoapContainer
-  include ActionService::Container
-  include ActionService::Protocol::Registry
-  include ActionService::Protocol::Soap
-
-  def request_protocol(request)
-    probe_request_protocol(request)
+class TC_ProtocolSoap < AbstractSoapTest
+  def setup
+    @container = ProtocolSoapTest::Container.new
   end
 
-  def dispatch_request(protocol, info)
-    dispatch_service_invocation_request(protocol, info)
+  def test_argument_passing
+    assert(do_soap_call('ArgumentPassing', 5, "test string", [true, false]) == true)
+    assert(service.int == 5)
+    assert(service.string == "test string")
+    assert(service.array == [true, false])
   end
 
-  wsdl_service_name 'Test'
-  service :soap_service, SoapService.new
-end
-
-class ProtocolSoapTest < Test::Unit::TestCase
-  def setup
-    @container = SoapContainer.new
+  def test_array_returner
+    assert(do_soap_call('ArrayReturner') == [1, 2, 3])
+    assert(service.values == [1, 2, 3])
   end
 
-  def test_soap_request_dispatching
-    service_name = 'soap_service'
-    public_method_name = 'SomeMethod'
-    int_value = 5
-    string_value = "test string"
-    qname = XSD::QName.new('urn:ActionService', public_method_name)
-    param_def = [
-      ['in', 'param1', [SOAP::SOAPInt]],
-      ['in', 'param2', [SOAP::SOAPString]],
-    ]
-    request = SOAP::RPC::SOAPMethodRequest.new(qname, param_def)
-    request.set_param([
-      ['param1', SOAP::Mapping.obj2soap(int_value)],
-      ['param2', SOAP::Mapping.obj2soap(string_value)]
-    ])
-    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
-    protocol = @container.request_protocol(test_request)
-    assert(protocol.is_a?(ActionService::Protocol::Soap::SoapProtocol))
-    request_info = protocol.request_info
-    assert(request_info.service_name == service_name)
-    assert(request_info.public_method_name == public_method_name)
-    method_name = SoapService.internal_export_name(public_method_name)
-    export_info = SoapService.exports[method_name]
-    params = protocol.unmarshal_request(request_info, export_info)
-    assert(params.length == 2)
-    assert(params == [int_value, string_value])
-    response = @container.dispatch_request(protocol, request_info)
-    service = @container.service_object(:soap_service)
-    assert(service.int == int_value)
-    assert(service.string == string_value)
-    raw_response = response.raw_body
-    envelope = SOAP::Processor.unmarshal(raw_response)
-    assert(envelope.is_a?(SOAP::SOAPEnvelope))
-    resp = envelope.body.response
-    assert(resp.is_a?(SOAP::SOAPBoolean))
-    assert(resp.data == true)
+  def test_nil_returner
+    assert(do_soap_call('NilReturner') == nil)
   end
 
-  def test_service_name
-    assert(SoapContainer.soap_mapper.custom_namespace == 'urn:Test')
+  def test_struct_array_returner
+    assert(do_soap_call('StructArrayReturner') == [service.person])
   end
 
-  def test_array_returning
-    service_name = 'soap_service'
-    public_method_name = 'ArrayReturner'
-    qname = XSD::QName.new('urn:ActionService', public_method_name)
-    request = SOAP::RPC::SOAPMethodRequest.new(qname)
-    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
-    protocol = @container.request_protocol(test_request)
-    assert(protocol.is_a?(ActionService::Protocol::Soap::SoapProtocol))
-    request_info = protocol.request_info
-    method_name = SoapService.internal_export_name(public_method_name)
-    export_info = SoapService.exports[method_name]
-    response = @container.dispatch_request(protocol, request_info)
-    service = @container.service_object(:soap_service)
-    assert(service.values == [1, 2, 3])
-    raw_response = response.raw_body
-    envelope = SOAP::Processor.unmarshal(raw_response)
-    assert(envelope.is_a?(SOAP::SOAPEnvelope))
-    resp = envelope.body.response
-    assert(resp.is_a?(SOAP::SOAPArray))
-    assert(SOAP::Mapping.soap2obj(resp) == [1, 2, 3])
+  def test_exception_thrower
+    assert_raises(RuntimeError) do
+      do_soap_call('ExceptionThrower')
+    end
+    #assert(obj.detail.is_a?(SOAP::Mapping::SOAPException))
+    #assert(obj.faultstring == "Hi, I'm a SOAP error")
   end
 
   def test_default_export
-    service_name = 'soap_service'
-    public_method_name = 'NonExistentMethodName'
-    qname = XSD::QName.new('urn:ActionService', public_method_name)
-    int_value = 50
-    bool_value = false
-    param_def = [
-      ['in', 'param1', [SOAP::SOAPInt]],
-      ['in', 'param2', [SOAP::SOAPBoolean]],
-    ]
-    request = SOAP::RPC::SOAPMethodRequest.new(qname, param_def)
-    request.set_param([
-      ['param1', SOAP::Mapping.obj2soap(int_value)],
-      ['param2', SOAP::Mapping.obj2soap(bool_value)]
-    ])
-    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
-    protocol = @container.request_protocol(test_request)
-    assert(protocol.is_a?(ActionService::Protocol::Soap::SoapProtocol))
-    request_info = protocol.request_info
-    method_name = SoapService.internal_export_name(public_method_name)
-    export_info = SoapService.exports[method_name]
-    service = @container.service_object(:soap_service)
-    assert(service.default_args.nil?)
-    response = @container.dispatch_request(protocol, request_info)
-    raw_response = response.raw_body
-    envelope = SOAP::Processor.unmarshal(raw_response)
-    assert(envelope.is_a?(SOAP::SOAPEnvelope))
-    resp = envelope.body.response
-    assert(resp.is_a?(SOAP::SOAPNil))
+    assert(do_soap_call('NonExistentMethodName', 50, false).nil?)
     assert(service.default_args == [50, false])
   end
+
+  def test_service_name_setting
+    assert(ProtocolSoapTest::Container.soap_mapper.custom_namespace == 'urn:Test')
+  end
+
+  protected
+    def service_name
+      'protocol_soap_service'
+    end
+
+    def service
+      @container.service_object(:protocol_soap_service)
+    end
+
+    def do_soap_call(public_method_name, *args)
+      super(public_method_name, *args) do |test_request, test_response|
+        protocol_request = @container.protocol_request(test_request)
+        @container.dispatch_request(protocol_request)
+      end
+    end
 end

data/test/protocol_xmlrpc_test.rb

@@ -17,69 +17,72 @@ module XMLRPC
   end
 end
 
-class XmlRpcService < ActionService::Base
-  attr :result
-  attr :hashvalue
-  attr :default_args
-
-  def initialize
-    @result = nil
-    @hashvalue = nil
-    @default_args = nil
-  end
-
-  def add(a, b)
-    @result = a + b
-  end
-
-  def something_hash(hash)
-    @hashvalue = hash
-  end
-
-  def array_returner
-    [1, 2, 3]
-  end
+module ProtocolXmlRpcTest
+  class Service < ActionService::Base
+    attr :result
+    attr :hashvalue
+    attr :default_args
   
-  def hash_returner
-    {'name' => 1, 'value' => 2}
-  end
-
-  def default(*args)
-    @default_args = args
-    nil
-  end
-
-  export :add,            :expects => [Integer, Integer], :returns => [Integer]
-  export :hash_returner,  :returns => [Hash]
-  export :array_returner, :returns => [[Integer]]
-  export :something_hash, :expects => [Hash]
-
-  default_export :default
-end
-
-$service = XmlRpcService.new
-
-class XmlRpcContainer
-  include ActionService::Container
-  include ActionService::Protocol::Registry
-  include ActionService::Protocol::Soap
-  include ActionService::Protocol::XmlRpc
-
-  def request_protocol(request)
-    probe_request_protocol(request)
+    def initialize
+      @result = nil
+      @hashvalue = nil
+      @default_args = nil
+    end
+  
+    def add(a, b)
+      @result = a + b
+    end
+  
+    def something_hash(hash)
+      @hashvalue = hash
+    end
+  
+    def array_returner
+      [1, 2, 3]
+    end
+    
+    def hash_returner
+      {'name' => 1, 'value' => 2}
+    end
+  
+    def default(*args)
+      @default_args = args
+      nil
+    end
+  
+    export :add,            :expects => [Integer, Integer], :returns => [Integer]
+    export :hash_returner,  :returns => [Hash]
+    export :array_returner, :returns => [[Integer]]
+    export :something_hash, :expects => [Hash]
+  
+    default_export :default
   end
-
-  def dispatch_request(protocol, info)
-    dispatch_service_invocation_request(protocol, info)
+  
+  $service = Service.new
+  
+  class Container
+    include ActionService::Container
+    include ActionService::Protocol::Registry
+    include ActionService::Protocol::Soap
+    include ActionService::Protocol::XmlRpc
+  
+    def protocol_request(request)
+      probe_request_protocol(request)
+    end
+  
+    def dispatch_request(protocol_request)
+      dispatch_service_request(protocol_request)
+    end
+  
+    service :xmlrpc, $service
+    service_dispatching_mode :delegated
   end
-
-  service :xmlrpc, $service
 end
 
-class ProtocolXmlRpcTest < Test::Unit::TestCase
+class TC_ProtocolXmlRpc < Test::Unit::TestCase
   def setup
     @helper = XMLRPC::XmlRpcHelper.new
-    @container = XmlRpcContainer.new
+    @container = ProtocolXmlRpcTest::Container.new
   end
 
   def test_xmlrpc_request_dispatching
@@ -123,8 +126,8 @@ class ProtocolXmlRpcTest < Test::Unit::TestCase
       test_request.env['REQUEST_METHOD'] = "POST"
       test_request.env['HTTP_CONTENTTYPE'] = 'text/xml'
       test_request.env['RAW_POST_DATA'] = raw_request
-      protocol = @container.request_protocol(test_request)
-      response = @container.dispatch_request(protocol, protocol.request_info)
+      protocol_request = @container.protocol_request(test_request)
+      response = @container.dispatch_request(protocol_request)
       @helper.parse_response(response.raw_body)
     end
 end

data/test/router_action_controller_test.rb

@@ -1,98 +1,67 @@
-require File.dirname(__FILE__) + '/abstract_unit'
+require File.dirname(__FILE__) + '/abstract_soap'
 require 'wsdl/parser'
 
-class ActionTestPerson < ActionService::Struct
-  member :id, Integer
-  member :names, [String]
-  member :lastname, String
-  member :deleted, TrueClass
-end
-
-class ActionTestService < ActionService::Base
-  attr :added
-
-  def initialize
-    @added = nil
+module RouterActionControllerTest
+  class Service < ActionService::Base
+    attr :added
+  
+    def add(a, b)
+      @added = a + b
+    end
+  
+    export :add, :expects => [Integer, Integer], :returns => [Integer]
   end
   
-  def add(a, b)
-    @added = a + b
+  class DelegatedController < ActionController::Base
+    service_dispatching_mode :delegated
+  
+    service(:test_service) { @service ||= Service.new; @service }
   end
+  
+  class DirectController < ActionController::Base
+    service_dispatching_mode :direct
 
-  def find_people
-    raise "Hi, I'm a SOAP error"
+    attr :added
+  
+    def add
+      @added = @params['a'] + @params['b']
+    end
+  
+    export :add, :expects => [{:a=>Integer}, {:b=>Integer}], :returns => [Integer]
   end
-
-  export :add, :expects => [Integer, Integer], :returns => [Integer]
-  export :find_people, :returns => [[ActionTestPerson]]
-end
-
-class ActionTestController < ActionController::Base
-  wsdl_service_name 'ActionTest'
-  service(:test_service) { ActionTestService.new }
 end
 
-class RouterActionControllerTest < Test::Unit::TestCase
-  def setup
-    @controller = ActionTestController.new
+class TC_RouterActionController < AbstractSoapTest
+  def test_direct_routing
+    @container = RouterActionControllerTest::DirectController.new
+    assert(do_soap_call('Add', 20, 50) == 70)
+    assert(@container.added == 70)
   end
 
-  def test_standard_invocation
-    service_name = 'test_service'
-    public_method_name = 'Add'
-    a = 20
-    b = 50
-    qname = XSD::QName.new('urn:ActionTest', public_method_name)
-    param_def = [
-      ['in', 'param1', [SOAP::SOAPInt]],
-      ['in', 'param2', [SOAP::SOAPString]],
-    ]
-    request = SOAP::RPC::SOAPMethodRequest.new(qname, param_def)
-    request.set_param([
-      ['param1', SOAP::Mapping.obj2soap(a)],
-      ['param2', SOAP::Mapping.obj2soap(b)]
-    ])
-    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_CONTENT_TYPE'] = '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
-    @controller.process(test_request, test_response)
-    raw_response = test_response.body
-    envelope = SOAP::Processor.unmarshal(raw_response)
-    assert(envelope.is_a?(SOAP::SOAPEnvelope))
-    resp = envelope.body.response
-    assert(resp.is_a?(SOAP::SOAPInt))
-    assert(resp.data == 70)
+  def test_direct_entrypoint
+    @container = RouterActionControllerTest::DirectController.new
+    assert(@container.respond_to?(:api))
   end
 
-  def test_error_invocation
-    service_name = 'test_service'
-    public_method_name = 'FindPeople'
-    qname = XSD::QName.new('urn:ActionTest', public_method_name)
-    request = SOAP::RPC::SOAPMethodRequest.new(qname)
-    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_CONTENT_TYPE'] = '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
-    @controller.process(test_request, test_response)
-    raw_response = test_response.body
-    envelope = SOAP::Processor.unmarshal(raw_response)
-    assert(envelope.is_a?(SOAP::SOAPEnvelope))
-    resp = envelope.body.response
-    assert(resp.is_a?(SOAP::SOAPFault))
+  def test_delegated_routing
+    @container = RouterActionControllerTest::DelegatedController.new
+    assert(do_soap_call('Add', 50, 80) == 130)
+    assert(service.added == 130)
   end
+
+
+  protected
+    def service_name
+      @container.is_a?(RouterActionControllerTest::DelegatedController) ? 'test_service' : 'api'
+    end
+
+    def service
+      @container.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
 end

data/test/router_wsdl_test.rb

@@ -1,37 +1,43 @@
 require File.dirname(__FILE__) + '/abstract_unit'
 require 'wsdl/parser'
 
-class TestPerson < ActionService::Struct
-  member :id, Integer
-  member :names, [String]
-  member :lastname, String
-  member :deleted, TrueClass
-end
-
-class WsdlTestService < ActionService::Base
-  def add(a, b)
-    a + b
+module RouterWsdlTest
+  class Person < ActionService::Struct
+    member :id, Integer
+    member :names, [String]
+    member :lastname, String
+    member :deleted, TrueClass
   end
-
-  def find_people
-    []
+  
+  class Service < ActionService::Base
+    def add(a, b)
+      a + b
+    end
+  
+    def find_people
+      []
+    end
+  
+    def nil_returner
+    end
+  
+    export :add, :expects => [{:a=>Integer}, {:b=>Integer}], :returns => [Integer]
+    export :find_people, :returns => [[Person]]
+    export :nil_returner
   end
+  
+  class WsdlController < ActionController::Base
+    service(:test_service) { Service.new }
 
-  def nil_returner
+    def generate_wsdl(container, uri, soap_action_base)
+      to_wsdl(container, uri, soap_action_base)
+    end
   end
-
-  export :add, :expects => [Integer, Integer], :returns => [Integer]
-  export :find_people, :returns => [[TestPerson]]
-  export :nil_returner
-end
-
-class WsdlController < ActionController::Base
-  service(:test_service) { WsdlTestService.new }
 end
 
-class RouterWsdlTest < Test::Unit::TestCase
+class TC_RouterWsdl < Test::Unit::TestCase
   def test_wsdl_generation
-    wsdl = WsdlController.to_wsdl(WsdlController.new, 'http://localhost:3000/test/', '/test')
+    wsdl = RouterWsdlTest::WsdlController.new.generate_wsdl(RouterWsdlTest::WsdlController.new, 'http://localhost:3000/test/', '/test')
     assert(WSDL::Parser.new.parse(wsdl).is_a?(WSDL::Definitions))
   end
 
@@ -39,7 +45,7 @@ class RouterWsdlTest < Test::Unit::TestCase
     test_request = ActionController::TestRequest.new({ 'action' => 'wsdl' })
     test_request.env['REQUEST_METHOD'] = 'GET'
     test_request.env['HTTP_HOST'] = 'localhost:3000'
-    controller = WsdlController.new
+    controller = RouterWsdlTest::WsdlController.new
     test_response = ActionController::TestResponse.new
     controller.process(test_request, test_response)
     assert(WSDL::Parser.new.parse(test_response.body).is_a?(WSDL::Definitions))