Ousted ActionWebService from Rails 2.0

git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@8180 5ecf4fe2-1ee6-0310-87b1-e25e094e27de

21 files changed, 0 insertions, 2112 deletions

diff --git a/actionwebservice/test/abstract_client.rb b/actionwebservice/test/abstract_client.rb
deleted file mode 100644
index 467c4e0d5b..0000000000
--- a/actionwebservice/test/abstract_client.rb
+++ /dev/null
@@ -1,183 +0,0 @@
-require File.dirname(__FILE__) + '/abstract_unit'
-require 'webrick'
-require 'webrick/log'
-require 'singleton'
-
-module ClientTest
-  class Person < ActionWebService::Struct
-    member :firstnames, [:string]
-    member :lastname,   :string
-
-    def ==(other)
-      firstnames == other.firstnames && lastname == other.lastname
-    end
-  end
-  
-  class Inner < ActionWebService::Struct
-    member :name, :string
-  end
-  
-  class Outer < ActionWebService::Struct
-    member :name, :string
-    member :inner, Inner
-  end
-
-  class User < ActiveRecord::Base
-  end
-  
-  module Accounting
-    class User < ActiveRecord::Base
-    end
-  end
-  
-  class WithModel < ActionWebService::Struct
-    member :user, User
-    member :users, [User]
-  end
-  
-  class WithMultiDimArray < ActionWebService::Struct
-    member :pref, [[:string]]
-  end
-
-  class API < ActionWebService::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 :nil_struct_return,    :returns => [Person] 
-    api_method :inner_nil,            :returns => [Outer]
-    api_method :client_container,     :returns => [:int]
-    api_method :named_parameters,     :expects => [{:key=>:string}, {:id=>:int}]
-    api_method :thrower
-    api_method :user_return,          :returns => [User]
-    api_method :with_model_return,    :returns => [WithModel]
-    api_method :scoped_model_return,  :returns => [Accounting::User]
-    api_method :multi_dim_return,     :returns => [WithMultiDimArray]
-  end
-  
-  class NullLogOut
-    def <<(*args); end
-  end
-
-  class Container < ActionController::Base
-    web_service_api API
-
-    attr_accessor :value_void
-    attr_accessor :value_normal
-    attr_accessor :value_array_return
-    attr_accessor :value_struct_pass
-    attr_accessor :value_named_parameters
-
-    def initialize
-      @value_void = nil
-      @value_normal = nil
-      @value_array_return = nil
-      @value_struct_pass = nil
-      @value_named_parameters = 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 nil_struct_return
-      nil
-    end
-    
-    def inner_nil
-      Outer.new :name => 'outer', :inner => nil
-    end
-
-    def client_container
-      50
-    end
-
-    def named_parameters
-      @value_named_parameters = @method_params
-    end
-
-    def thrower
-      raise "Hi"
-    end
-    
-    def user_return
-      User.find(1)
-    end
-    
-    def with_model_return
-      WithModel.new :user => User.find(1), :users => User.find(:all)
-    end
-    
-    def scoped_model_return
-      Accounting::User.find(1)
-    end
-    
-    def multi_dim_return
-      WithMultiDimArray.new :pref => [%w{pref1 value1}, %w{pref2 value2}]
-    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_dispatcher.rb b/actionwebservice/test/abstract_dispatcher.rb
deleted file mode 100644
index c15af41797..0000000000
--- a/actionwebservice/test/abstract_dispatcher.rb
+++ /dev/null
@@ -1,551 +0,0 @@
-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
-
-  def test_allowed_http_methods
-    webservice_api = @direct_controller.class.web_service_api
-    original_allowed_http_methods = webservice_api.allowed_http_methods
-    
-    # check defaults
-    assert_equal false, http_method_allowed?(:get)
-    assert_equal false, http_method_allowed?(:head)
-    assert_equal false, http_method_allowed?(:put)
-    assert_equal false, http_method_allowed?(:delete)
-    assert_equal false, http_method_allowed?(:trace)
-    assert_equal false, http_method_allowed?(:connect)
-    assert_equal true,  http_method_allowed?(:post)
-    
-    # allow get and post
-    webservice_api.allowed_http_methods = [ :get, :post ]
-    assert_equal true,  http_method_allowed?(:get)
-    assert_equal true,  http_method_allowed?(:post)
-
-    # allow get only
-    webservice_api.allowed_http_methods = [ :get ]
-    assert_equal true,  http_method_allowed?(:get)
-    assert_equal false, http_method_allowed?(:post)
-    
-    # allow delete only
-    webservice_api.allowed_http_methods = [ 'DELETE' ]
-    assert_equal false, http_method_allowed?(:get)
-    assert_equal false, http_method_allowed?(:head)
-    assert_equal false, http_method_allowed?(:post)
-    assert_equal false, http_method_allowed?(:put)
-    assert_equal false, http_method_allowed?(:trace)
-    assert_equal false, http_method_allowed?(:connect)
-    assert_equal true,  http_method_allowed?(:delete)
-    
-  ensure
-    webservice_api.allowed_http_methods = original_allowed_http_methods    
-  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
-    
-    def http_method_allowed?(method)
-      method = method.to_s.upcase
-      test_request = ActionController::TestRequest.new({ 'action' => 'api' })
-      test_response = ActionController::TestResponse.new
-      test_request.env['REQUEST_METHOD'] = method
-      result = @direct_controller.process(test_request, test_response)
-      result.body =~ /(GET|POST|PUT|DELETE|TRACE|CONNECT) not supported/ ? false : true
-    end
-end
diff --git a/actionwebservice/test/abstract_unit.rb b/actionwebservice/test/abstract_unit.rb
deleted file mode 100644
index b7088c43f3..0000000000
--- a/actionwebservice/test/abstract_unit.rb
+++ /dev/null
@@ -1,45 +0,0 @@
-ENV["RAILS_ENV"] = "test"
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-$:.unshift(File.dirname(__FILE__) + '/../../activesupport/lib')
-$:.unshift(File.dirname(__FILE__) + '/../../actionpack/lib')
-$:.unshift(File.dirname(__FILE__) + '/../../activerecord/lib')
-
-require 'test/unit'
-require 'action_web_service'
-require 'action_controller'
-require 'action_controller/test_process'
-
-# Show backtraces for deprecated behavior for quicker cleanup.
-ActiveSupport::Deprecation.debug = true
-
-
-ActionController::Base.logger = Logger.new("debug.log")
-ActionController::Base.ignore_missing_templates = true
-
-begin
-  PATH_TO_AR = File.dirname(__FILE__) + '/../../activerecord'
-  require "#{PATH_TO_AR}/lib/active_record" unless Object.const_defined?(:ActiveRecord)
-  require "#{PATH_TO_AR}/lib/active_record/fixtures" unless Object.const_defined?(:Fixtures)
-rescue LoadError => e
-  fail "\nFailed to load activerecord: #{e}"
-end
-
-ActiveRecord::Base.configurations = {
-  'mysql' => {
-    :adapter  => "mysql",
-    :username => "rails",
-    :encoding => "utf8",
-    :database => "actionwebservice_unittest"
-  }
-}
-
-ActiveRecord::Base.establish_connection 'mysql'
-
-Test::Unit::TestCase.fixture_path = "#{File.dirname(__FILE__)}/fixtures/"
-
-# restore default raw_post functionality
-class ActionController::TestRequest
-  def raw_post
-    super
-  end
-end
diff --git a/actionwebservice/test/api_test.rb b/actionwebservice/test/api_test.rb
deleted file mode 100644
index 0e58d84864..0000000000
--- a/actionwebservice/test/api_test.rb
+++ /dev/null
@@ -1,102 +0,0 @@
-require File.dirname(__FILE__) + '/abstract_unit'
-
-module APITest
-  class API < ActionWebService::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', 'base64']
-    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(nil, API.api_methods[:void].expects)
-    assert_equal(nil, API.api_methods[:void].returns)
-    assert_equal([String], API.api_methods[:expects_and_returns].expects.map{|x| x.type_class})
-    assert_equal([String], API.api_methods[:expects_and_returns].returns.map{|x| x.type_class})
-    assert_equal([Integer, TrueClass], API.api_methods[:expects].expects.map{|x| x.type_class})
-    assert_equal(nil, API.api_methods[:expects].returns)
-    assert_equal(nil, API.api_methods[:returns].expects)
-    assert_equal([Integer, [String]], API.api_methods[:returns].returns.map{|x| x.array?? [x.element_type.type_class] : x.type_class})
-    assert_equal([[:appkey, Integer], [:publish, TrueClass]], API.api_methods[:named_signature].expects.map{|x| [x.name, x.type_class]})
-    assert_equal(nil, API.api_methods[:named_signature].returns)
-    assert_equal([Integer, String, TrueClass, ActionWebService::Base64], API.api_methods[:string_types].expects.map{|x| x.type_class})
-    assert_equal(nil, API.api_methods[:string_types].returns)
-    assert_equal([TrueClass, Integer, String], API.api_methods[:class_types].expects.map{|x| x.type_class})
-    assert_equal(nil, API.api_methods[:class_types].returns)
-  end
-
-  def test_not_instantiable
-    assert_raises(NoMethodError) do
-      API.new
-    end
-  end
-
-  def test_api_errors
-    assert_raises(ActionWebService::ActionWebServiceError) do
-      klass = Class.new(ActionWebService::API::Base) do
-        api_method :test, :expects => [ActiveRecord::Base]
-      end
-    end
-    klass = Class.new(ActionWebService::API::Base) do
-      allow_active_record_expects true
-      api_method :test2, :expects => [ActiveRecord::Base]
-    end
-    assert_raises(ActionWebService::ActionWebServiceError) do
-      klass = Class.new(ActionWebService::API::Base) do
-        api_method :test, :invalid => [:int]
-      end
-    end
-  end
-
-  def test_parameter_names
-    method = API.api_methods[:named_signature]
-    assert_equal 0, method.expects_index_of(:appkey)
-    assert_equal 1, method.expects_index_of(:publish)
-    assert_equal 1, method.expects_index_of('publish')
-    assert_equal 0, method.expects_index_of('appkey')
-    assert_equal -1, method.expects_index_of('blah')
-    assert_equal -1, method.expects_index_of(:missing)
-    assert_equal -1, API.api_methods[:void].expects_index_of('test')
-  end
-
-  def test_parameter_hash
-    method = API.api_methods[:named_signature]
-    hash = method.expects_to_hash([5, false])
-    assert_equal({:appkey => 5, :publish => false}, hash)
-  end
-
-  def test_api_methods_compat
-    sig = API.api_methods[:named_signature][:expects]
-    assert_equal [{:appkey=>Integer}, {:publish=>TrueClass}], sig
-  end
-
-  def test_to_s
-    assert_equal 'void Expects(int param0, bool param1)', APITest::API.api_methods[:expects].to_s
-  end
-end
diff --git a/actionwebservice/test/apis/auto_load_api.rb b/actionwebservice/test/apis/auto_load_api.rb
deleted file mode 100644
index a35bbe3ff7..0000000000
--- a/actionwebservice/test/apis/auto_load_api.rb
+++ /dev/null
@@ -1,3 +0,0 @@
-class AutoLoadAPI < ActionWebService::API::Base
-  api_method :void
-end
diff --git a/actionwebservice/test/apis/broken_auto_load_api.rb b/actionwebservice/test/apis/broken_auto_load_api.rb
deleted file mode 100644
index 139597f9cb..0000000000
--- a/actionwebservice/test/apis/broken_auto_load_api.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-
-
diff --git a/actionwebservice/test/base_test.rb b/actionwebservice/test/base_test.rb
deleted file mode 100644
index 55a112a089..0000000000
--- a/actionwebservice/test/base_test.rb
+++ /dev/null
@@ -1,42 +0,0 @@
-require File.dirname(__FILE__) + '/abstract_unit'
-
-module BaseTest
-  class API < ActionWebService::API::Base
-    api_method :add, :expects => [:int, :int], :returns => [:int]
-    api_method :void
-  end
-
-  class PristineAPI < ActionWebService::API::Base
-    inflect_names false
-
-    api_method :add
-    api_method :under_score
-  end
-
-  class Service < ActionWebService::Base
-    web_service_api API
-
-    def add(a, b)
-    end
-  
-    def void
-    end
-  end
-  
-  class PristineService < ActionWebService::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/casting_test.rb b/actionwebservice/test/casting_test.rb
deleted file mode 100644
index 34bad07d5b..0000000000
--- a/actionwebservice/test/casting_test.rb
+++ /dev/null
@@ -1,86 +0,0 @@
-require File.dirname(__FILE__) + '/abstract_unit'
-
-module CastingTest
-  class API < ActionWebService::API::Base
-    api_method :int,       :expects => [:int]
-    api_method :str,       :expects => [:string]
-    api_method :base64,    :expects => [:base64]
-    api_method :bool,      :expects => [:bool]
-    api_method :float,     :expects => [:float]
-    api_method :time,      :expects => [:time]
-    api_method :datetime,  :expects => [:datetime]
-    api_method :date,      :expects => [:date]
-
-    api_method :int_array,   :expects => [[:int]]
-    api_method :str_array,   :expects => [[:string]]
-    api_method :bool_array,  :expects => [[:bool]]
-  end
-end
-
-class TC_Casting < Test::Unit::TestCase
-  include CastingTest
-
-  def test_base_type_casting_valid
-    assert_equal 10000,   cast_expects(:int, '10000')[0]
-    assert_equal '10000', cast_expects(:str, 10000)[0]
-    base64 = cast_expects(:base64, 10000)[0]
-    assert_equal '10000', base64
-    assert_instance_of ActionWebService::Base64, base64
-    [1, '1', 'true', 'y', 'yes'].each do |val|
-      assert_equal true, cast_expects(:bool, val)[0]
-    end
-    [0, '0', 'false', 'n', 'no'].each do |val|
-      assert_equal false, cast_expects(:bool, val)[0]
-    end
-    assert_equal 3.14159, cast_expects(:float, '3.14159')[0]
-    now = Time.at(Time.now.tv_sec)
-    casted = cast_expects(:time, now.to_s)[0]
-    assert_equal now, casted
-    now = DateTime.now
-    assert_equal now.to_s, cast_expects(:datetime, now.to_s)[0].to_s
-    today = Date.today
-    assert_equal today, cast_expects(:date, today.to_s)[0]
-  end
-
-  def test_base_type_casting_invalid
-    assert_raises ArgumentError do
-      cast_expects(:int, 'this is not a number')
-    end
-    assert_raises ActionWebService::Casting::CastingError do
-      # neither true or false ;)
-      cast_expects(:bool, 'i always lie')
-    end
-    assert_raises ArgumentError do
-      cast_expects(:float, 'not a float')
-    end
-    assert_raises ArgumentError do
-      cast_expects(:time, '111111111111111111111111111111111')
-    end
-    assert_raises ArgumentError do
-      cast_expects(:datetime, '-1')
-    end
-    assert_raises ArgumentError do
-      cast_expects(:date, '')
-    end
-  end
-
-  def test_array_type_casting
-    assert_equal [1, 2, 3213992, 4], cast_expects(:int_array, ['1', '2', '3213992', '4'])[0]
-    assert_equal ['one', 'two', '5.0', '200', nil, 'true'], cast_expects(:str_array, [:one, 'two', 5.0, 200, nil, true])[0]
-    assert_equal [true, nil, true, true, false], cast_expects(:bool_array, ['1', nil, 'y', true, 'false'])[0]
-  end
-
-  def test_array_type_casting_failure
-    assert_raises ActionWebService::Casting::CastingError do
-      cast_expects(:bool_array, ['false', 'blahblah'])
-    end
-    assert_raises ArgumentError do
-      cast_expects(:int_array, ['1', '2.021', '4'])
-    end
-  end
-
-  private
-    def cast_expects(method_name, *args)
-      API.api_method_instance(method_name.to_sym).cast_expects([*args])
-    end
-end
diff --git a/actionwebservice/test/client_soap_test.rb b/actionwebservice/test/client_soap_test.rb
deleted file mode 100644
index 914bf377ea..0000000000
--- a/actionwebservice/test/client_soap_test.rb
+++ /dev/null
@@ -1,153 +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
-      response = ActionController::TestResponse.new
-      @controller.process(test_request, response)
-      res.header['content-type'] = 'text/xml'
-      res.body = response.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
-    web_client_api :invalid, :null, "", :api => true
-
-    def get_client
-      client
-    end
-
-    def get_invalid
-      invalid
-    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
-  
-  fixtures :users
-
-  def setup
-    @server = SoapServer.instance
-    @container = @server.container
-    @client = ActionWebService::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)
-    assert_equal(5, @client.normal("7", "8"))
-    assert_equal([7, 8], @container.value_normal)
-    assert_equal(5, @client.normal(true, false))
-  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_nil_struct_return
-    assert_nil @client.nil_struct_return
-  end
-  
-  def test_inner_nil
-    outer = @client.inner_nil
-    assert_equal 'outer', outer.name
-    assert_nil outer.inner
-  end
-
-  def test_client_container
-    assert_equal(50, ClientContainer.new.get_client.client_container)
-    assert(ClientContainer.new.get_invalid.nil?)
-  end
-
-  def test_named_parameters
-    assert(@container.value_named_parameters.nil?)
-    assert(@client.named_parameters("key", 5).nil?)
-    assert_equal(["key", 5], @container.value_named_parameters)
-  end
-
-  def test_capitalized_method_name
-    @container.value_normal = nil
-    assert_equal(5, @client.Normal(5, 6))
-    assert_equal([5, 6], @container.value_normal)
-    @container.value_normal = nil
-  end
-  
-  def test_model_return
-    user = @client.user_return
-    assert_equal 1, user.id
-    assert_equal 'Kent', user.name
-    assert user.active?
-    assert_kind_of Date, user.created_on
-    assert_equal Date.today, user.created_on
-    assert_equal BigDecimal('12.2'), user.balance
-  end
-  
-  def test_with_model
-    with_model = @client.with_model_return
-    assert_equal 'Kent', with_model.user.name
-    assert_equal 2, with_model.users.size
-    with_model.users.each do |user|
-      assert_kind_of User, user
-    end
-  end
-  
-  def test_scoped_model_return
-    scoped_model = @client.scoped_model_return
-    assert_kind_of Accounting::User, scoped_model
-    assert_equal 'Kent', scoped_model.name
-  end
-  
-  def test_multi_dim_return
-    md_struct = @client.multi_dim_return
-    assert_kind_of Array, md_struct.pref
-    assert_equal 2, md_struct.pref.size
-    assert_kind_of Array, md_struct.pref[0]
-  end
-end
diff --git a/actionwebservice/test/client_xmlrpc_test.rb b/actionwebservice/test/client_xmlrpc_test.rb
deleted file mode 100644
index 896ec5951c..0000000000
--- a/actionwebservice/test/client_xmlrpc_test.rb
+++ /dev/null
@@ -1,152 +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_CONTENT_TYPE'] = 'text/xml'
-      test_request.env['RAW_POST_DATA'] = req.body
-      response = ActionController::TestResponse.new
-      @controller.process(test_request, response) 
-      res.header['content-type'] = 'text/xml'
-      res.body = response.body
-      # puts res.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
-  
-  fixtures :users
-
-  def setup
-    @server = XmlRpcServer.instance
-    @container = @server.container
-    @client = ActionWebService::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)
-    assert_equal(5, @client.normal("7", "8"))
-    assert_equal([7, 8], @container.value_normal)
-    assert_equal(5, @client.normal(true, false))
-  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_nil_struct_return
-    assert_equal false, @client.nil_struct_return
-  end
-
-  def test_inner_nil
-    outer = @client.inner_nil
-    assert_equal 'outer', outer.name
-    assert_nil outer.inner
-  end
-
-  def test_client_container
-    assert_equal(50, ClientContainer.new.get_client.client_container)
-  end
-
-  def test_named_parameters
-    assert(@container.value_named_parameters.nil?)
-    assert_equal(false, @client.named_parameters("xxx", 7))
-    assert_equal(["xxx", 7], @container.value_named_parameters)
-  end
-
-  def test_exception
-    assert_raises(ActionWebService::Client::ClientError) do
-      assert(@client.thrower)
-    end
-  end
-
-  def test_invalid_signature
-    assert_raises(ArgumentError) do
-      @client.normal
-    end
-  end
-
-  def test_model_return
-    user = @client.user_return
-    assert_equal 1, user.id
-    assert_equal 'Kent', user.name
-    assert user.active?
-    assert_kind_of Time, user.created_on
-    assert_equal Time.utc(Time.now.year, Time.now.month, Time.now.day), user.created_on
-    assert_equal BigDecimal('12.2'), user.balance
-  end
-
-  def test_with_model
-    with_model = @client.with_model_return
-    assert_equal 'Kent', with_model.user.name
-    assert_equal 2, with_model.users.size
-    with_model.users.each do |user|
-      assert_kind_of User, user
-    end
-  end
-  
-  def test_scoped_model_return
-    scoped_model = @client.scoped_model_return
-    assert_kind_of Accounting::User, scoped_model
-    assert_equal 'Kent', scoped_model.name
-  end
-
-  def test_multi_dim_return
-    md_struct = @client.multi_dim_return
-    assert_kind_of Array, md_struct.pref
-    assert_equal 2, md_struct.pref.size
-    assert_kind_of Array, md_struct.pref[0]
-  end
-end
diff --git a/actionwebservice/test/container_test.rb b/actionwebservice/test/container_test.rb
deleted file mode 100644
index 325d420f24..0000000000
--- a/actionwebservice/test/container_test.rb
+++ /dev/null
@@ -1,73 +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
-
-  class InvalidContainer
-    include ActionWebService::Container::Direct
-  end
-end
-
-class TC_Container < Test::Unit::TestCase
-  include ContainerTest
-
-  def setup
-    @delegate_container = DelegateContainer.new
-    @direct_container = DirectContainer.new
-  end
-
-  def test_registration
-    assert(DelegateContainer.has_web_service?(:immediate_service))
-    assert(DelegateContainer.has_web_service?(:deferred_service))
-    assert(!DelegateContainer.has_web_service?(:fake_service))
-    assert_raises(ActionWebService::Container::Delegated::ContainerError) do
-      DelegateContainer.web_service('invalid')
-    end
-  end
-
-  def test_service_object
-    assert_raises(ActionWebService::Container::Delegated::ContainerError) do
-      @delegate_container.web_service_object(:nonexistent)
-    end
-    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(DirectContainer.web_service_dispatching_mode == :direct)
-  end
-
-  def test_validity
-    assert_raises(ActionWebService::Container::Direct::ContainerError) do 
-      InvalidContainer.web_service_api :test
-    end
-    assert_raises(ActionWebService::Container::Direct::ContainerError) do 
-      InvalidContainer.web_service_api 50.0
-    end
-  end
-end
diff --git a/actionwebservice/test/dispatcher_action_controller_soap_test.rb b/actionwebservice/test/dispatcher_action_controller_soap_test.rb
deleted file mode 100644
index 0b58af3006..0000000000
--- a/actionwebservice/test/dispatcher_action_controller_soap_test.rb
+++ /dev/null
@@ -1,137 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + '/apis')
-require File.dirname(__FILE__) + '/abstract_dispatcher'
-require 'wsdl/parser'
-
-class ActionController::Base
-  class << self
-    alias :inherited_without_name_error :inherited
-    def inherited(child)
-      begin
-        inherited_without_name_error(child)
-      rescue NameError => e
-      end
-    end
-  end
-end
-
-class AutoLoadController < ActionController::Base; end
-class FailingAutoLoadController < ActionController::Base; end
-class BrokenAutoLoadController < ActionController::Base; end
-
-class TC_DispatcherActionControllerSoap < Test::Unit::TestCase
-  include DispatcherTest
-  include DispatcherCommonTests
-
-  def setup
-    @direct_controller = DirectController.new
-    @delegated_controller = DelegatedController.new
-    @virtual_controller = VirtualController.new
-    @layered_controller = LayeredController.new
-    @protocol = ActionWebService::Protocol::Soap::SoapProtocol.create(@direct_controller)
-  end
-
-  def test_wsdl_generation
-    ensure_valid_wsdl_generation DelegatedController.new, DispatcherTest::WsdlNamespace
-    ensure_valid_wsdl_generation DirectController.new, DispatcherTest::WsdlNamespace
-  end
-
-  def test_wsdl_action
-    delegated_types = ensure_valid_wsdl_action DelegatedController.new
-    delegated_names = delegated_types.map{|x| x.name.name}
-    assert(delegated_names.include?('DispatcherTest..NodeArray'))
-    assert(delegated_names.include?('DispatcherTest..Node'))
-    direct_types = ensure_valid_wsdl_action DirectController.new
-    direct_names = direct_types.map{|x| x.name.name}
-    assert(direct_names.include?('DispatcherTest..NodeArray'))
-    assert(direct_names.include?('DispatcherTest..Node'))
-    assert(direct_names.include?('IntegerArray'))
-  end
-
-  def test_autoloading
-    assert(!AutoLoadController.web_service_api.nil?)
-    assert(AutoLoadController.web_service_api.has_public_api_method?('Void'))
-    assert(FailingAutoLoadController.web_service_api.nil?)
-    assert_raises(MissingSourceFile) do
-      FailingAutoLoadController.require_web_service_api :blah
-    end
-    assert_raises(ArgumentError) do
-      FailingAutoLoadController.require_web_service_api 50.0
-    end
-    assert(BrokenAutoLoadController.web_service_api.nil?)
-  end
-
-  def test_layered_dispatching
-    mt_cats = do_method_call(@layered_controller, 'mt.getCategories')
-    assert_equal(["mtCat1", "mtCat2"], mt_cats)
-    blogger_cats = do_method_call(@layered_controller, 'blogger.getCategories')
-    assert_equal(["bloggerCat1", "bloggerCat2"], blogger_cats)
-  end
-
-  def test_utf8
-    @direct_controller.web_service_exception_reporting = true
-    $KCODE = 'u'
-    assert_equal(Utf8String, do_method_call(@direct_controller, 'TestUtf8'))
-    retval = SOAP::Processor.unmarshal(@response_body).body.response
-    assert retval.is_a?(SOAP::SOAPString)
-
-    # If $KCODE is not set to UTF-8, any strings with non-ASCII UTF-8 data
-    # will be sent back as base64 by SOAP4R. By the time we get it here though,
-    # it will be decoded back into a string. So lets read the base64 value
-    # from the message body directly.
-    $KCODE = 'NONE'
-    do_method_call(@direct_controller, 'TestUtf8')
-    retval = SOAP::Processor.unmarshal(@response_body).body.response
-    assert retval.is_a?(SOAP::SOAPBase64)
-    assert_equal "T25lIFdvcmxkIENhZsOp", retval.data.to_s
-  end
-
-  protected
-    def exception_message(soap_fault_exception)
-      soap_fault_exception.detail.cause.message
-    end
-
-    def is_exception?(obj)
-      obj.respond_to?(:detail) && obj.detail.respond_to?(:cause) && \
-      obj.detail.cause.is_a?(Exception)
-    end
-
-    def service_name(container)
-      container.is_a?(DelegatedController) ? 'test_service' : 'api'
-    end
-
-    def ensure_valid_wsdl_generation(controller, expected_namespace)
-      wsdl = controller.generate_wsdl
-      ensure_valid_wsdl(controller, wsdl, expected_namespace)
-    end
-
-    def ensure_valid_wsdl(controller, wsdl, expected_namespace)
-      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
-      types = definitions.collect_complextypes.map{|x| x.name}
-      types.each do |type|
-        assert(type.namespace == expected_namespace)
-      end
-      location = definitions.services[0].ports[0].soap_address.location
-      if controller.is_a?(DelegatedController)
-        assert_match %r{http://test.host/dispatcher_test/delegated/test_service$}, location
-      elsif controller.is_a?(DirectController)
-        assert_match %r{http://test.host/dispatcher_test/direct/api$}, location
-      end
-      definitions.collect_complextypes
-    end
-
-    def ensure_valid_wsdl_action(controller)
-      test_request = ActionController::TestRequest.new({ 'action' => 'wsdl' })
-      test_response = ActionController::TestResponse.new
-      wsdl = controller.process(test_request, test_response).body
-      ensure_valid_wsdl(controller, wsdl, DispatcherTest::WsdlNamespace)
-    end
-end
diff --git a/actionwebservice/test/dispatcher_action_controller_xmlrpc_test.rb b/actionwebservice/test/dispatcher_action_controller_xmlrpc_test.rb
deleted file mode 100644
index 8add576620..0000000000
--- a/actionwebservice/test/dispatcher_action_controller_xmlrpc_test.rb
+++ /dev/null
@@ -1,59 +0,0 @@
-require File.dirname(__FILE__) + '/abstract_dispatcher'
-
-class TC_DispatcherActionControllerXmlRpc < Test::Unit::TestCase
-  include DispatcherTest
-  include DispatcherCommonTests
-
-  def setup
-    @direct_controller = DirectController.new
-    @delegated_controller = DelegatedController.new
-    @layered_controller = LayeredController.new
-    @virtual_controller = VirtualController.new
-    @protocol = ActionWebService::Protocol::XmlRpc::XmlRpcProtocol.create(@direct_controller)
-  end
-
-  def test_layered_dispatching
-    mt_cats = do_method_call(@layered_controller, 'mt.getCategories')
-    assert_equal(["mtCat1", "mtCat2"], mt_cats)
-    blogger_cats = do_method_call(@layered_controller, 'blogger.getCategories')
-    assert_equal(["bloggerCat1", "bloggerCat2"], blogger_cats)
-  end
-
-  def test_multicall
-    response = do_method_call(@layered_controller, 'system.multicall', [
-      {'methodName' => 'mt.getCategories'},
-      {'methodName' => 'blogger.getCategories'},
-      {'methodName' => 'mt.bool'},
-      {'methodName' => 'blogger.str', 'params' => ['2000']},
-      {'methodName' => 'mt.alwaysFail'},
-      {'methodName' => 'blogger.alwaysFail'},
-      {'methodName' => 'mt.blah'},
-      {'methodName' => 'blah.blah'},
-      {'methodName' => 'mt.person'}
-    ])
-    assert_equal [
-      [["mtCat1", "mtCat2"]],
-      [["bloggerCat1", "bloggerCat2"]],
-      [true],
-      ["2500"],
-      {"faultCode" => 3, "faultString" => "MT AlwaysFail"},
-      {"faultCode" => 3, "faultString" => "Blogger AlwaysFail"},
-      {"faultCode" => 4, "faultMessage" => "no such method 'blah' on API DispatcherTest::MTAPI"},
-      {"faultCode" => 4, "faultMessage" => "no such web service 'blah'"},
-      [{"name"=>"person1", "id"=>1}]
-    ], response
-  end
-
-  protected
-    def exception_message(xmlrpc_fault_exception)
-      xmlrpc_fault_exception.faultString
-    end
-
-    def is_exception?(obj)
-      obj.is_a?(XMLRPC::FaultException)
-    end
-
-    def service_name(container)
-      container.is_a?(DelegatedController) ? 'test_service' : 'api'
-    end
-end
diff --git a/actionwebservice/test/fixtures/db_definitions/mysql.sql b/actionwebservice/test/fixtures/db_definitions/mysql.sql
deleted file mode 100644
index 8e01eef453..0000000000
--- a/actionwebservice/test/fixtures/db_definitions/mysql.sql
+++ /dev/null
@@ -1,8 +0,0 @@
-CREATE TABLE `users` (
-  `id` int(11) NOT NULL auto_increment,
-  `name` varchar(30) default NULL,
-  `active` tinyint(4) default NULL,
-  `balance` decimal(5, 2) default NULL,
-  `created_on` date default NULL,
-  PRIMARY KEY  (`id`)
-) ENGINE=MyISAM DEFAULT CHARSET=latin1;
diff --git a/actionwebservice/test/fixtures/users.yml b/actionwebservice/test/fixtures/users.yml
deleted file mode 100644
index 926d6015f5..0000000000
--- a/actionwebservice/test/fixtures/users.yml
+++ /dev/null
@@ -1,12 +0,0 @@
-user1:
-  id: 1
-  name: Kent
-  active: 1
-  balance: 12.2
-  created_on: <%= Date.today %>
-user2:
-  id: 2
-  name: David
-  active: 1
-  balance: 16.4
-  created_on: <%= Date.today %>
diff --git a/actionwebservice/test/gencov b/actionwebservice/test/gencov
deleted file mode 100755
index 1faab34c07..0000000000
--- a/actionwebservice/test/gencov
+++ /dev/null
@@ -1,3 +0,0 @@
-#!/bin/sh
-
-rcov -x '.*_test\.rb,rubygems,abstract_,/run,/apis' ./run
diff --git a/actionwebservice/test/invocation_test.rb b/actionwebservice/test/invocation_test.rb
deleted file mode 100644
index 3ef22fafeb..0000000000
--- a/actionwebservice/test/invocation_test.rb
+++ /dev/null
@@ -1,185 +0,0 @@
-require File.dirname(__FILE__) + '/abstract_unit'
-
-module InvocationTest
-  class API < ActionWebService::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 Interceptor
-    attr :args
-
-    def initialize
-      @args = nil
-    end
-
-    def intercept(*args)
-      @args = args
-    end
-  end
-
-  InterceptorClass = Interceptor.new 
-
-  class Service < ActionController::Base
-    web_service_api API
-
-    before_invocation :intercept_before, :except => [:no_before]
-    after_invocation :intercept_after, :except => [:no_after]
-    prepend_after_invocation :intercept_after_first, :except => [:no_after]
-    prepend_before_invocation :intercept_only, :only => [:only_one, :only_two]
-    after_invocation(:only => [:only_one]) do |*args| 
-      args[0].instance_variable_set('@block_invoked', args[1])
-    end
-    after_invocation InterceptorClass, :only => [:only_one]
-
-    attr_accessor :before_invoked
-    attr_accessor :after_invoked
-    attr_accessor :after_first_invoked
-    attr_accessor :only_invoked
-    attr_accessor :block_invoked
-    attr_accessor :invocation_result
-  
-    def initialize
-      @before_invoked = nil
-      @after_invoked = nil
-      @after_first_invoked = nil
-      @only_invoked = nil
-      @invocation_result = nil
-      @block_invoked = 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
-  
-    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_after_first(name, args, result)
-        @after_first_invoked = name
-      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 ActionWebService::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(NoMethodError) 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 == 4)
-    assert_equal(:intercept_only, InvocationTest::Service.before_invocation_interceptors[0])
-    assert_equal(:intercept_after_first, InvocationTest::Service.after_invocation_interceptors[0])
-  end
-
-  def test_interception
-    assert(@service.before_invoked.nil?)
-    assert(@service.after_invoked.nil?)
-    assert(@service.only_invoked.nil?)
-    assert(@service.block_invoked.nil?)
-    assert(@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_first_invoked == :no_before)
-    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)
-    assert(@service.block_invoked == :only_one)
-    assert(InvocationTest::InterceptorClass.args[1] == :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)
-      @service.perform_invocation(method_name, args, &block)
-    end
-end
diff --git a/actionwebservice/test/run b/actionwebservice/test/run
deleted file mode 100755
index c8c0372776..0000000000
--- a/actionwebservice/test/run
+++ /dev/null
@@ -1,6 +0,0 @@
-#!/usr/bin/env ruby
-require 'test/unit'
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-args = Dir[File.join(File.dirname(__FILE__), '*_test.rb')] + Dir[File.join(File.dirname(__FILE__), 'ws/*_test.rb')]
-(r = Test::Unit::AutoRunner.new(true)).process_args(args)
-exit r.run
diff --git a/actionwebservice/test/scaffolded_controller_test.rb b/actionwebservice/test/scaffolded_controller_test.rb
deleted file mode 100644
index 722007cc99..0000000000
--- a/actionwebservice/test/scaffolded_controller_test.rb
+++ /dev/null
@@ -1,146 +0,0 @@
-require File.dirname(__FILE__) + '/abstract_unit'
-
-ActionController::Routing::Routes.draw do |map|
-  map.connect '', :controller => 'scaffolded'
-  map.connect ':controller/:action/:id'
-end
-
-ActionController::Base.view_paths = [ '.' ]
-
-class ScaffoldPerson < ActionWebService::Struct
-  member :id,     :int
-  member :name,   :string
-  member :birth,  :date
-
-  def ==(other)
-    self.id == other.id && self.name == other.name
-  end
-end
-
-class ScaffoldedControllerTestAPI < ActionWebService::API::Base
-  api_method :hello, :expects => [{:integer=>:int}, :string], :returns => [:bool]
-  api_method :hello_struct_param, :expects => [{:person => ScaffoldPerson}], :returns => [:bool]
-  api_method :date_of_birth, :expects => [ScaffoldPerson], :returns => [:string]
-  api_method :bye,   :returns => [[ScaffoldPerson]]
-  api_method :date_diff, :expects => [{:start_date => :date}, {:end_date => :date}], :returns => [:int]
-  api_method :time_diff, :expects => [{:start_time => :time}, {:end_time => :time}], :returns => [:int]
-  api_method :base64_upcase, :expects => [:base64], :returns => [:base64]
-end
-
-class ScaffoldedController < ActionController::Base
-  web_service_api ScaffoldedControllerTestAPI
-  web_service_scaffold :scaffold_invoke
-
-  def hello(int, string)
-    0
-  end
-  
-  def hello_struct_param(person)
-    0
-  end
-  
-  def date_of_birth(person)
-    person.birth.to_s
-  end
-
-  def bye
-    [ScaffoldPerson.new(:id => 1, :name => "leon"), ScaffoldPerson.new(:id => 2, :name => "paul")]
-  end
-
-  def rescue_action(e)
-    raise e
-  end
-  
-  def date_diff(start_date, end_date)
-    end_date - start_date
-  end
-  
-  def time_diff(start_time, end_time)
-    end_time - start_time
-  end
-  
-  def base64_upcase(data)
-    data.upcase
-  end
-end
-
-class ScaffoldedControllerTest < Test::Unit::TestCase
-  def setup
-    @controller = ScaffoldedController.new
-    @request    = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
-  end
-
-  def test_scaffold_invoke
-    get :scaffold_invoke
-    assert_template 'methods.erb'
-  end
-
-  def test_scaffold_invoke_method_params
-    get :scaffold_invoke_method_params, :service => 'scaffolded', :method => 'Hello'
-    assert_template 'parameters.erb'
-  end
-  
-  def test_scaffold_invoke_method_params_with_struct
-    get :scaffold_invoke_method_params, :service => 'scaffolded', :method => 'HelloStructParam'
-    assert_template 'parameters.erb'
-    assert_tag :tag => 'form'
-    assert_tag :tag => 'input', :attributes => {:name => "method_params[0][name]"}
-  end
-
-  def test_scaffold_invoke_submit_hello
-    post :scaffold_invoke_submit, :service => 'scaffolded', :method => 'Hello', :method_params => {'0' => '5', '1' => 'hello world'}
-    assert_template 'result.erb'
-    assert_equal false, @controller.instance_eval{ @method_return_value }
-  end
-
-  def test_scaffold_invoke_submit_bye
-    post :scaffold_invoke_submit, :service => 'scaffolded', :method => 'Bye'
-    assert_template 'result.erb'
-    persons = [ScaffoldPerson.new(:id => 1, :name => "leon"), ScaffoldPerson.new(:id => 2, :name => "paul")]
-    assert_equal persons, @controller.instance_eval{ @method_return_value }
-  end
-  
-  def test_scaffold_date_params
-    get :scaffold_invoke_method_params, :service => 'scaffolded', :method => 'DateDiff'
-    (0..1).each do |param|
-      (1..3).each do |date_part|
-        assert_tag :tag => 'select', :attributes => {:name => "method_params[#{param}][#{date_part}]"}, 
-                   :children => {:greater_than => 1, :only => {:tag => 'option'}}
-      end
-    end
-    
-    post :scaffold_invoke_submit, :service => 'scaffolded', :method => 'DateDiff', 
-         :method_params => {'0' => {'1' => '2006', '2' => '2', '3' => '1'}, '1' => {'1' => '2006', '2' => '2', '3' => '2'}}
-    assert_equal 1, @controller.instance_eval{ @method_return_value }
-  end
-  
-  def test_scaffold_struct_date_params
-    post :scaffold_invoke_submit, :service => 'scaffolded', :method => 'DateOfBirth', 
-         :method_params => {'0' => {'birth' => {'1' => '2006', '2' => '2', '3' => '1'}, 'id' => '1', 'name' => 'person'}}
-    assert_equal '2006-02-01', @controller.instance_eval{ @method_return_value }
-  end
-
-  def test_scaffold_time_params
-    get :scaffold_invoke_method_params, :service => 'scaffolded', :method => 'TimeDiff'
-    (0..1).each do |param|
-      (1..6).each do |date_part|
-        assert_tag :tag => 'select', :attributes => {:name => "method_params[#{param}][#{date_part}]"}, 
-                   :children => {:greater_than => 1, :only => {:tag => 'option'}}
-      end
-    end
-
-    post :scaffold_invoke_submit, :service => 'scaffolded', :method => 'TimeDiff', 
-         :method_params => {'0' => {'1' => '2006', '2' => '2', '3' => '1', '4' => '1', '5' => '1', '6' => '1'}, 
-                            '1' => {'1' => '2006', '2' => '2', '3' => '2', '4' => '1', '5' => '1', '6' => '1'}}
-    assert_equal 86400, @controller.instance_eval{ @method_return_value }
-  end
-  
-  def test_scaffold_base64
-    get :scaffold_invoke_method_params, :service => 'scaffolded', :method => 'Base64Upcase'
-    assert_tag :tag => 'textarea', :attributes => {:name => 'method_params[0]'}
-    
-    post :scaffold_invoke_submit, :service => 'scaffolded', :method => 'Base64Upcase', :method_params => {'0' => 'scaffold'}
-    assert_equal 'SCAFFOLD', @controller.instance_eval{ @method_return_value }
-  end
-end
diff --git a/actionwebservice/test/struct_test.rb b/actionwebservice/test/struct_test.rb
deleted file mode 100644
index f689746ee4..0000000000
--- a/actionwebservice/test/struct_test.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-require File.dirname(__FILE__) + '/abstract_unit'
-
-module StructTest
-  class Struct < ActionWebService::Struct
-    member :id, Integer
-    member :name, String
-    member :items, [String]
-    member :deleted, :bool
-    member :emails, [:string]
-  end
-end
-
-class TC_Struct < Test::Unit::TestCase
-  include StructTest
-
-  def setup
-    @struct = Struct.new(:id      => 5,
-                         :name    => 'hello',
-                         :items   => ['one', 'two'],
-                         :deleted => true,
-                         :emails  => ['test@test.com'])
-  end
-
-  def test_members
-    assert_equal(5, Struct.members.size)
-    assert_equal(Integer, Struct.members[:id].type_class)
-    assert_equal(String, Struct.members[:name].type_class)
-    assert_equal(String, Struct.members[:items].element_type.type_class)
-    assert_equal(TrueClass, Struct.members[:deleted].type_class)
-    assert_equal(String, Struct.members[:emails].element_type.type_class)
-  end
-
-  def test_initializer_and_lookup
-    assert_equal(5, @struct.id)
-    assert_equal('hello', @struct.name)
-    assert_equal(['one', 'two'], @struct.items)
-    assert_equal(true, @struct.deleted)
-    assert_equal(['test@test.com'], @struct.emails)
-    assert_equal(5, @struct['id'])
-    assert_equal('hello', @struct['name'])
-    assert_equal(['one', 'two'], @struct['items'])
-    assert_equal(true, @struct['deleted'])
-    assert_equal(['test@test.com'], @struct['emails'])
-  end
-
-  def test_each_pair
-    @struct.each_pair do |name, value|
-      assert_equal @struct.__send__(name), value
-      assert_equal @struct[name], value
-    end
-  end
-end
diff --git a/actionwebservice/test/test_invoke_test.rb b/actionwebservice/test/test_invoke_test.rb
deleted file mode 100644
index 72ebc71925..0000000000
--- a/actionwebservice/test/test_invoke_test.rb
+++ /dev/null
@@ -1,112 +0,0 @@
-require File.dirname(__FILE__) + '/abstract_unit'
-require 'action_web_service/test_invoke'
-
-class TestInvokeAPI < ActionWebService::API::Base
-  api_method :null
-  api_method :add, :expects => [:int, :int], :returns => [:int]
-end
-
-class TestInvokeService < ActionWebService::Base
-  web_service_api TestInvokeAPI
-
-  attr :invoked
-
-  def add(a, b)
-    @invoked = true
-    a + b
-  end
-  
-  def null
-  end
-end
-
-class TestController < ActionController::Base
-  def rescue_action(e); raise e; end
-end
-
-class TestInvokeDirectController < TestController
-  web_service_api TestInvokeAPI
-
-  attr :invoked
-
-  def add
-    @invoked = true
-    @method_params[0] + @method_params[1]
-  end
-
-  def null
-  end
-end
-
-class TestInvokeDelegatedController < TestController
-  web_service_dispatching_mode :delegated
-  web_service :service, TestInvokeService.new
-end
-
-class TestInvokeLayeredController < TestController
-  web_service_dispatching_mode :layered
-  web_service(:one) { @service_one ||= TestInvokeService.new }
-  web_service(:two) { @service_two ||= TestInvokeService.new }
-end
-
-class TestInvokeTest < Test::Unit::TestCase
-  def setup
-    @request  = ActionController::TestRequest.new
-    @response = ActionController::TestResponse.new
-  end
-
-  def test_direct_add
-    @controller = TestInvokeDirectController.new
-    assert_equal nil, @controller.invoked
-    result = invoke :add, 25, 25
-    assert_equal 50, result
-    assert_equal true, @controller.invoked
-  end
-
-  def test_delegated_add
-    @controller = TestInvokeDelegatedController.new
-    assert_equal nil, @controller.web_service_object(:service).invoked
-    result = invoke_delegated :service, :add, 100, 50
-    assert_equal 150, result
-    assert_equal true, @controller.web_service_object(:service).invoked
-  end
-
-  def test_layered_add
-    [:soap, :xmlrpc].each do |protocol|
-      @protocol = protocol
-      [:one, :two].each do |service|
-        @controller = TestInvokeLayeredController.new
-        assert_equal nil, @controller.web_service_object(service).invoked
-        result = invoke_layered service, :add, 200, -50
-        assert_equal 150, result
-        assert_equal true, @controller.web_service_object(service).invoked
-      end
-    end
-  end
-  
-  def test_layered_fail_with_wrong_number_of_arguments
-    [:soap, :xmlrpc].each do |protocol|
-      @protocol = protocol
-      [:one, :two].each do |service|
-        @controller = TestInvokeLayeredController.new
-        assert_raise(ArgumentError) { invoke_layered service, :add, 1 }
-      end
-    end
-  end
-
-  def test_delegated_fail_with_wrong_number_of_arguments
-    @controller = TestInvokeDelegatedController.new
-    assert_raise(ArgumentError) { invoke_delegated :service, :add, 1 }
-  end
-  
-  def test_direct_fail_with_wrong_number_of_arguments
-    @controller = TestInvokeDirectController.new
-    assert_raise(ArgumentError) { invoke :add, 1 }
-  end
-  
-  def test_with_no_parameters_declared
-    @controller = TestInvokeDirectController.new
-    assert_nil invoke(:null)
-  end
-  
-end