typo 5.3 → 5.4

data/vendor/actionwebservice/test/abstract_client.rb

@@ -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 => [])
-      @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

data/vendor/actionwebservice/test/abstract_dispatcher.rb

@@ -1,547 +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 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 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