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 --- actionservice/test/abstract_client.rb | 124 ----------- actionservice/test/abstract_soap.rb | 58 ------ actionservice/test/abstract_unit.rb | 9 - actionservice/test/api_test.rb | 52 ----- actionservice/test/base_test.rb | 42 ---- actionservice/test/client_soap_test.rb | 87 -------- actionservice/test/client_xmlrpc_test.rb | 86 -------- actionservice/test/container_test.rb | 53 ----- actionservice/test/invocation_test.rb | 158 -------------- actionservice/test/protocol_registry_test.rb | 53 ----- actionservice/test/protocol_soap_test.rb | 226 --------------------- actionservice/test/protocol_xmlrpc_test.rb | 157 -------------- .../test/router_action_controller_test.rb | 139 ------------- actionservice/test/router_wsdl_test.rb | 100 --------- actionservice/test/struct_test.rb | 40 ---- 15 files changed, 1384 deletions(-) delete mode 100644 actionservice/test/abstract_client.rb delete mode 100644 actionservice/test/abstract_soap.rb delete mode 100644 actionservice/test/abstract_unit.rb delete mode 100644 actionservice/test/api_test.rb delete mode 100644 actionservice/test/base_test.rb delete mode 100644 actionservice/test/client_soap_test.rb delete mode 100644 actionservice/test/client_xmlrpc_test.rb delete mode 100644 actionservice/test/container_test.rb delete mode 100644 actionservice/test/invocation_test.rb delete mode 100644 actionservice/test/protocol_registry_test.rb delete mode 100644 actionservice/test/protocol_soap_test.rb delete mode 100644 actionservice/test/protocol_xmlrpc_test.rb delete mode 100644 actionservice/test/router_action_controller_test.rb delete mode 100644 actionservice/test/router_wsdl_test.rb delete mode 100644 actionservice/test/struct_test.rb (limited to 'actionservice/test') diff --git a/actionservice/test/abstract_client.rb b/actionservice/test/abstract_client.rb deleted file mode 100644 index 70d2d21124..0000000000 --- a/actionservice/test/abstract_client.rb +++ /dev/null @@ -1,124 +0,0 @@ -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/actionservice/test/abstract_soap.rb b/actionservice/test/abstract_soap.rb deleted file mode 100644 index 7454be9bdf..0000000000 --- a/actionservice/test/abstract_soap.rb +++ /dev/null @@ -1,58 +0,0 @@ -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/actionservice/test/abstract_unit.rb b/actionservice/test/abstract_unit.rb deleted file mode 100644 index 54ca73b35c..0000000000 --- a/actionservice/test/abstract_unit.rb +++ /dev/null @@ -1,9 +0,0 @@ -$:.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/actionservice/test/api_test.rb b/actionservice/test/api_test.rb deleted file mode 100644 index 2ef5cc7bda..0000000000 --- a/actionservice/test/api_test.rb +++ /dev/null @@ -1,52 +0,0 @@ -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/actionservice/test/base_test.rb b/actionservice/test/base_test.rb deleted file mode 100644 index a9fbdd1a8b..0000000000 --- a/actionservice/test/base_test.rb +++ /dev/null @@ -1,42 +0,0 @@ -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/actionservice/test/client_soap_test.rb b/actionservice/test/client_soap_test.rb deleted file mode 100644 index 80fae90543..0000000000 --- a/actionservice/test/client_soap_test.rb +++ /dev/null @@ -1,87 +0,0 @@ -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/actionservice/test/client_xmlrpc_test.rb b/actionservice/test/client_xmlrpc_test.rb deleted file mode 100644 index 35768adf32..0000000000 --- a/actionservice/test/client_xmlrpc_test.rb +++ /dev/null @@ -1,86 +0,0 @@ -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/actionservice/test/container_test.rb b/actionservice/test/container_test.rb deleted file mode 100644 index 8c66651b64..0000000000 --- a/actionservice/test/container_test.rb +++ /dev/null @@ -1,53 +0,0 @@ -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/actionservice/test/invocation_test.rb b/actionservice/test/invocation_test.rb deleted file mode 100644 index e4c82a35f8..0000000000 --- a/actionservice/test/invocation_test.rb +++ /dev/null @@ -1,158 +0,0 @@ -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/actionservice/test/protocol_registry_test.rb b/actionservice/test/protocol_registry_test.rb deleted file mode 100644 index 8e2b9659a6..0000000000 --- a/actionservice/test/protocol_registry_test.rb +++ /dev/null @@ -1,53 +0,0 @@ -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/actionservice/test/protocol_soap_test.rb b/actionservice/test/protocol_soap_test.rb deleted file mode 100644 index 164d06bbd6..0000000000 --- a/actionservice/test/protocol_soap_test.rb +++ /dev/null @@ -1,226 +0,0 @@ -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/actionservice/test/protocol_xmlrpc_test.rb b/actionservice/test/protocol_xmlrpc_test.rb deleted file mode 100644 index a8a6efc07e..0000000000 --- a/actionservice/test/protocol_xmlrpc_test.rb +++ /dev/null @@ -1,157 +0,0 @@ -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/actionservice/test/router_action_controller_test.rb b/actionservice/test/router_action_controller_test.rb deleted file mode 100644 index e26d67c194..0000000000 --- a/actionservice/test/router_action_controller_test.rb +++ /dev/null @@ -1,139 +0,0 @@ -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/actionservice/test/router_wsdl_test.rb b/actionservice/test/router_wsdl_test.rb deleted file mode 100644 index 6812d25579..0000000000 --- a/actionservice/test/router_wsdl_test.rb +++ /dev/null @@ -1,100 +0,0 @@ -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/actionservice/test/struct_test.rb b/actionservice/test/struct_test.rb deleted file mode 100644 index b883c6d991..0000000000 --- a/actionservice/test/struct_test.rb +++ /dev/null @@ -1,40 +0,0 @@ -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