backlog 0.0.4 → 0.0.5

data/vendor/rails/actionwebservice/test/abstract_unit.rb

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

data/vendor/rails/actionwebservice/test/api_test.rb

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

data/vendor/rails/actionwebservice/test/apis/auto_load_api.rb

@@ -1,3 +0,0 @@
-class AutoLoadAPI < ActionWebService::API::Base
-  api_method :void
-end

data/vendor/rails/actionwebservice/test/apis/broken_auto_load_api.rb

@@ -1,2 +0,0 @@
-
-

data/vendor/rails/actionwebservice/test/base_test.rb

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

data/vendor/rails/actionwebservice/test/casting_test.rb

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

data/vendor/rails/actionwebservice/test/client_soap_test.rb

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

data/vendor/rails/actionwebservice/test/client_xmlrpc_test.rb

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