From 7a67d0f617db7d2962b6c3b80466e21570b244bf Mon Sep 17 00:00:00 2001 From: David Heinemeier Hansson Date: Fri, 18 Feb 2005 23:43:09 +0000 Subject: Renamed Action Service to Action Web Service git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@669 5ecf4fe2-1ee6-0310-87b1-e25e094e27de --- actionwebservice/test/abstract_client.rb | 124 +++++++++++ actionwebservice/test/abstract_soap.rb | 58 ++++++ actionwebservice/test/abstract_unit.rb | 9 + actionwebservice/test/api_test.rb | 52 +++++ actionwebservice/test/base_test.rb | 42 ++++ actionwebservice/test/client_soap_test.rb | 87 ++++++++ actionwebservice/test/client_xmlrpc_test.rb | 86 ++++++++ actionwebservice/test/container_test.rb | 53 +++++ actionwebservice/test/invocation_test.rb | 158 ++++++++++++++ actionwebservice/test/protocol_registry_test.rb | 53 +++++ actionwebservice/test/protocol_soap_test.rb | 226 +++++++++++++++++++++ actionwebservice/test/protocol_xmlrpc_test.rb | 157 ++++++++++++++ .../test/router_action_controller_test.rb | 139 +++++++++++++ actionwebservice/test/router_wsdl_test.rb | 100 +++++++++ actionwebservice/test/struct_test.rb | 40 ++++ 15 files changed, 1384 insertions(+) create mode 100644 actionwebservice/test/abstract_client.rb create mode 100644 actionwebservice/test/abstract_soap.rb create mode 100644 actionwebservice/test/abstract_unit.rb create mode 100644 actionwebservice/test/api_test.rb create mode 100644 actionwebservice/test/base_test.rb create mode 100644 actionwebservice/test/client_soap_test.rb create mode 100644 actionwebservice/test/client_xmlrpc_test.rb create mode 100644 actionwebservice/test/container_test.rb create mode 100644 actionwebservice/test/invocation_test.rb create mode 100644 actionwebservice/test/protocol_registry_test.rb create mode 100644 actionwebservice/test/protocol_soap_test.rb create mode 100644 actionwebservice/test/protocol_xmlrpc_test.rb create mode 100644 actionwebservice/test/router_action_controller_test.rb create mode 100644 actionwebservice/test/router_wsdl_test.rb create mode 100644 actionwebservice/test/struct_test.rb (limited to 'actionwebservice/test') diff --git a/actionwebservice/test/abstract_client.rb b/actionwebservice/test/abstract_client.rb new file mode 100644 index 0000000000..70d2d21124 --- /dev/null +++ b/actionwebservice/test/abstract_client.rb @@ -0,0 +1,124 @@ +require File.dirname(__FILE__) + '/abstract_unit' +require 'webrick' +require 'webrick/log' +require 'singleton' + +module ClientTest + class Person < ActionService::Struct + member :firstnames, [:string] + member :lastname, :string + + def ==(other) + firstnames == other.firstnames && lastname == other.lastname + end + end + + class API < ActionService::API::Base + api_method :void + api_method :normal, :expects => [:int, :int], :returns => [:int] + api_method :array_return, :returns => [[Person]] + api_method :struct_pass, :expects => [[Person]], :returns => [:bool] + api_method :client_container, :returns => [:int] + end + + class NullLogOut + def <<(*args); end + end + + class Container < ActionController::Base + web_service_api API + + attr :value_void + attr :value_normal + attr :value_array_return + attr :value_struct_pass + + def initialize + @session = @assigns = {} + @value_void = nil + @value_normal = nil + @value_array_return = nil + @value_struct_pass = nil + end + + def void + @value_void = @method_params + end + + def normal + @value_normal = @method_params + 5 + end + + def array_return + person = Person.new + person.firstnames = ["one", "two"] + person.lastname = "last" + @value_array_return = [person] + end + + def struct_pass + @value_struct_pass = @method_params + true + end + + def client_container + 50 + end + + def protocol_request(request) + probe_request_protocol(request) + end + + def dispatch_request(protocol_request) + dispatch_web_service_request(protocol_request) + end + end + + class AbstractClientLet < WEBrick::HTTPServlet::AbstractServlet + def initialize(controller) + @controller = controller + end + + def get_instance(*args) + self + end + + def require_path_info? + false + end + + def do_GET(req, res) + raise WEBrick::HTTPStatus::MethodNotAllowed, "GET request not allowed." + end + + def do_POST(req, res) + raise NotImplementedError + end + end + + class AbstractServer + include ClientTest + include Singleton + attr :container + def initialize + @container = Container.new + @clientlet = create_clientlet(@container) + log = WEBrick::BasicLog.new(NullLogOut.new) + @server = WEBrick::HTTPServer.new(:Port => server_port, :Logger => log, :AccessLog => log) + @server.mount('/', @clientlet) + @thr = Thread.new { @server.start } + until @server.status == :Running; end + at_exit { @server.stop; @thr.join } + end + + protected + def create_clientlet + raise NotImplementedError + end + + def server_port + raise NotImplementedError + end + end +end diff --git a/actionwebservice/test/abstract_soap.rb b/actionwebservice/test/abstract_soap.rb new file mode 100644 index 0000000000..7454be9bdf --- /dev/null +++ b/actionwebservice/test/abstract_soap.rb @@ -0,0 +1,58 @@ +require File.dirname(__FILE__) + '/abstract_unit' +require 'soap/rpc/element' + +class SoapTestError < StandardError +end + +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) + if envelope + if envelope.body.response + SOAP::Mapping.soap2obj(envelope.body.response) + else + nil + end + else + raise(SoapTestError, "empty/invalid body from server") + end + end +end diff --git a/actionwebservice/test/abstract_unit.rb b/actionwebservice/test/abstract_unit.rb new file mode 100644 index 0000000000..54ca73b35c --- /dev/null +++ b/actionwebservice/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 diff --git a/actionwebservice/test/api_test.rb b/actionwebservice/test/api_test.rb new file mode 100644 index 0000000000..2ef5cc7bda --- /dev/null +++ b/actionwebservice/test/api_test.rb @@ -0,0 +1,52 @@ +require File.dirname(__FILE__) + '/abstract_unit' + +module APITest + class API < ActionService::API::Base + api_method :void + api_method :expects_and_returns, :expects_and_returns => [:string] + api_method :expects, :expects => [:int, :bool] + api_method :returns, :returns => [:int, [:string]] + api_method :named_signature, :expects => [{:appkey=>:int}, {:publish=>:bool}] + api_method :string_types, :expects => ['int', 'string', 'bool'] + api_method :class_types, :expects => [TrueClass, Bignum, String] + end +end + +class TC_API < Test::Unit::TestCase + API = APITest::API + + def test_api_method_declaration + %w( + void + expects_and_returns + expects + returns + named_signature + string_types + class_types + ).each do |name| + name = name.to_sym + public_name = API.public_api_method_name(name) + assert(API.has_api_method?(name)) + assert(API.has_public_api_method?(public_name)) + assert(API.api_method_name(public_name) == name) + assert(API.api_methods.has_key?(name)) + end + end + + def test_signature_canonicalization + assert_equal({:expects=>nil, :returns=>nil}, API.api_methods[:void]) + assert_equal({:expects=>[String], :returns=>[String]}, API.api_methods[:expects_and_returns]) + assert_equal({:expects=>[Integer, TrueClass], :returns=>nil}, API.api_methods[:expects]) + assert_equal({:expects=>nil, :returns=>[Integer, [String]]}, API.api_methods[:returns]) + assert_equal({:expects=>[{:appkey=>Integer}, {:publish=>TrueClass}], :returns=>nil}, API.api_methods[:named_signature]) + assert_equal({:expects=>[Integer, String, TrueClass], :returns=>nil}, API.api_methods[:string_types]) + assert_equal({:expects=>[TrueClass, Bignum, String], :returns=>nil}, API.api_methods[:class_types]) + end + + def test_not_instantiable + assert_raises(NoMethodError) do + API.new + end + end +end diff --git a/actionwebservice/test/base_test.rb b/actionwebservice/test/base_test.rb new file mode 100644 index 0000000000..a9fbdd1a8b --- /dev/null +++ b/actionwebservice/test/base_test.rb @@ -0,0 +1,42 @@ +require File.dirname(__FILE__) + '/abstract_unit' + +module BaseTest + class API < ActionService::API::Base + api_method :add, :expects => [:int, :int], :returns => [:int] + api_method :void + end + + class PristineAPI < ActionService::API::Base + inflect_names false + + api_method :add + api_method :under_score + end + + class Service < ActionService::Base + web_service_api API + + def add(a, b) + end + + def void + end + end + + class PristineService < ActionService::Base + web_service_api PristineAPI + + def add + end + + def under_score + end + end +end + +class TC_Base < Test::Unit::TestCase + def test_options + assert(BaseTest::PristineService.web_service_api.inflect_names == false) + assert(BaseTest::Service.web_service_api.inflect_names == true) + end +end diff --git a/actionwebservice/test/client_soap_test.rb b/actionwebservice/test/client_soap_test.rb new file mode 100644 index 0000000000..80fae90543 --- /dev/null +++ b/actionwebservice/test/client_soap_test.rb @@ -0,0 +1,87 @@ +require File.dirname(__FILE__) + '/abstract_client' + + +module ClientSoapTest + PORT = 8998 + + class SoapClientLet < ClientTest::AbstractClientLet + def do_POST(req, res) + test_request = ActionController::TestRequest.new + test_request.request_parameters['action'] = req.path.gsub(/^\//, '').split(/\//)[1] + test_request.env['REQUEST_METHOD'] = "POST" + test_request.env['HTTP_CONTENTTYPE'] = 'text/xml' + test_request.env['HTTP_SOAPACTION'] = req.header['soapaction'][0] + test_request.env['RAW_POST_DATA'] = req.body + protocol_request = @controller.protocol_request(test_request) + response = @controller.dispatch_request(protocol_request) + res.header['content-type'] = 'text/xml' + res.body = response.raw_body + rescue Exception => e + $stderr.puts e.message + $stderr.puts e.backtrace.join("\n") + end + end + + class ClientContainer < ActionController::Base + web_client_api :client, :soap, "http://localhost:#{PORT}/client/api", :api => ClientTest::API + + def get_client + client + end + end + + class SoapServer < ClientTest::AbstractServer + def create_clientlet(controller) + SoapClientLet.new(controller) + end + + def server_port + PORT + end + end +end + +class TC_ClientSoap < Test::Unit::TestCase + include ClientTest + include ClientSoapTest + + def setup + @server = SoapServer.instance + @container = @server.container + @client = ActionService::Client::Soap.new(API, "http://localhost:#{@server.server_port}/client/api") + end + + def test_void + assert(@container.value_void.nil?) + @client.void + assert(!@container.value_void.nil?) + end + + def test_normal + assert(@container.value_normal.nil?) + assert_equal(5, @client.normal(5, 6)) + assert_equal([5, 6], @container.value_normal) + end + + def test_array_return + assert(@container.value_array_return.nil?) + new_person = Person.new + new_person.firstnames = ["one", "two"] + new_person.lastname = "last" + assert_equal([new_person], @client.array_return) + assert_equal([new_person], @container.value_array_return) + end + + def test_struct_pass + assert(@container.value_struct_pass.nil?) + new_person = Person.new + new_person.firstnames = ["one", "two"] + new_person.lastname = "last" + assert_equal(true, @client.struct_pass([new_person])) + assert_equal([[new_person]], @container.value_struct_pass) + end + + def test_client_container + assert_equal(50, ClientContainer.new.get_client.client_container) + end +end diff --git a/actionwebservice/test/client_xmlrpc_test.rb b/actionwebservice/test/client_xmlrpc_test.rb new file mode 100644 index 0000000000..35768adf32 --- /dev/null +++ b/actionwebservice/test/client_xmlrpc_test.rb @@ -0,0 +1,86 @@ +require File.dirname(__FILE__) + '/abstract_client' + + +module ClientXmlRpcTest + PORT = 8999 + + class XmlRpcClientLet < ClientTest::AbstractClientLet + def do_POST(req, res) + test_request = ActionController::TestRequest.new + test_request.request_parameters['action'] = req.path.gsub(/^\//, '').split(/\//)[1] + test_request.env['REQUEST_METHOD'] = "POST" + test_request.env['HTTP_CONTENTTYPE'] = 'text/xml' + test_request.env['RAW_POST_DATA'] = req.body + protocol_request = @controller.protocol_request(test_request) + response = @controller.dispatch_request(protocol_request) + res.header['content-type'] = 'text/xml' + res.body = response.raw_body + rescue Exception => e + $stderr.puts e.message + $stderr.puts e.backtrace.join("\n") + end + end + + class ClientContainer < ActionController::Base + web_client_api :client, :xmlrpc, "http://localhost:#{PORT}/client/api", :api => ClientTest::API + + def get_client + client + end + end + + class XmlRpcServer < ClientTest::AbstractServer + def create_clientlet(controller) + XmlRpcClientLet.new(controller) + end + + def server_port + PORT + end + end +end + +class TC_ClientXmlRpc < Test::Unit::TestCase + include ClientTest + include ClientXmlRpcTest + + def setup + @server = XmlRpcServer.instance + @container = @server.container + @client = ActionService::Client::XmlRpc.new(API, "http://localhost:#{@server.server_port}/client/api") + end + + def test_void + assert(@container.value_void.nil?) + @client.void + assert(!@container.value_void.nil?) + end + + def test_normal + assert(@container.value_normal.nil?) + assert_equal(5, @client.normal(5, 6)) + assert_equal([5, 6], @container.value_normal) + end + + def test_array_return + assert(@container.value_array_return.nil?) + new_person = Person.new + new_person.firstnames = ["one", "two"] + new_person.lastname = "last" + assert_equal([new_person], @client.array_return) + assert_equal([new_person], @container.value_array_return) + end + + def test_struct_pass + assert(@container.value_struct_pass.nil?) + new_person = Person.new + new_person.firstnames = ["one", "two"] + new_person.lastname = "last" + assert_equal(true, @client.struct_pass([new_person])) + assert_equal([[new_person]], @container.value_struct_pass) + end + + def test_client_container + assert_equal(50, ClientContainer.new.get_client.client_container) + end +end diff --git a/actionwebservice/test/container_test.rb b/actionwebservice/test/container_test.rb new file mode 100644 index 0000000000..8c66651b64 --- /dev/null +++ b/actionwebservice/test/container_test.rb @@ -0,0 +1,53 @@ +require File.dirname(__FILE__) + '/abstract_unit' + +module ContainerTest + + $immediate_service = Object.new + $deferred_service = Object.new + + class DelegateContainer < ActionController::Base + web_service_dispatching_mode :delegated + + attr :flag + attr :previous_flag + + def initialize + @previous_flag = nil + @flag = true + end + + web_service :immediate_service, $immediate_service + web_service(:deferred_service) { @previous_flag = @flag; @flag = false; $deferred_service } + end + + class DirectContainer < ActionController::Base + web_service_dispatching_mode :direct + end +end + +class TC_Container < Test::Unit::TestCase + def setup + @delegate_container = ContainerTest::DelegateContainer.new + @direct_container = ContainerTest::DirectContainer.new + end + + def test_registration + assert(ContainerTest::DelegateContainer.has_web_service?(:immediate_service)) + assert(ContainerTest::DelegateContainer.has_web_service?(:deferred_service)) + assert(!ContainerTest::DelegateContainer.has_web_service?(:fake_service)) + end + + def test_service_object + assert(@delegate_container.flag == true) + assert(@delegate_container.web_service_object(:immediate_service) == $immediate_service) + assert(@delegate_container.previous_flag.nil?) + assert(@delegate_container.flag == true) + assert(@delegate_container.web_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.web_service_dispatching_mode == :direct) + end +end diff --git a/actionwebservice/test/invocation_test.rb b/actionwebservice/test/invocation_test.rb new file mode 100644 index 0000000000..e4c82a35f8 --- /dev/null +++ b/actionwebservice/test/invocation_test.rb @@ -0,0 +1,158 @@ +require File.dirname(__FILE__) + '/abstract_unit' + +module InvocationTest + class API < ActionService::API::Base + api_method :add, :expects => [:int, :int], :returns => [:int] + api_method :transmogrify, :expects_and_returns => [:string] + api_method :fail_with_reason + api_method :fail_generic + api_method :no_before + api_method :no_after + api_method :only_one + api_method :only_two + end + + class Service < ActionService::Base + web_service_api API + + before_invocation :intercept_before, :except => [:no_before] + after_invocation :intercept_after, :except => [:no_after] + before_invocation :intercept_only, :only => [:only_one, :only_two] + + 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_public + end + + 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 TC_Invocation < Test::Unit::TestCase + include ActionService::Invocation + + def setup + @service = InvocationTest::Service.new + end + + def test_invocation + assert(perform_invocation(:add, 5, 10) == 15) + assert(perform_invocation(:transmogrify, "hello") == "HELLO") + assert_raises(InvocationError) do + perform_invocation(:not_public) + end + assert_raises(InvocationError) do + perform_invocation(:nonexistent_method_xyzzy) + end + end + + def test_interceptor_registration + 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?) + 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 + 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 + 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 + 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 + 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?) + perform_invocation(:only_one) + assert(@service.only_invoked == :only_one) + @service.only_invoked = nil + perform_invocation(:only_two) + assert(@service.only_invoked == :only_two) + end + + private + def perform_invocation(method_name, *args, &block) + public_method_name = @service.class.web_service_api.public_api_method_name(method_name) + args ||= [] + request = InvocationRequest.new(ConcreteInvocation, public_method_name, method_name, args) + @service.perform_invocation(request, &block) + end +end diff --git a/actionwebservice/test/protocol_registry_test.rb b/actionwebservice/test/protocol_registry_test.rb new file mode 100644 index 0000000000..8e2b9659a6 --- /dev/null +++ b/actionwebservice/test/protocol_registry_test.rb @@ -0,0 +1,53 @@ +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 self.create_protocol_request(klass, request) + protocol = FooFullProtocol.new klass + ActionService::Protocol::ProtocolRequest.new(protocol, '', '', '', '') + end + end + + class FooMinimalProtocol < AbstractProtocol + def self.create_protocol_request(klass, request) + protocol = FooMinimalProtocol.new klass + ActionService::Protocol::ProtocolRequest.new(protocol, '', '', '', '') + end + end + + class FooMinimalProtocolTwo < AbstractProtocol + end +end + +class ProtocolRegistry + include ActionService::Protocol::Registry + include Foo + + def all_protocols + header_and_body_protocols + body_only_protocols + end + + def protocol_request + probe_request_protocol(nil) + end +end + + +class TC_ProtocolRegistry < Test::Unit::TestCase + def test_registration + registry = ProtocolRegistry.new + assert(registry.all_protocols.length == 4) + assert(registry.protocol_request.protocol.is_a?(Foo::FooFullProtocol)) + end +end diff --git a/actionwebservice/test/protocol_soap_test.rb b/actionwebservice/test/protocol_soap_test.rb new file mode 100644 index 0000000000..164d06bbd6 --- /dev/null +++ b/actionwebservice/test/protocol_soap_test.rb @@ -0,0 +1,226 @@ +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 + + class API < ActionService::API::Base + api_method :argument_passing, :expects => [{:int=>:int}, {:string=>:string}, {:array=>[:int]}], :returns => [:bool] + api_method :array_returner, :returns => [[:int]] + api_method :nil_returner + api_method :struct_array_returner, :returns => [[Person]] + api_method :exception_thrower + + default_api_method :default + end + + class Service < ActionService::Base + web_service_api API + + 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 + end + + class AbstractContainer + include ActionService::API + include ActionService::Container + include ActionService::Protocol::Registry + include ActionService::Protocol::Soap + + wsdl_service_name 'Test' + + def protocol_request(request) + probe_request_protocol(request) + end + + def dispatch_request(protocol_request) + dispatch_web_service_request(protocol_request) + end + end + + class DelegatedContainer < AbstractContainer + web_service_dispatching_mode :delegated + web_service :protocol_soap_service, Service.new + end + + class DirectContainer < AbstractContainer + web_service_api API + web_service_dispatching_mode :direct + + 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 = @params['int'] + @string = @params['string'] + @array = @params['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 + @default_args = @method_params + nil + end + end +end + +class TC_ProtocolSoap < AbstractSoapTest + def setup + @delegated_container = ProtocolSoapTest::DelegatedContainer.new + @direct_container = ProtocolSoapTest::DirectContainer.new + end + + def test_argument_passing + in_all_containers do + 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 + end + + def test_array_returner + in_all_containers do + assert(do_soap_call('ArrayReturner') == [1, 2, 3]) + assert(service.values == [1, 2, 3]) + end + end + + def test_nil_returner + in_all_containers do + assert(do_soap_call('NilReturner') == nil) + end + end + + def test_struct_array_returner + in_all_containers do + assert(do_soap_call('StructArrayReturner') == [service.person]) + end + end + + def test_exception_thrower + in_all_containers do + assert_raises(RuntimeError) do + do_soap_call('ExceptionThrower') + end + end + end + + def test_default_api_method + in_all_containers do + assert(do_soap_call('NonExistentMethodName', 50, false).nil?) + assert(service.default_args == [50, false]) + end + end + + def test_service_name_setting + in_all_containers do + assert(ProtocolSoapTest::DelegatedContainer.soap_mapper.custom_namespace == 'urn:Test') + end + end + + protected + def service_name + @container == @direct_container ? 'api' : 'protocol_soap_service' + end + + def service + @container == @direct_container ? @container : @container.web_service_object(:protocol_soap_service) + end + + def in_all_containers(&block) + [@direct_container].each do |container| + @container = container + block.call + end + 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 diff --git a/actionwebservice/test/protocol_xmlrpc_test.rb b/actionwebservice/test/protocol_xmlrpc_test.rb new file mode 100644 index 0000000000..a8a6efc07e --- /dev/null +++ b/actionwebservice/test/protocol_xmlrpc_test.rb @@ -0,0 +1,157 @@ +require File.dirname(__FILE__) + '/abstract_unit' +require 'xmlrpc/parser' +require 'xmlrpc/create' +require 'xmlrpc/config' + +module XMLRPC + class XmlRpcTestHelper + include ParserWriterChooseMixin + + def create_request(methodName, *args) + create().methodCall(methodName, *args) + end + + def parse_response(response) + parser().parseMethodResponse(response) + end + end +end + +module ProtocolXmlRpcTest + class Person < ActionService::Struct + member :firstname, String + member :lastname, String + member :active, TrueClass + end + + class API < ActionService::API::Base + api_method :add, :expects => [Integer, Integer], :returns => [Integer] + api_method :hash_returner, :returns => [Hash] + api_method :array_returner, :returns => [[Integer]] + api_method :something_hash, :expects => [Hash] + api_method :struct_array_returner, :returns => [[Person]] + + default_api_method :default + end + + class Service < ActionService::Base + web_service_api API + + 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 + + def hash_returner + {'name' => 1, 'value' => 2} + end + + def struct_array_returner + person = Person.new + person.firstname = "John" + person.lastname = "Doe" + person.active = true + [person] + end + + def default(*args) + @default_args = args + nil + end + end + + $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_web_service_request(protocol_request) + end + + web_service :xmlrpc, $service + web_service_dispatching_mode :delegated + end +end + +class TC_ProtocolXmlRpc < Test::Unit::TestCase + def setup + @helper = XMLRPC::XmlRpcTestHelper.new + @container = ProtocolXmlRpcTest::Container.new + end + + def test_xmlrpc_request_dispatching + retval = do_xmlrpc_call('Add', 50, 30) + assert(retval == [true, 80]) + end + + def test_array_returning + retval = do_xmlrpc_call('ArrayReturner') + assert(retval == [true, [1, 2, 3]]) + end + + def test_hash_returning + retval = do_xmlrpc_call('HashReturner') + assert(retval == [true, {'name' => 1, 'value' => 2}]) + end + + def test_struct_array_returning + retval = do_xmlrpc_call('StructArrayReturner') + assert(retval == [true, [{"firstname"=>"John", "lastname"=>"Doe", "active"=>true}]]) + end + + def test_hash_parameter + retval = do_xmlrpc_call('SomethingHash', {'name' => 1, 'value' => 2}) + assert(retval == [true, true]) + assert($service.hashvalue == {'name' => 1, 'value' => 2}) + end + + def test_default_api_method + retval = do_xmlrpc_call('SomeNonexistentMethod', 'test', [1, 2], {'name'=>'value'}) + assert(retval == [true, true]) + assert($service.default_args == ['test', [1, 2], {'name'=>'value'}]) + end + + def test_xmlrpc_introspection + retval = do_xmlrpc_call('system.listMethods', 'test', [1, 2], {'name'=>'value'}) + assert(retval == [true, ["Add", "ArrayReturner", "HashReturner", "SomethingHash", "StructArrayReturner"]]) + end + + private + def do_xmlrpc_call(public_method_name, *args) + service_name = 'xmlrpc' + raw_request = @helper.create_request(public_method_name, *args) + 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['RAW_POST_DATA'] = raw_request + protocol_request = @container.protocol_request(test_request) + response = @container.dispatch_request(protocol_request) + @helper.parse_response(response.raw_body) + end +end diff --git a/actionwebservice/test/router_action_controller_test.rb b/actionwebservice/test/router_action_controller_test.rb new file mode 100644 index 0000000000..e26d67c194 --- /dev/null +++ b/actionwebservice/test/router_action_controller_test.rb @@ -0,0 +1,139 @@ +require File.dirname(__FILE__) + '/abstract_soap' +require 'wsdl/parser' + +module RouterActionControllerTest + class API < ActionService::API::Base + api_method :add, :expects => [:int, :int], :returns => [:int] + end + + class Service < ActionService::Base + web_service_api API + + attr :added + + def add(a, b) + @added = a + b + end + end + + class DelegatedController < ActionController::Base + web_service_dispatching_mode :delegated + + web_service(:test_service) { @service ||= Service.new; @service } + end + + class DirectAPI < ActionService::API::Base + api_method :add, :expects => [{:a=>:int}, {:b=>:int}], :returns => [:int] + api_method :before_filtered + api_method :after_filtered, :returns => [:int] + api_method :thrower + end + + class DirectController < ActionController::Base + 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 + + def initialize + @before_filter_called = false + @before_filter_target_called = false + @after_filter_called = false + @after_filter_target_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 + end + + def thrower + raise "Hi, I'm a SOAP exception" + end + + protected + def alwaysfail + @before_filter_called = true + false + end + + def alwaysok + @after_filter_called = true + end + end +end + +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_direct_entrypoint + @container = RouterActionControllerTest::DirectController.new + assert(@container.respond_to?(:api)) + end + + def test_direct_filtering + @container = RouterActionControllerTest::DirectController.new + assert(@container.before_filter_called == false) + assert(@container.before_filter_target_called == false) + assert(do_soap_call('BeforeFiltered').nil?) + assert(@container.before_filter_called == true) + assert(@container.before_filter_target_called == false) + assert(@container.after_filter_called == false) + assert(@container.after_filter_target_called == false) + assert(do_soap_call('AfterFiltered') == 5) + assert(@container.after_filter_called == true) + assert(@container.after_filter_target_called == true) + end + + def test_delegated_routing + @container = RouterActionControllerTest::DelegatedController.new + assert(do_soap_call('Add', 50, 80) == 130) + assert(service.added == 130) + end + + def test_exception_marshaling + @container = RouterActionControllerTest::DirectController.new + result = do_soap_call('Thrower') + exception = result.detail + assert(exception.cause.is_a?(RuntimeError)) + assert_equal("Hi, I'm a SOAP exception", exception.cause.message) + @container.web_service_exception_reporting = false + assert_raises(SoapTestError) do + do_soap_call('Thrower') + end + end + + protected + def service_name + @container.is_a?(RouterActionControllerTest::DelegatedController) ? 'test_service' : 'api' + end + + def service + @container.web_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 diff --git a/actionwebservice/test/router_wsdl_test.rb b/actionwebservice/test/router_wsdl_test.rb new file mode 100644 index 0000000000..6812d25579 --- /dev/null +++ b/actionwebservice/test/router_wsdl_test.rb @@ -0,0 +1,100 @@ +require File.dirname(__FILE__) + '/abstract_unit' +require 'wsdl/parser' + +module RouterWsdlTest + class Person < ActionService::Struct + member :id, Integer + member :names, [String] + member :lastname, String + member :deleted, TrueClass + end + + class API < ActionService::API::Base + api_method :add, :expects => [{:a=>:int}, {:b=>:int}], :returns => [:int] + api_method :find_people, :returns => [[Person]] + api_method :nil_returner + end + + class Service < ActionService::Base + web_service_api API + + def add(a, b) + a + b + end + + def find_people + [] + end + + def nil_returner + end + end + + class AbstractController < ActionController::Base + def generate_wsdl(container, uri, soap_action_base) + to_wsdl(container, uri, soap_action_base) + end + end + + class DirectController < AbstractController + web_service_api API + + def add + end + + def find_people + end + + def nil_returner + end + end + + class DelegatedController < AbstractController + web_service_dispatching_mode :delegated + web_service(:test_service) { Service.new } + end +end + +class TC_RouterWsdl < Test::Unit::TestCase + include RouterWsdlTest + + def test_wsdl_generation + ensure_valid_generation DelegatedController.new + ensure_valid_generation DirectController.new + end + + def + + def test_wsdl_action + ensure_valid_wsdl_action DelegatedController.new + ensure_valid_wsdl_action DirectController.new + end + + protected + def ensure_valid_generation(controller) + wsdl = controller.generate_wsdl(controller, 'http://localhost:3000/test/', '/test') + ensure_valid_wsdl(wsdl) + end + + def ensure_valid_wsdl(wsdl) + definitions = WSDL::Parser.new.parse(wsdl) + assert(definitions.is_a?(WSDL::Definitions)) + definitions.bindings.each do |binding| + assert(binding.name.name.index(':').nil?) + end + definitions.services.each do |service| + service.ports.each do |port| + assert(port.name.name.index(':').nil?) + end + end + end + + def ensure_valid_wsdl_action(controller) + test_request = ActionController::TestRequest.new({ 'action' => 'wsdl' }) + test_request.env['REQUEST_METHOD'] = 'GET' + test_request.env['HTTP_HOST'] = 'localhost:3000' + test_response = ActionController::TestResponse.new + wsdl = controller.process(test_request, test_response).body + ensure_valid_wsdl(wsdl) + end +end diff --git a/actionwebservice/test/struct_test.rb b/actionwebservice/test/struct_test.rb new file mode 100644 index 0000000000..b883c6d991 --- /dev/null +++ b/actionwebservice/test/struct_test.rb @@ -0,0 +1,40 @@ +require File.dirname(__FILE__) + '/abstract_unit' + +module StructTest + class Struct < ActionService::Struct + member :id, Integer + member :name, String + member :items, [String] + member :deleted, :bool + member :emails, [:string] + end +end + +class TC_Struct < Test::Unit::TestCase + def test_members + assert_equal(5, StructTest::Struct.members.size) + assert_equal(Integer, StructTest::Struct.members[:id]) + assert_equal(String, StructTest::Struct.members[:name]) + assert_equal([String], StructTest::Struct.members[:items]) + assert_equal(TrueClass, StructTest::Struct.members[:deleted]) + assert_equal([String], StructTest::Struct.members[:emails]) + end + + def test_initializer_and_lookup + s = StructTest::Struct.new(:id => 5, + :name => 'hello', + :items => ['one', 'two'], + :deleted => true, + :emails => ['test@test.com']) + assert_equal(5, s.id) + assert_equal('hello', s.name) + assert_equal(['one', 'two'], s.items) + assert_equal(true, s.deleted) + assert_equal(['test@test.com'], s.emails) + assert_equal(5, s['id']) + assert_equal('hello', s['name']) + assert_equal(['one', 'two'], s['items']) + assert_equal(true, s['deleted']) + assert_equal(['test@test.com'], s['emails']) + end +end -- cgit v1.2.3