rubyjedi-actionwebservice 2.3.5.20100615120735

data/test/dispatcher_action_controller_soap_test.rb

@@ -0,0 +1,139 @@
+$:.unshift(File.dirname(__FILE__) + '/apis')
+require '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; acts_as_web_service; end
+class FailingAutoLoadController < ActionController::Base; acts_as_web_service; end
+class BrokenAutoLoadController < ActionController::Base; acts_as_web_service; 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 %>

data/test/gencov

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

data/test/invocation_test.rb

@@ -0,0 +1,186 @@
+require '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
+    acts_as_web_service 
+    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

data/test/run

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+args = Dir[File.join(File.dirname(__FILE__), '*_test.rb')] + Dir[File.join(File.dirname(__FILE__), 'ws/*_test.rb')]
+(r = Test::Unit::AutoRunner.new(true)).process_args(args)
+exit r.run

data/test/scaffolded_controller_test.rb

@@ -0,0 +1,147 @@
+require 'abstract_unit'
+
+ActionController::Routing::Routes.draw do |map|
+  map.connect '', :controller => 'scaffolded'
+  map.connect ':controller/:action/:id'
+end
+
+ActionController::Base.view_paths = [ '.' ]
+
+class ScaffoldPerson < ActionWebService::Struct
+  member :id,     :int
+  member :name,   :string
+  member :birth,  :date
+
+  def ==(other)
+    self.id == other.id && self.name == other.name
+  end
+end
+
+class ScaffoldedControllerTestAPI < ActionWebService::API::Base
+  api_method :hello, :expects => [{:integer=>:int}, :string], :returns => [:bool]
+  api_method :hello_struct_param, :expects => [{:person => ScaffoldPerson}], :returns => [:bool]
+  api_method :date_of_birth, :expects => [ScaffoldPerson], :returns => [:string]
+  api_method :bye,   :returns => [[ScaffoldPerson]]
+  api_method :date_diff, :expects => [{:start_date => :date}, {:end_date => :date}], :returns => [:int]
+  api_method :time_diff, :expects => [{:start_time => :time}, {:end_time => :time}], :returns => [:int]
+  api_method :base64_upcase, :expects => [:base64], :returns => [:base64]
+end
+
+class ScaffoldedController < ActionController::Base
+  acts_as_web_service
+  web_service_api ScaffoldedControllerTestAPI
+  web_service_scaffold :scaffold_invoke
+
+  def hello(int, string)
+    0
+  end
+  
+  def hello_struct_param(person)
+    0
+  end
+  
+  def date_of_birth(person)
+    person.birth.to_s
+  end
+
+  def bye
+    [ScaffoldPerson.new(:id => 1, :name => "leon"), ScaffoldPerson.new(:id => 2, :name => "paul")]
+  end
+
+  def rescue_action(e)
+    raise e
+  end
+  
+  def date_diff(start_date, end_date)
+    end_date - start_date
+  end
+  
+  def time_diff(start_time, end_time)
+    end_time - start_time
+  end
+  
+  def base64_upcase(data)
+    data.upcase
+  end
+end
+
+class ScaffoldedControllerTest < ActionController::TestCase
+  # def setup
+  #   @controller = ScaffoldedController.new
+  #   @request    = ActionController::TestRequest.new
+  #   @response   = ActionController::TestResponse.new
+  # end
+
+  def test_scaffold_invoke
+    get :scaffold_invoke
+    assert_template 'methods.html.erb'
+  end
+
+  def test_scaffold_invoke_method_params
+    get :scaffold_invoke_method_params, :service => 'scaffolded', :method => 'Hello'
+    assert_template 'parameters.html.erb'
+  end
+  
+  def test_scaffold_invoke_method_params_with_struct
+    get :scaffold_invoke_method_params, :service => 'scaffolded', :method => 'HelloStructParam'
+    assert_template 'parameters.html.erb'
+    assert_tag :tag => 'form'
+    assert_tag :tag => 'input', :attributes => {:name => "method_params[0][name]"}
+  end
+
+  def test_scaffold_invoke_submit_hello
+    post :scaffold_invoke_submit, :service => 'scaffolded', :method => 'Hello', :method_params => {'0' => '5', '1' => 'hello world'}
+    assert_template 'result.html.erb'
+    assert_equal false, @controller.instance_eval{ @method_return_value }
+  end
+
+  def test_scaffold_invoke_submit_bye
+    post :scaffold_invoke_submit, :service => 'scaffolded', :method => 'Bye'
+    assert_template 'result.html.erb'
+    persons = [ScaffoldPerson.new(:id => 1, :name => "leon"), ScaffoldPerson.new(:id => 2, :name => "paul")]
+    assert_equal persons, @controller.instance_eval{ @method_return_value }
+  end
+  
+  def test_scaffold_date_params
+    get :scaffold_invoke_method_params, :service => 'scaffolded', :method => 'DateDiff'
+    (0..1).each do |param|
+      (1..3).each do |date_part|
+        assert_tag :tag => 'select', :attributes => {:name => "method_params[#{param}][#{date_part}]"}, 
+                   :children => {:greater_than => 1, :only => {:tag => 'option'}}
+      end
+    end
+    
+    post :scaffold_invoke_submit, :service => 'scaffolded', :method => 'DateDiff', 
+         :method_params => {'0' => {'1' => '2006', '2' => '2', '3' => '1'}, '1' => {'1' => '2006', '2' => '2', '3' => '2'}}
+    assert_equal 1, @controller.instance_eval{ @method_return_value }
+  end
+  
+  def test_scaffold_struct_date_params
+    post :scaffold_invoke_submit, :service => 'scaffolded', :method => 'DateOfBirth', 
+         :method_params => {'0' => {'birth' => {'1' => '2006', '2' => '2', '3' => '1'}, 'id' => '1', 'name' => 'person'}}
+    assert_equal '2006-02-01', @controller.instance_eval{ @method_return_value }
+  end
+
+  def test_scaffold_time_params
+    get :scaffold_invoke_method_params, :service => 'scaffolded', :method => 'TimeDiff'
+    (0..1).each do |param|
+      (1..6).each do |date_part|
+        assert_tag :tag => 'select', :attributes => {:name => "method_params[#{param}][#{date_part}]"}, 
+                   :children => {:greater_than => 1, :only => {:tag => 'option'}}
+      end
+    end
+
+    post :scaffold_invoke_submit, :service => 'scaffolded', :method => 'TimeDiff', 
+         :method_params => {'0' => {'1' => '2006', '2' => '2', '3' => '1', '4' => '1', '5' => '1', '6' => '1'}, 
+                            '1' => {'1' => '2006', '2' => '2', '3' => '2', '4' => '1', '5' => '1', '6' => '1'}}
+    assert_equal 86400, @controller.instance_eval{ @method_return_value }
+  end
+  
+  def test_scaffold_base64
+    get :scaffold_invoke_method_params, :service => 'scaffolded', :method => 'Base64Upcase'
+    assert_tag :tag => 'textarea', :attributes => {:name => 'method_params[0]'}
+    
+    post :scaffold_invoke_submit, :service => 'scaffolded', :method => 'Base64Upcase', :method_params => {'0' => 'scaffold'}
+    assert_equal 'SCAFFOLD', @controller.instance_eval{ @method_return_value }
+  end
+end

