actionwebservice 0.5.0 → 0.6.0

data/lib/action_web_service/vendor/ws/types.rb

@@ -0,0 +1,162 @@
+require 'time'
+require 'date'
+
+module WS
+  module BaseTypes
+    class << self
+      def type_name_to_class(name)
+        case canonical_type_name(name)
+        when :int
+          Integer
+        when :string
+          String
+        when :bool
+          TrueClass
+        when :float
+          Float
+        when :time
+          Time
+        when :date
+          Date
+        end
+      end
+
+      def class_to_type_name(klass)
+        if WS.derived_from?(Integer, klass) || WS.derived_from?(Fixnum, klass) || WS.derived_from?(Bignum, klass)
+          :int
+        elsif klass == String
+          :string
+        elsif klass == TrueClass || klass == FalseClass
+          :bool
+        elsif WS.derived_from?(Float, klass) || WS.derived_from?(Precision, klass) || WS.derived_from?(Numeric, klass)
+          :float
+        elsif klass == Time || klass == DateTime
+          :time
+        elsif klass == Date
+          :date
+        else
+          raise(TypeError, "#{klass} is not a valid base type")
+        end
+      end
+
+      def base_type?(klass)
+        !(canonical_type_class(klass) rescue nil).nil?
+      end
+
+      def canonical_type_class(klass)
+        type_name_to_class(class_to_type_name(klass))
+      end
+
+      def canonical_param_type_class(spec)
+        klass = spec.is_a?(Hash) ? spec.values[0] : spec
+        array_element_class = klass.is_a?(Array) ? klass[0] : nil
+        klass = array_element_class ? array_element_class : klass
+        klass = type_name_to_class(klass) if klass.is_a?(Symbol) || klass.is_a?(String)
+        base_class = canonical_type_class(klass) rescue nil
+        klass = base_class unless base_class.nil?
+        array_element_class ? [klass] : klass
+      end
+
+      def canonical_param_type_spec(spec)
+        klass = canonical_param_type_class(spec)
+        spec.is_a?(Hash) ? {spec.keys[0]=>klass} : klass
+      end
+
+      def canonical_type_name(name)
+        name = name.to_sym
+        case name
+          when :int, :integer, :fixnum, :bignum
+            :int
+          when :string, :base64
+            :string
+          when :bool, :boolean
+            :bool
+          when :float, :double
+            :float
+          when :time, :datetime, :timestamp
+            :time
+          when :date
+            :date
+          else
+            raise(TypeError, "#{name} is not a valid base type")
+        end
+      end
+    end
+  end
+
+  class Param
+    attr_accessor :value
+    attr_accessor :info
+
+    def initialize(value, info)
+      @value = value
+      @info = info
+    end
+  end
+
+  class ParamInfo
+    attr_accessor :name
+    attr_accessor :type
+    attr_accessor :data
+
+    def initialize(name, type, data=nil)
+      @name = name
+      @type = type
+      @data = data
+    end
+
+    def self.create(spec, data, index=nil)
+      name = spec.is_a?(Hash) ? spec.keys[0].to_s : (index ? "param#{index}" : nil)
+      type = BaseTypes.canonical_param_type_class(spec)
+      ParamInfo.new(name, type, data)
+    end
+  end
+
+  class BaseTypeCaster
+    def initialize
+      @handlers = {}
+      install_handlers
+    end
+
+    def cast(value, klass)
+      type_class = BaseTypes.canonical_type_class(klass)
+      return value unless type_class
+      @handlers[type_class].call(value, type_class)
+    end
+
+    protected
+      def install_handlers
+        handler = method(:cast_base_type)
+        [:int, :string, :bool, :float, :time, :date].each do |name|
+          type = BaseTypes.type_name_to_class(name)
+          @handlers[type] = handler
+        end
+        @handlers[Fixnum] = handler
+      end
+
+      def cast_base_type(value, type_class)
+        desired_class = BaseTypes.canonical_type_class(type_class)
+        value_class = BaseTypes.canonical_type_class(value.class)
+        return value if desired_class == value_class
+        desired_name = BaseTypes.class_to_type_name(desired_class)
+        case desired_name
+        when :int
+          Integer(value)
+        when :string
+          value.to_s
+        when :bool
+          return false if value.nil?
+          value = value.to_s
+          return true if value == 'true'
+          return false if value == 'false'
+          raise(TypeError, "can't convert #{value} to boolean")
+        when :float
+          Float(value)
+        when :time
+          Time.parse(value.to_s)
+        when :date
+          Date.parse(value.to_s)
+        end
+      end
+  end
+end

