actionwebservice 0.5.0 → 0.6.0

data/lib/action_web_service/protocol/registry.rb

@@ -1,55 +0,0 @@
-module ActionWebService # :nodoc:
-  module Protocol # :nodoc:
-    HeaderAndBody = :header_and_body
-    BodyOnly      = :body_only
-
-    module Registry # :nodoc:
-      def self.append_features(base) # :nodoc:
-        super
-        base.extend(ClassMethods)
-        base.send(:include, ActionWebService::Protocol::Registry::InstanceMethods)
-      end
-
-      module ClassMethods # :nodoc:
-        def register_protocol(type, klass) # :nodoc:
-          case type
-          when HeaderAndBody
-            write_inheritable_array("header_and_body_protocols", [klass])
-          when BodyOnly
-            write_inheritable_array("body_only_protocols", [klass])
-          else
-            raise(ProtocolError, "unknown protocol type #{type}")
-          end
-        end
-      end
-
-      module InstanceMethods # :nodoc:
-        private
-          def probe_request_protocol(action_pack_request)
-            (header_and_body_protocols + body_only_protocols).each do |protocol|
-              protocol_request = protocol.create_protocol_request(self.class, action_pack_request)
-              return protocol_request if protocol_request
-            end
-            raise(ProtocolError, "unsupported request message format")
-          end
-
-          def probe_protocol_client(api, protocol_name, endpoint_uri, options)
-            (header_and_body_protocols + body_only_protocols).each do |protocol|
-              protocol_client = protocol.create_protocol_client(api, protocol_name, endpoint_uri, options)
-              return protocol_client if protocol_client
-            end
-            raise(ProtocolError, "unsupported client protocol :#{protocol_name}")
-          end
-          
-          def header_and_body_protocols
-            self.class.read_inheritable_attribute("header_and_body_protocols") || []
-          end
-
-          def body_only_protocols
-            self.class.read_inheritable_attribute("body_only_protocols") || []
-          end
-      end
-
-    end
-  end
-end

data/lib/action_web_service/support/signature.rb

@@ -1,100 +0,0 @@
-module ActionWebService # :nodoc:
-  # Action Web Service parameter specifiers may contain symbols or strings
-  # instead of Class objects, for a limited set of base types.
-  #
-  # This provides an unambiguous way to specify that a given parameter
-  # contains an integer or boolean value, for example.
-  #
-  # The allowed set of symbol/string aliases:
-  #
-  # [<tt>:int</tt>]     any integer value
-  # [<tt>:float</tt>]   any floating point value
-  # [<tt>:string</tt>]  any string value
-  # [<tt>:bool</tt>]    any boolean value
-  # [<tt>:time</tt>]    any value containing both date and time
-  # [<tt>:date</tt>]    any value containing only a date
-  module Signature
-    class SignatureError < StandardError # :nodoc:
-    end
-
-    private
-      def canonical_signature(params)
-        return nil if params.nil?
-        params.map do |param|
-          klass = signature_parameter_class(param)
-          if param.is_a?(Hash)
-            param[param.keys[0]] = klass
-            param
-          else
-            klass
-          end
-        end
-      end
-  
-      def signature_parameter_class(param)
-        param = param.is_a?(Hash) ? param.values[0] : param
-        is_array = param.is_a?(Array)
-        param = is_array ? param[0] : param
-        param = param.is_a?(String) ? param.to_sym : param
-        param = param.is_a?(Symbol) ? signature_ruby_class(param) : param
-        is_array ? [param] : param
-      end
-  
-  
-      def canonical_signature_base_type(base_type)
-        base_type = base_type.to_sym
-        case base_type
-          when :int, :integer, :fixnum, :bignum
-            :int
-          when :string, :base64
-            :string
-          when :bool, :boolean
-            :bool
-          when :float, :double
-            :float
-          when :time, :datetime, :timestamp
-            :time
-          when :date
-            :date
-          else
-            raise(SignatureError, ":#{base_type} is not an ActionWebService base type")
-        end
-      end
-  
-      def signature_ruby_class(base_type)
-        case canonical_signature_base_type(base_type)
-        when :int
-          Integer
-        when :string
-          String
-        when :bool
-          TrueClass
-        when :float
-          Float
-        when :time
-          Time
-        when :date
-          Date
-        end
-      end
-  
-      def signature_base_type(ruby_class)
-        case ruby_class
-        when Bignum, Integer, Fixnum
-          :int
-        when String
-          :string
-        when TrueClass, FalseClass
-          :bool
-        when Float, Numeric, Precision
-          :float
-        when Time, DateTime
-          :time
-        when Date
-          :date
-        else
-          raise(SignatureError, "#{ruby_class.name} is not an ActionWebService base type")
-        end
-      end
-  end
-end

