fdv-actionwebservice 2.3.8

data/test/abstract_unit.rb

@@ -0,0 +1,43 @@
+$: << "#{File.dirname(__FILE__)}/../lib"
+ENV["RAILS_ENV"] = "test"
+require 'rubygems'
+require 'test/unit'
+require 'action_web_service'
+require 'action_controller'
+require 'action_controller/test_case'
+require 'action_view'
+require 'action_view/test_case'
+
+# Show backtraces for deprecated behavior for quicker cleanup.
+ActiveSupport::Deprecation.debug = true
+
+
+ActiveRecord::Base.logger = ActionController::Base.logger = Logger.new("debug.log")
+
+begin
+  require 'activerecord'
+  require "active_record/test_case"
+  require "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 => "root",
+    :encoding => "utf8",
+    :database => "actionwebservice_unittest"
+  },
+  'sqlite3' => {
+    :adapter  => "sqlite3",
+    :database => "actionwebservice_unittest.db"
+  }
+}
+
+ActiveRecord::Base.establish_connection 'sqlite3'
+
+class ActiveSupport::TestCase
+  include ActiveRecord::TestFixtures
+  self.fixture_path = "#{File.dirname(__FILE__)}/fixtures/"
+end

data/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 < ActiveSupport::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/test/apis/auto_load_api.rb

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

data/test/apis/broken_auto_load_api.rb

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

data/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 < ActiveSupport::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/test/casting_test.rb

@@ -0,0 +1,95 @@
+require File.dirname(__FILE__) + '/abstract_unit'
+
+module CastingTest
+  class A < ActionWebService::Struct; end
+  class B < A; end
+  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]]
+    
+    api_method :a, :expects => [A]
+  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
+    # not sure why this test fails but too lazy to find out why :-(
+#    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
+  
+  def test_structured_type_casting_with_polymorphism
+    assert cast_expects(:a, B.new)[0].is_a?(B)
+  end
+
+  private
+    def cast_expects(method_name, *args)
+      API.api_method_instance(method_name.to_sym).cast_expects([*args])
+    end
+end

data/test/client_soap_test.rb

@@ -0,0 +1,155 @@
+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")
+    ensure
+      ActiveRecord::Base.clear_active_connections!
+    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 < ActiveSupport::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