actionservice 0.2.99

data/test/abstract_unit.rb

@@ -0,0 +1,9 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'test/unit'
+require 'action_service'
+require 'action_controller'
+require 'action_controller/test_process'
+
+ActionController::Base.logger = nil
+ActionController::Base.ignore_missing_templates = true

data/test/base_test.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + '/abstract_unit'
+
+class BaseTestService < ActionService::Base
+  def add(a, b)
+  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
+  def test_exports
+    assert(BaseTestService.has_export?(:add))
+    assert(BaseTestService.exports.keys.map{|x|x.to_s}.sort == ['add', 'void'])
+  end
+
+  def test_signatures
+    expects = BaseTestService.exports[:add][:expects]
+    assert(expects == [Integer, Integer])
+    returns = BaseTestService.exports[:add][:returns]
+    assert(returns == [Integer])
+  end
+
+  def test_options
+    assert(UnmangledOrReportedService.export_name_mangling == false)
+    assert(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')
+  end
+end

data/test/container_test.rb

@@ -0,0 +1,29 @@
+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
+  service :immediate_service, $immediate_service
+  service(:deferred_service) { $deferred_service }
+end
+
+class ContainerTest < Test::Unit::TestCase
+  def test_registration
+    assert(TestContainer.has_service?(:immediate_service))
+    assert(TestContainer.has_service?(:deferred_service))
+    assert(!TestContainer.has_service?(:fake_service))
+  end
+
+  def test_service_object
+    assert(TestContainer.service_object(:immediate_service) == $immediate_service)
+    assert(TestContainer.service_object(:deferred_service) == $deferred_service)
+  end
+end

data/test/invocation_test.rb

@@ -0,0 +1,144 @@
+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
+  
+  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
+
+class InvocationTest < Test::Unit::TestCase
+
+  def setup
+    @service = InvocationTestService.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)
+    end
+    assert_raises(ActionService::Invocation::InvocationError) do
+      @service.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)
+  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])
+    assert(@service.before_invoked == :add)
+    assert(@service.after_invoked == :add)
+    assert(@service.invocation_result == 70)
+  end
+
+  def test_interception_canceling
+    reason = nil
+    @service.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}
+    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
+    @service.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)
+    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?)
+    @service.perform_invocation(:only_one)
+    assert(@service.only_invoked == :only_one)
+    @service.only_invoked = nil
+    @service.perform_invocation(:only_two)
+    assert(@service.only_invoked == :only_two)
+  end
+end

data/test/protocol_registry_test.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + '/abstract_unit'
+
+
+module Foo
+  include ActionService::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 request_supported?(request)
+      true
+    end
+  end
+
+  class FooMinimalProtocol < AbstractProtocol
+    def request_supported?(request)
+      true
+    end
+  end
+
+  class FooMinimalProtocolTwo < AbstractProtocol
+    def request_supported?(request)
+      false
+    end
+  end
+end
+
+class ProtocolRegistry
+  include ActionService::Protocol::Registry
+  include Foo
+
+  def all_protocols
+    header_and_body_protocols + body_only_protocols
+  end
+
+  def request_protocol
+    probe_request_protocol(nil)
+  end
+end
+
+
+class ProtocolRegistryTest < Test::Unit::TestCase
+  def test_registration
+    registry = ProtocolRegistry.new
+    assert(registry.all_protocols.length == 4)
+    assert(registry.request_protocol.is_a?(Foo::FooFullProtocol))
+  end
+end

data/test/protocol_soap_test.rb

@@ -0,0 +1,94 @@
+require File.dirname(__FILE__) + '/abstract_unit'
+require 'soap/rpc/element'
+
+class SoapService < ActionService::Base
+  attr :int
+  attr :string
+
+  def initialize
+    @int = 20
+    @string = "wrong string value"
+  end
+
+  def some_method(int, string)
+    @int = int
+    @string = string
+    true
+  end
+
+  export :some_method, :expects => [Integer, String], :returns => [TrueClass]
+end
+
+class SoapContainer
+  include ActionService::Container
+  include ActionService::Protocol::Registry
+  include ActionService::Protocol::Soap
+
+  def request_protocol(request)
+    probe_request_protocol(request)
+  end
+
+  def dispatch_request(protocol, info)
+    dispatch_service_invocation_request(protocol, info)
+  end
+
+  wsdl_service_name 'Test'
+  service :soap_service, SoapService.new
+end
+
+class ProtocolSoapTest < Test::Unit::TestCase
+  def setup
+    @container = SoapContainer.new
+  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(test_request)
+    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 = SoapContainer.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)
+  end
+
+  def test_service_name
+    assert(SoapContainer.soap_mapper.custom_namespace == 'urn:Test')
+  end
+end

data/test/router_action_controller_test.rb

@@ -0,0 +1,98 @@
+require File.dirname(__FILE__) + '/abstract_unit'
+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
+  end
+  
+  def add(a, b)
+    @added = a + b
+  end
+
+  def find_people
+    raise "Hi, I'm a SOAP error"
+  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
+  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)
+  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))
+  end
+end