data/test/abstract_soap.rb

@@ -1,58 +0,0 @@
-require File.dirname(__FILE__) + '/abstract_unit'
-require 'soap/rpc/element'
-
-class SoapTestError < StandardError
-end
-
-class AbstractSoapTest < Test::Unit::TestCase
-  def default_test
-  end
-
-  protected
-    def service_name
-      raise NotImplementedError
-    end
-
-    def do_soap_call(public_method_name, *args)
-      mapper = @container.class.soap_mapper
-      param_def = []
-      i = 1
-      args.each do |arg|
-        mapping = mapper.lookup(arg.class)
-        param_def << ["in", "param#{i}", mapping.registry_mapping]
-        i += 1
-      end
-      qname = XSD::QName.new('urn:ActionWebService', public_method_name)
-      request = SOAP::RPC::SOAPMethodRequest.new(qname, param_def)
-      soap_args = []
-      i = 1
-      args.each do |arg|
-        soap_args << ["param#{i}", SOAP::Mapping.obj2soap(arg)]
-        i += 1
-      end
-      request.set_param(soap_args)
-      header = SOAP::SOAPHeader.new
-      body = SOAP::SOAPBody.new(request)
-      envelope = SOAP::SOAPEnvelope.new(header, body)
-      raw_request = SOAP::Processor.marshal(envelope)
-      test_request = ActionController::TestRequest.new
-      test_request.request_parameters['action'] = service_name
-      test_request.env['REQUEST_METHOD'] = "POST"
-      test_request.env['HTTP_CONTENTTYPE'] = 'text/xml'
-      test_request.env['HTTP_SOAPACTION'] = "/soap/#{service_name}/#{public_method_name}"
-      test_request.env['RAW_POST_DATA'] = raw_request
-      test_response = ActionController::TestResponse.new
-      response = yield test_request, test_response
-      raw_body = response.respond_to?(:body) ? response.body : response.raw_body
-      envelope = SOAP::Processor.unmarshal(raw_body)
-      if envelope
-        if envelope.body.response
-          SOAP::Mapping.soap2obj(envelope.body.response)
-        else
-          nil
-        end
-      else
-        raise(SoapTestError, "empty/invalid body from server")
-      end
-    end
-end

data/test/dispatcher_action_controller_test.rb