data/test/abstract_client.rb

@@ -20,6 +20,7 @@ module ClientTest
     api_method :struct_pass,    :expects => [[Person]], :returns => [:bool]
     api_method :client_container, :returns => [:int]
     api_method :named_parameters, :expects => [{:key=>:string}, {:id=>:int}]
+    api_method :thrower
   end
 
   class NullLogOut
@@ -29,11 +30,11 @@ module ClientTest
   class Container < ActionController::Base
     web_service_api API
 
-    attr :value_void
-    attr :value_normal
-    attr :value_array_return
-    attr :value_struct_pass
-    attr :value_named_parameters
+    attr_accessor :value_void
+    attr_accessor :value_normal
+    attr_accessor :value_array_return
+    attr_accessor :value_struct_pass
+    attr_accessor :value_named_parameters
 
     def initialize
       @session = @assigns = {}
@@ -73,12 +74,8 @@ module ClientTest
       @value_named_parameters = @method_params
     end
 
-    def protocol_request(request)
-      probe_request_protocol(request)
-    end
-
-    def dispatch_request(protocol_request)
-      dispatch_protocol_request(protocol_request)
+    def thrower
+      raise "Hi"
     end
   end
 

data/test/abstract_dispatcher.rb

@@ -0,0 +1,370 @@
+require File.dirname(__FILE__) + '/abstract_unit'
+
+module DispatcherTest
+  class Node < ActiveRecord::Base
+    def initialize(*args)
+      super(*args)
+      @new_record = false
+    end
+
+    class << self
+      def name
+        "DispatcherTest::Node"
+      end
+
+      def columns(*args)
+        [
+          ActiveRecord::ConnectionAdapters::Column.new('id', 0, 'int'),
+          ActiveRecord::ConnectionAdapters::Column.new('name', nil, 'string'),
+          ActiveRecord::ConnectionAdapters::Column.new('description', nil, 'string'),
+        ]
+      end
+
+      def connection
+        self
+      end
+    end
+  end
+
+  class Person < ActionWebService::Struct
+    member :id, :int
+    member :name, :string
+  end
+
+  class API < ActionWebService::API::Base
+    api_method :add, :expects => [:int, :int], :returns => [:int]
+    api_method :interceptee
+    api_method :struct_return, :returns => [[Node]]
+    api_method :void
+  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 :struct_return, :returns => [[Node]]
+    api_method :base_struct_return, :returns => [[Person]]
+    api_method :thrower
+    api_method :void
+  end
+
+  class VirtualAPI < ActionWebService::API::Base
+    default_api_method :fallback
+  end
+ 
+  class Service < ActionWebService::Base
+    web_service_api API
+
+    before_invocation :do_intercept, :only => [:interceptee]
+
+    attr :added
+    attr :intercepted
+    attr :void_called
+
+    def initialize
+      @void_called = false
+    end
+
+    def add(a, b)
+      @added = a + b
+    end
+
+    def interceptee
+      @intercepted = false
+    end
+
+    def struct_return
+      n1 = Node.new('id' => 1, 'name' => 'node1', 'description' => 'Node 1')
+      n2 = Node.new('id' => 2, 'name' => 'node2', 'description' => 'Node 2')
+      [n1, n2]
+    end
+
+    def void(*args)
+      @void_called = args
+    end
+
+    def do_intercept(name, args)
+      [false, "permission denied"]
+    end
+  end
+
+  class MTAPI < ActionWebService::API::Base
+    inflect_names false
+    api_method :getCategories, :returns => [[:string]]
+  end
+
+  class BloggerAPI < ActionWebService::API::Base
+    inflect_names false
+    api_method :getCategories, :returns => [[:string]]
+  end
+
+  class MTService < ActionWebService::Base
+    web_service_api MTAPI
+
+    def getCategories
+      ["mtCat1", "mtCat2"]
+    end
+  end
+
+  class BloggerService < ActionWebService::Base
+    web_service_api BloggerAPI
+
+    def getCategories
+      ["bloggerCat1", "bloggerCat2"]
+    end
+  end
+
+  class AbstractController < ActionController::Base
+    def generate_wsdl
+      to_wsdl
+    end
+  end
+ 
+  class DelegatedController < AbstractController
+    web_service_dispatching_mode :delegated
+  
+    web_service(:test_service) { @service ||= Service.new; @service }
+  end
+
+  class LayeredController < AbstractController
+    web_service_dispatching_mode :layered
+
+    web_service(:mt) { @mt_service ||= MTService.new; @mt_service }
+    web_service(:blogger) { @blogger_service ||= BloggerService.new; @blogger_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
+    attr :void_called
+
+    def initialize
+      @before_filter_called = false
+      @before_filter_target_called = false
+      @after_filter_called = false
+      @after_filter_target_called = false
+      @void_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, 6, 7]
+    end
+
+    def thrower
+      raise "Hi, I'm an exception"
+    end
+
+    def struct_return
+      n1 = Node.new('id' => 1, 'name' => 'node1', 'description' => 'Node 1')
+      n2 = Node.new('id' => 2, 'name' => 'node2', 'description' => 'Node 2')
+      [n1, n2]
+    end
+
+    def base_struct_return
+      p1 = Person.new('id' => 1, 'name' => 'person1')
+      p2 = Person.new('id' => 2, 'name' => 'person2')
+      [p1, p2]
+    end
+    
+    def void
+      @void_called = @method_params
+    end
+
+    protected
+      def alwaysfail
+        @before_filter_called = true
+        false
+      end
+
+      def alwaysok
+        @after_filter_called = true
+      end
+  end
+
+  class VirtualController < AbstractController
+    web_service_api VirtualAPI
+
+    def fallback
+      "fallback!"
+    end
+  end
+end
+
+module DispatcherCommonTests
+  def test_direct_dispatching
+    assert_equal(70, do_method_call(@direct_controller, 'Add', 20, 50))
+    assert_equal(70, @direct_controller.added)
+    assert(@direct_controller.void_called == false)
+    case @encoder
+    when WS::Encoding::SoapRpcEncoding
+      assert(do_method_call(@direct_controller, 'Void', 3, 4, 5).nil?)
+    when WS::Encoding::XmlRpcEncoding
+      assert(do_method_call(@direct_controller, 'Void', 3, 4, 5) == true)
+    end
+    assert(@direct_controller.void_called == [])
+    result = do_method_call(@direct_controller, 'BaseStructReturn')
+    case @encoder
+    when WS::Encoding::SoapRpcEncoding
+      assert(result[0].is_a?(DispatcherTest::Person))
+      assert(result[1].is_a?(DispatcherTest::Person))
+    when WS::Encoding::XmlRpcEncoding
+      assert(result[0].is_a?(Hash))
+      assert(result[1].is_a?(Hash))
+    end
+  end
+
+  def test_direct_entrypoint
+    assert(@direct_controller.respond_to?(:api))
+  end
+  
+  def test_virtual_dispatching
+    assert_equal("fallback!", do_method_call(@virtual_controller, 'VirtualOne'))
+    assert_equal("fallback!", do_method_call(@virtual_controller, 'VirtualTwo'))
+  end
+
+  def test_direct_filtering
+    assert_equal(false, @direct_controller.before_filter_called)
+    assert_equal(false, @direct_controller.before_filter_target_called)
+    do_method_call(@direct_controller, 'BeforeFiltered')
+    assert_equal(true, @direct_controller.before_filter_called)
+    assert_equal(false, @direct_controller.before_filter_target_called)
+    assert_equal(false, @direct_controller.after_filter_called)
+    assert_equal(false, @direct_controller.after_filter_target_called)
+    assert_equal([5, 6, 7], do_method_call(@direct_controller, 'AfterFiltered'))
+    assert_equal(true, @direct_controller.after_filter_called)
+    assert_equal(true, @direct_controller.after_filter_target_called)
+  end
+
+  def test_delegated_dispatching
+    assert_equal(130, do_method_call(@delegated_controller, 'Add', 50, 80))
+    service = @delegated_controller.web_service_object(:test_service)
+    assert_equal(130, service.added)
+    @delegated_controller.web_service_exception_reporting = true
+    assert(service.intercepted.nil?)
+    result = do_method_call(@delegated_controller, 'Interceptee')
+    assert(service.intercepted.nil?)
+    assert(is_exception?(result))
+    assert_match(/permission denied/, exception_message(result))
+    result = do_method_call(@delegated_controller, 'NonExistentMethod')
+    assert(is_exception?(result))
+    assert_match(/NonExistentMethod/, exception_message(result))
+    assert(service.void_called == false)
+    case @encoder
+    when WS::Encoding::SoapRpcEncoding
+      assert(do_method_call(@delegated_controller, 'Void', 3, 4, 5).nil?)
+    when WS::Encoding::XmlRpcEncoding
+      assert(do_method_call(@delegated_controller, 'Void', 3, 4, 5) == true)
+    end
+    assert(service.void_called == [])
+  end
+
+  def test_garbage_request
+    [@direct_controller, @delegated_controller].each do |controller|
+      controller.class.web_service_exception_reporting = true
+      send_garbage_request = lambda do
+        request = create_ap_request(controller, 'invalid request body', 'xxx')
+        response = ActionController::TestResponse.new
+        controller.process(request, response)
+        # puts response.body
+        assert(response.headers['Status'] =~ /^500/)
+      end
+      send_garbage_request.call
+      controller.class.web_service_exception_reporting = false
+      send_garbage_request.call
+    end
+  end
+
+  def test_exception_marshaling
+    @direct_controller.web_service_exception_reporting = true
+    result = do_method_call(@direct_controller, 'Thrower')
+    assert(is_exception?(result))
+    assert_equal("Hi, I'm an exception", exception_message(result))
+    @direct_controller.web_service_exception_reporting = false
+    result = do_method_call(@direct_controller, 'Thrower')
+    assert(exception_message(result) != "Hi, I'm an exception")
+  end
+
+  def test_ar_struct_return
+    [@direct_controller, @delegated_controller].each do |controller|
+      result = do_method_call(controller, 'StructReturn')
+      case @encoder
+      when WS::Encoding::SoapRpcEncoding
+        assert(result[0].is_a?(DispatcherTest::Node))
+        assert(result[1].is_a?(DispatcherTest::Node))
+        assert_equal('node1', result[0].name)
+        assert_equal('node2', result[1].name)
+      when WS::Encoding::XmlRpcEncoding
+        assert(result[0].is_a?(Hash))
+        assert(result[1].is_a?(Hash))
+        assert_equal('node1', result[0]['name'])
+        assert_equal('node2', result[1]['name'])
+      end
+    end
+  end
+
+  protected
+    def service_name(container)
+      raise NotImplementedError
+    end
+
+    def exception_message(obj)
+      raise NotImplementedError
+    end
+
+    def is_exception?(obj)
+      raise NotImplementedError
+    end
+
+    def do_method_call(container, public_method_name, *params)
+      mode = container.web_service_dispatching_mode
+      case mode
+      when :direct
+        api = container.class.web_service_api
+      when :delegated
+        api = container.web_service_object(service_name(container)).class.web_service_api
+      when :layered
+        service_name = nil
+        if public_method_name =~ /^([^\.]+)\.(.*)$/
+          service_name = $1
+        end
+        api = container.web_service_object(service_name.to_sym).class.web_service_api
+      end
+      info = api.api_methods[method_name] || {}
+      params = params.dup
+      ((info[:expects] || []) + (info[:returns] || [])).each do |spec|
+        @marshaler.register_type(spec)
+      end
+      expects = info[:expects]
+      (0..(params.length-1)).each do |i|
+        type_binding = @marshaler.register_type(expects ? expects[i] : params[i].class)
+        info = WS::ParamInfo.create(expects ? expects[i] : params[i].class, type_binding, i)
+        params[i] = @marshaler.marshal(WS::Param.new(params[i], info))
+      end
+      body = @encoder.encode_rpc_call(public_method_name, params)
+      # puts body
+      ap_request = create_ap_request(container, body, public_method_name, *params)
+      ap_response = ActionController::TestResponse.new
+      container.process(ap_request, ap_response)
+      # puts ap_response.body
+      public_method_name, return_value = @encoder.decode_rpc_response(ap_response.body)
+      @marshaler.unmarshal(return_value).value
+    end
+end