505 lines
15 KiB
Ruby
505 lines
15 KiB
Ruby
require File.dirname(__FILE__) + '/abstract_unit'
|
|
require 'stringio'
|
|
|
|
class ActionController::Base; def rescue_action(e) raise e end; end
|
|
|
|
module DispatcherTest
|
|
Utf8String = "One World Caf\303\251"
|
|
WsdlNamespace = 'http://rubyonrails.com/some/namespace'
|
|
|
|
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
|
|
|
|
def ==(other)
|
|
self.id == other.id && self.name == other.name
|
|
end
|
|
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 :add2, :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 :struct_pass, :expects => [{:person => Person}]
|
|
api_method :base_struct_return, :returns => [[Person]]
|
|
api_method :hash_struct_return, :returns => [[Person]]
|
|
api_method :thrower
|
|
api_method :void
|
|
api_method :test_utf8, :returns => [:string]
|
|
api_method :hex, :expects => [:base64], :returns => [:string]
|
|
api_method :unhex, :expects => [:string], :returns => [:base64]
|
|
api_method :time, :expects => [:time], :returns => [:time]
|
|
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]]
|
|
api_method :bool, :returns => [:bool]
|
|
api_method :alwaysFail
|
|
api_method :person, :returns => [Person]
|
|
end
|
|
|
|
class BloggerAPI < ActionWebService::API::Base
|
|
inflect_names false
|
|
api_method :getCategories, :returns => [[:string]]
|
|
api_method :str, :expects => [:int], :returns => [:string]
|
|
api_method :alwaysFail
|
|
end
|
|
|
|
class MTService < ActionWebService::Base
|
|
web_service_api MTAPI
|
|
|
|
def getCategories
|
|
["mtCat1", "mtCat2"]
|
|
end
|
|
|
|
def bool
|
|
'y'
|
|
end
|
|
|
|
def alwaysFail
|
|
raise "MT AlwaysFail"
|
|
end
|
|
|
|
def person
|
|
Person.new('id' => 1, 'name' => 'person1')
|
|
end
|
|
end
|
|
|
|
class BloggerService < ActionWebService::Base
|
|
web_service_api BloggerAPI
|
|
|
|
def getCategories
|
|
["bloggerCat1", "bloggerCat2"]
|
|
end
|
|
|
|
def str(int)
|
|
unless int.is_a?(Integer)
|
|
raise "Not an integer!"
|
|
end
|
|
500 + int
|
|
end
|
|
|
|
def alwaysFail
|
|
raise "Blogger AlwaysFail"
|
|
end
|
|
end
|
|
|
|
class AbstractController < ActionController::Base
|
|
def generate_wsdl
|
|
self.request ||= ::ActionController::TestRequest.new
|
|
to_wsdl
|
|
end
|
|
end
|
|
|
|
class DelegatedController < AbstractController
|
|
web_service_dispatching_mode :delegated
|
|
wsdl_namespace WsdlNamespace
|
|
|
|
web_service(:test_service) { @service ||= Service.new; @service }
|
|
end
|
|
|
|
class LayeredController < AbstractController
|
|
web_service_dispatching_mode :layered
|
|
wsdl_namespace WsdlNamespace
|
|
|
|
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
|
|
wsdl_namespace WsdlNamespace
|
|
|
|
before_invocation :alwaysfail, :only => [:before_filtered]
|
|
after_invocation :alwaysok, :only => [:after_filtered]
|
|
|
|
attr :added
|
|
attr :added2
|
|
attr :before_filter_called
|
|
attr :before_filter_target_called
|
|
attr :after_filter_called
|
|
attr :after_filter_target_called
|
|
attr :void_called
|
|
attr :struct_pass_value
|
|
|
|
def initialize
|
|
@before_filter_called = false
|
|
@before_filter_target_called = false
|
|
@after_filter_called = false
|
|
@after_filter_target_called = false
|
|
@void_called = false
|
|
@struct_pass_value = false
|
|
end
|
|
|
|
def add
|
|
@added = params['a'] + params['b']
|
|
end
|
|
|
|
def add2(a, b)
|
|
@added2 = a + 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 struct_pass(person)
|
|
@struct_pass_value = person
|
|
end
|
|
|
|
def base_struct_return
|
|
p1 = Person.new('id' => 1, 'name' => 'person1')
|
|
p2 = Person.new('id' => 2, 'name' => 'person2')
|
|
[p1, p2]
|
|
end
|
|
|
|
def hash_struct_return
|
|
p1 = { :id => '1', 'name' => 'test' }
|
|
p2 = { 'id' => '2', :name => 'person2' }
|
|
[p1, p2]
|
|
end
|
|
|
|
def void
|
|
@void_called = @method_params
|
|
end
|
|
|
|
def test_utf8
|
|
Utf8String
|
|
end
|
|
|
|
def hex(s)
|
|
return s.unpack("H*")[0]
|
|
end
|
|
|
|
def unhex(s)
|
|
return [s].pack("H*")
|
|
end
|
|
|
|
def time(t)
|
|
t
|
|
end
|
|
|
|
protected
|
|
def alwaysfail(method_name, params)
|
|
@before_filter_called = true
|
|
false
|
|
end
|
|
|
|
def alwaysok(method_name, params, return_value)
|
|
@after_filter_called = true
|
|
end
|
|
end
|
|
|
|
class VirtualController < AbstractController
|
|
web_service_api VirtualAPI
|
|
wsdl_namespace WsdlNamespace
|
|
|
|
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_equal(50, do_method_call(@direct_controller, 'Add2', 25, 25))
|
|
assert_equal(50, @direct_controller.added2)
|
|
assert(@direct_controller.void_called == false)
|
|
assert(do_method_call(@direct_controller, 'Void', 3, 4, 5).nil?)
|
|
assert(@direct_controller.void_called == [])
|
|
result = do_method_call(@direct_controller, 'BaseStructReturn')
|
|
assert(result[0].is_a?(DispatcherTest::Person))
|
|
assert(result[1].is_a?(DispatcherTest::Person))
|
|
assert_equal("cafe", do_method_call(@direct_controller, 'Hex', "\xca\xfe"))
|
|
assert_equal("\xca\xfe", do_method_call(@direct_controller, 'Unhex', "cafe"))
|
|
time = Time.gm(1998, "Feb", 02, 15, 12, 01)
|
|
assert_equal(time, do_method_call(@direct_controller, 'Time', time))
|
|
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)
|
|
assert(do_method_call(@delegated_controller, 'Void', 3, 4, 5).nil?)
|
|
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
|
|
service_name = service_name(controller)
|
|
request = protocol.encode_action_pack_request(service_name, 'broken, method, name!', 'broken request body', :request_class => ActionController::TestRequest)
|
|
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')
|
|
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)
|
|
end
|
|
end
|
|
|
|
def test_casting
|
|
assert_equal 70, do_method_call(@direct_controller, 'Add', "50", "20")
|
|
assert_equal false, @direct_controller.struct_pass_value
|
|
person = DispatcherTest::Person.new(:id => 1, :name => 'test')
|
|
result = do_method_call(@direct_controller, 'StructPass', person)
|
|
assert(nil == result || true == result)
|
|
assert_equal person, @direct_controller.struct_pass_value
|
|
assert !person.equal?(@direct_controller.struct_pass_value)
|
|
result = do_method_call(@direct_controller, 'StructPass', {'id' => '1', 'name' => 'test'})
|
|
case
|
|
when soap?
|
|
assert_equal(person, @direct_controller.struct_pass_value)
|
|
assert !person.equal?(@direct_controller.struct_pass_value)
|
|
when xmlrpc?
|
|
assert_equal(person, @direct_controller.struct_pass_value)
|
|
assert !person.equal?(@direct_controller.struct_pass_value)
|
|
end
|
|
assert_equal person, do_method_call(@direct_controller, 'HashStructReturn')[0]
|
|
result = do_method_call(@direct_controller, 'StructPass', {'id' => '1', 'name' => 'test', 'nonexistent_attribute' => 'value'})
|
|
case
|
|
when soap?
|
|
assert_equal(person, @direct_controller.struct_pass_value)
|
|
assert !person.equal?(@direct_controller.struct_pass_value)
|
|
when xmlrpc?
|
|
assert_equal(person, @direct_controller.struct_pass_value)
|
|
assert !person.equal?(@direct_controller.struct_pass_value)
|
|
end
|
|
end
|
|
|
|
def test_logging
|
|
buf = ""
|
|
ActionController::Base.logger = Logger.new(StringIO.new(buf))
|
|
test_casting
|
|
test_garbage_request
|
|
test_exception_marshaling
|
|
ActionController::Base.logger = nil
|
|
assert_match /Web Service Response/, buf
|
|
assert_match /Web Service Request/, buf
|
|
end
|
|
|
|
protected
|
|
def service_name(container)
|
|
raise NotImplementedError
|
|
end
|
|
|
|
def exception_message(obj)
|
|
raise NotImplementedError
|
|
end
|
|
|
|
def is_exception?(obj)
|
|
raise NotImplementedError
|
|
end
|
|
|
|
def protocol
|
|
@protocol
|
|
end
|
|
|
|
def soap?
|
|
protocol.is_a? ActionWebService::Protocol::Soap::SoapProtocol
|
|
end
|
|
|
|
def xmlrpc?
|
|
protocol.is_a? ActionWebService::Protocol::XmlRpc::XmlRpcProtocol
|
|
end
|
|
|
|
def do_method_call(container, public_method_name, *params)
|
|
request_env = {}
|
|
mode = container.web_service_dispatching_mode
|
|
case mode
|
|
when :direct
|
|
service_name = service_name(container)
|
|
api = container.class.web_service_api
|
|
method = api.public_api_method_instance(public_method_name)
|
|
when :delegated
|
|
service_name = service_name(container)
|
|
api = container.web_service_object(service_name).class.web_service_api
|
|
method = api.public_api_method_instance(public_method_name)
|
|
when :layered
|
|
service_name = nil
|
|
real_method_name = nil
|
|
if public_method_name =~ /^([^\.]+)\.(.*)$/
|
|
service_name = $1
|
|
real_method_name = $2
|
|
end
|
|
if soap?
|
|
public_method_name = real_method_name
|
|
request_env['HTTP_SOAPACTION'] = "/soap/#{service_name}/#{real_method_name}"
|
|
end
|
|
api = container.web_service_object(service_name.to_sym).class.web_service_api rescue nil
|
|
method = api.public_api_method_instance(real_method_name) rescue nil
|
|
service_name = self.service_name(container)
|
|
end
|
|
protocol.register_api(api)
|
|
virtual = false
|
|
unless method
|
|
virtual = true
|
|
method ||= ActionWebService::API::Method.new(public_method_name.underscore.to_sym, public_method_name, nil, nil)
|
|
end
|
|
body = protocol.encode_request(public_method_name, params.dup, method.expects)
|
|
# puts body
|
|
ap_request = protocol.encode_action_pack_request(service_name, public_method_name, body, :request_class => ActionController::TestRequest)
|
|
ap_request.env.update(request_env)
|
|
ap_response = ActionController::TestResponse.new
|
|
container.process(ap_request, ap_response)
|
|
# puts ap_response.body
|
|
@response_body = ap_response.body
|
|
public_method_name, return_value = protocol.decode_response(ap_response.body)
|
|
unless is_exception?(return_value) || virtual
|
|
return_value = method.cast_returns(return_value)
|
|
end
|
|
if soap?
|
|
# http://dev.rubyonrails.com/changeset/920
|
|
assert_match(/Response$/, public_method_name) unless public_method_name == "fault"
|
|
end
|
|
return_value
|
|
end
|
|
end
|