@@ -1,186 +0,0 @@
-require File.dirname(__FILE__) + '/abstract_soap'
-require 'wsdl/parser'
-
-module DispatcherActionControllerTest
-  class API < ActionWebService::API::Base
-    api_method :add, :expects => [:int, :int], :returns => [:int]
-  end
-
-  class DirectAPI < ActionWebService::API::Base
-    api_method :add, :expects => [{:a=>:int}, {:b=>:int}], :returns => [:int]
-    api_method :before_filtered
-    api_method :after_filtered, :returns => [:int]
-    api_method :thrower
-  end
- 
-  class Service < ActionWebService::Base
-    web_service_api API
-
-    attr :added
-  
-    def add(a, b)
-      @added = a + b
-    end
-  end
-
-  class AbstractController < ActionController::Base
-    def generate_wsdl(container, uri, soap_action_base)
-      to_wsdl(container, uri, soap_action_base)
-    end
-  end
- 
-  class DelegatedController < AbstractController
-    web_service_dispatching_mode :delegated
-  
-    web_service(:test_service) { @service ||= Service.new; @service }
-  end
- 
-  class DirectController < AbstractController
-    web_service_api DirectAPI
-    web_service_dispatching_mode :direct
-
-    before_filter :alwaysfail, :only => [:before_filtered]
-    after_filter :alwaysok, :only => [:after_filtered]
-
-    attr :added
-    attr :before_filter_called
-    attr :before_filter_target_called
-    attr :after_filter_called
-    attr :after_filter_target_called
-
-    def initialize
-      @before_filter_called = false
-      @before_filter_target_called = false
-      @after_filter_called = false
-      @after_filter_target_called = false
-    end
-  
-    def add
-      @added = @params['a'] + @params['b']
-    end
-
-    def before_filtered
-      @before_filter_target_called = true
-    end
-
-    def after_filtered
-      @after_filter_target_called = true
-      5
-    end
-
-    def thrower
-      raise "Hi, I'm a SOAP exception"
-    end
-
-    protected
-      def alwaysfail
-        @before_filter_called = true
-        false
-      end
-
-      def alwaysok
-        @after_filter_called = true
-      end
-  end
-end
-
-class TC_DispatcherActionController < AbstractSoapTest
-  include DispatcherActionControllerTest
-
-  def test_direct_dispatching
-    @container = DirectController.new
-    assert(do_soap_call('Add', 20, 50) == 70)
-    assert(@container.added == 70)
-  end
-
-  def test_direct_entrypoint
-    @container = DirectController.new
-    assert(@container.respond_to?(:api))
-  end
-
-  def test_direct_filtering
-    @container = DirectController.new
-    assert(@container.before_filter_called == false)
-    assert(@container.before_filter_target_called == false)
-    assert(do_soap_call('BeforeFiltered').nil?)
-    assert(@container.before_filter_called == true)
-    assert(@container.before_filter_target_called == false)
-    assert(@container.after_filter_called == false)
-    assert(@container.after_filter_target_called == false)
-    assert(do_soap_call('AfterFiltered') == 5)
-    assert(@container.after_filter_called == true)
-    assert(@container.after_filter_target_called == true)
-  end
-
-  def test_delegated_dispatching
-    @container = DelegatedController.new
-    assert(do_soap_call('Add', 50, 80) == 130)
-    assert(service.added == 130)
-  end
-
-  def test_exception_marshaling
-    @container = DirectController.new
-    result = do_soap_call('Thrower')
-    exception = result.detail
-    assert(exception.cause.is_a?(RuntimeError))
-    assert_equal("Hi, I'm a SOAP exception", exception.cause.message)
-    @container.web_service_exception_reporting = false
-    assert_raises(SoapTestError) do
-      do_soap_call('Thrower')
-    end
-  end
-
-  def test_wsdl_generation
-    ensure_valid_wsdl_generation DelegatedController.new
-    ensure_valid_wsdl_generation DirectController.new
-  end
-
-  def 
-
-  def test_wsdl_action
-    ensure_valid_wsdl_action DelegatedController.new
-    ensure_valid_wsdl_action DirectController.new
-  end
-
-  protected
-    def service_name
-      @container.is_a?(DelegatedController) ? 'test_service' : 'api'
-    end
-
-    def service
-      @container.web_service_object(:test_service)
-    end
-
-    def do_soap_call(public_method_name, *args)
-      super(public_method_name, *args) do |test_request, test_response|
-        response = @container.process(test_request, test_response)
-      end
-    end
-
-    def ensure_valid_wsdl_generation(controller)
-      wsdl = controller.generate_wsdl(controller, 'http://localhost:3000/test/', '/test')
-      ensure_valid_wsdl(wsdl)
-    end
-
-    def ensure_valid_wsdl(wsdl)
-      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
-    end
-
-    def ensure_valid_wsdl_action(controller)
-      test_request = ActionController::TestRequest.new({ 'action' => 'wsdl' })
-      test_request.env['REQUEST_METHOD'] = 'GET'
-      test_request.env['HTTP_HOST'] = 'localhost:3000'
-      test_response = ActionController::TestResponse.new
-      wsdl = controller.process(test_request, test_response).body
-      ensure_valid_wsdl(wsdl)
-    end
-end

data/test/protocol_registry_test.rb

@@ -1,53 +0,0 @@
-require File.dirname(__FILE__) + '/abstract_unit'
-
-
-module Foo
-  include ActionWebService::Protocol
-
-  def self.append_features(base)
-    super
-    base.register_protocol(BodyOnly, FooMinimalProtocol)
-    base.register_protocol(HeaderAndBody, FooMinimalProtocolTwo)
-    base.register_protocol(HeaderAndBody, FooMinimalProtocolTwo)
-    base.register_protocol(HeaderAndBody, FooFullProtocol)
-  end
-
-  class FooFullProtocol < AbstractProtocol
-    def self.create_protocol_request(klass, request)
-      protocol = FooFullProtocol.new klass
-      ActionWebService::Protocol::ProtocolRequest.new(protocol, '', '', '', '')
-    end
-  end
-
-  class FooMinimalProtocol < AbstractProtocol
-    def self.create_protocol_request(klass, request)
-      protocol = FooMinimalProtocol.new klass
-      ActionWebService::Protocol::ProtocolRequest.new(protocol, '', '', '', '')
-    end
-  end
-
-  class FooMinimalProtocolTwo < AbstractProtocol
-  end
-end
-
-class ProtocolRegistry
-  include ActionWebService::Protocol::Registry
-  include Foo
-
-  def all_protocols
-    header_and_body_protocols + body_only_protocols
-  end
-
-  def protocol_request
-    probe_request_protocol(nil)
-  end
-end
-
-
-class TC_ProtocolRegistry < Test::Unit::TestCase
-  def test_registration
-    registry = ProtocolRegistry.new
-    assert(registry.all_protocols.length == 4)
-    assert(registry.protocol_request.protocol.is_a?(Foo::FooFullProtocol))
-  end
-end