data/test/struct_test.rb

@@ -0,0 +1,84 @@
+require 'abstract_unit'
+
+module StructTest
+  class Struct < ActionWebService::Struct
+    member :id, Integer
+    member :name, String
+    member :items, [String]
+    member :deleted, :bool
+    member :emails, [:string]
+  end
+end
+
+class TC_Struct < Test::Unit::TestCase
+  include StructTest
+
+  def setup
+    @struct = Struct.new(:id      => 5,
+                         :name    => 'hello',
+                         :items   => ['one', 'two'],
+                         :deleted => true,
+                         :emails  => ['test@test.com'])
+  end
+
+  def test_members
+    assert_equal(5, Struct.members.size)
+    assert_equal(Integer, Struct.members[:id][0].type_class)
+    assert_equal(String, Struct.members[:name][0].type_class)
+    assert_equal(String, Struct.members[:items][0].element_type.type_class)
+    assert_equal(TrueClass, Struct.members[:deleted][0].type_class)
+    assert_equal(String, Struct.members[:emails][0].element_type.type_class)
+  end
+
+  def test_initializer_and_lookup
+    assert_equal(5, @struct.id)
+    assert_equal('hello', @struct.name)
+    assert_equal(['one', 'two'], @struct.items)
+    assert_equal(true, @struct.deleted)
+    assert_equal(['test@test.com'], @struct.emails)
+    assert_equal(5, @struct['id'])
+    assert_equal('hello', @struct['name'])
+    assert_equal(['one', 'two'], @struct['items'])
+    assert_equal(true, @struct['deleted'])
+    assert_equal(['test@test.com'], @struct['emails'])
+  end
+  
+  def test_initializing_with_invalid_hash_and_not_checking
+
+    attrib_hash = { :id      => 5,
+                    :name    => 'hello',
+                    :items   => ['one', 'two'],
+                    :deleted => true,
+                    :emails  => ['test@test.com'],
+                    :extra   => "extra_field"
+                  }
+                                
+    assert_raise NoMethodError do
+      struct = Struct.new(attrib_hash)
+    end
+  end
+  
+  def test_initializing_with_invalid_hash_and_with_hash_checking
+
+     attrib_hash = { :id      => 5,
+                     :name    => 'hello',
+                     :items   => ['one', 'two'],
+                     :deleted => true,
+                     :emails  => ['test@test.com'],
+                     :extra   => "extra_field"
+                   }
+
+     assert_nothing_raised do
+        struct = Struct.new(attrib_hash, true)
+     end
+     struct = Struct.new(attrib_hash, true)
+     assert_equal(5, struct['id'])
+   end
+
+  def test_each_pair
+    @struct.each_pair do |name, value|
+      assert_equal @struct.__send__(name), value
+      assert_equal @struct[name], value
+    end
+  end
+end