typo 5.2 → 5.2.98

data/vendor/actionwebservice/test/container_test.rb

@@ -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

data/vendor/actionwebservice/test/dispatcher_action_controller_soap_test.rb

@@ -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

data/vendor/actionwebservice/test/dispatcher_action_controller_xmlrpc_test.rb

@@ -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

data/vendor/actionwebservice/test/fixtures/db_definitions/mysql.sql

@@ -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;

data/vendor/actionwebservice/test/fixtures/users.yml

@@ -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 %>

data/vendor/actionwebservice/test/gencov

@@ -1,3 +0,0 @@
-#!/bin/sh
-
-rcov -x '.*_test\.rb,rubygems,abstract_,/run,/apis' ./run

data/vendor/actionwebservice/test/invocation_test.rb

@@ -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