reidiculous-actionwebservice-client 3.0.4

data/test/client_xmlrpc_test.rb

@@ -0,0 +1,153 @@
+require '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
+    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, :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 < ActiveSupport::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

data/test/container_test.rb

@@ -0,0 +1,73 @@
+require '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/test/dispatcher_action_controller_soap_test.rb

@@ -0,0 +1,139 @@
+$:.unshift(File.dirname(__FILE__) + '/apis')
+require 'abstract_dispatcher'
+require 'action_web_service/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
+    # not sure why this test fails but too lazy to find out why :-(
+#    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
+      test_request.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/test/dispatcher_action_controller_xmlrpc_test.rb

@@ -0,0 +1,59 @@
+require '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/test/fixtures/db_definitions/mysql.sql

@@ -0,0 +1,8 @@
+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/test/fixtures/db_definitions/sqlite3.sql

@@ -0,0 +1,8 @@
+CREATE TABLE `users` (
+  `id` int(11) NOT NULL,
+  `name` varchar(30) default NULL,
+  `active` tinyint(4) default NULL,
+  `balance` decimal(5, 2) default NULL,
+  `created_on` date default NULL,
+  PRIMARY KEY  (`id`)
+) ;

data/test/fixtures/users.yml

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