jstorimer-deep-test 0.1.0

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

@@ -0,0 +1,45 @@
+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/sample_rails_project/vendor/rails/actionwebservice/test/api_test.rb

@@ -0,0 +1,102 @@
+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/sample_rails_project/vendor/rails/actionwebservice/test/apis/auto_load_api.rb

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

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

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

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

@@ -0,0 +1,42 @@
+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/sample_rails_project/vendor/rails/actionwebservice/test/casting_test.rb

@@ -0,0 +1,86 @@
+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/sample_rails_project/vendor/rails/actionwebservice/test/client_soap_test.rb

@@ -0,0 +1,152 @@
+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
+  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/sample_rails_project/vendor/rails/actionwebservice/test/client_xmlrpc_test.rb

@@ -0,0 +1,151 @@
+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
+  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/sample_rails_project/vendor/rails/actionwebservice/test/container_test.rb

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