google-ads-common 0.5.5 → 0.6.0

data/ChangeLog

@@ -1,3 +1,8 @@
+0.6.0:
+  - Better namespace handling in complex cases.
+  - Large refactoring on parameter processing code.
+  - Support for SimpleTypes in wsdl.
+
 0.5.5:
   - Now support Savon 0.9.7.
 

data/lib/ads_common/api_config.rb

@@ -26,7 +26,7 @@ module AdsCommon
   # Contains helper methods for loading and managing the available services.
   # This module is meant to be imported into API-specific modules.
   module ApiConfig
-    ADS_COMMON_VERSION = '0.5.5'
+    ADS_COMMON_VERSION = '0.6.0'
 
     # Get the available API versions.
     #

data/lib/ads_common/build/savon_registry.rb

@@ -63,12 +63,16 @@ module AdsCommon
       def process_types(doc)
         REXML::XPath.each(doc, '//schema') do |schema|
           ns_index = process_namespace(schema)
-          get_complex_types(schema).each do |ctype|
+          complex_types = get_complex_types(schema)
+          simple_types =  get_simple_types(schema)
+          (complex_types + simple_types).each do |ctype|
             ctype_name = get_element_name(ctype)
             if ctype_name.match('.+Exception$')
               @soap_exceptions << extract_exception(ctype)
             elsif ctype_name.match('.+Error$')
               # We don't use it at the moment.
+            elsif ctype_name.match('.+\.Reason$')
+              # We don't use it at the moment.
             else
               @soap_types << extract_type(ctype, ns_index)
             end
@@ -104,6 +108,11 @@ module AdsCommon
         return REXML::XPath.each(node, 'complexType').to_a
       end
 
+      # Extracts SimpleTypes from node into an array.
+      def get_simple_types(node)
+        return REXML::XPath.each(node, 'simpleType').to_a
+      end
+
       # Extracts exception parameters from ComplexTypes element.
       def extract_exception(exception_element)
         return {:name => get_element_name(exception_element),

data/lib/ads_common/errors.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/ruby
 #
-# Authors:: api.sgomes@gmail.com (Sérgio Gomes)
+# Authors:: api.dklimkin@gmail.com (Danial Klimkin)
 #
 # Copyright:: Copyright 2011, Google Inc. All Rights Reserved.
 #
@@ -20,6 +20,8 @@
 # Contains common errors across APIs, as well as base classes to inherit from
 # in specific APIs.
 
+require 'pp'
+
 module AdsCommon
   module Errors
 
@@ -30,31 +32,53 @@ module AdsCommon
     # Raised if an attempt is made to authenticate with missing or wrong
     # information.
     class AuthError < Error
-      attr_reader :error
-      attr_reader :info
+      attr_reader :error, :info
       def initialize(message = self.class.to_s, error = nil, info = nil)
         super(message)
-        @error = error
-        @info = info
+        @error, @info = error, info
       end
     end
 
     # Raised when OAuth access token is required.
     class OAuthVerificationRequired < AuthError
-      attr_reader :oauth_url
-      attr_reader :request_token
+      attr_reader :oauth_url, :request_token
       def initialize(oauth_url, request_token)
         super()
         @oauth_url, @request_token = oauth_url, request_token
       end
     end
 
-    # Raised if setting a non-existant property on an object
+    # Raised if a required property on an object is missing.
     class MissingPropertyError < Error
       attr_reader :property, :object_type
       def initialize(property, object_type)
-        @property = property
-        @object_type = object_type
+        @property, @object_type = property, object_type
+      end
+      def to_s()
+        return "%s: name: %s, type: %s" % [super, @property, @object_type]
+      end
+    end
+
+    # Raised if the type of the object provided does not match expected type.
+    class TypeMismatchError < Error
+      attr_reader :expected, :provided, :field_name
+      def initialize(expected, provided, field_name)
+        @expected, @provided, @field_name = expected, provided, field_name
+      end
+      def to_s()
+        return "%s: expected: '%s', provided: '%s' for field '%s'" %
+            [super, @expected, @provided, @field_name]
+      end
+    end
+
+    # Raised if unexpected parameters encountered.
+    class UnexpectedParametersError < Error
+      attr_reader :parameters_list
+      def initialize(parameters_list)
+        @parameters_list = parameters_list
+      end
+      def to_s()
+        return "%s: %s" % [super, PP.singleline_pp(@parameters_list, '')]
       end
     end
 

data/lib/ads_common/parameters_validator.rb

@@ -0,0 +1,270 @@
+#!/usr/bin/ruby
+#
+# Author:: api.dklimkin@gmail.com (Danial Klimkin)
+#
+# Copyright:: Copyright 2011, Google Inc. All Rights Reserved.
+#
+# License:: Licensed under the Apache License, Version 2.0 (the "License");
+#           you may not use this file except in compliance with the License.
+#           You may obtain a copy of the License at
+#
+#           http://www.apache.org/licenses/LICENSE-2.0
+#
+#           Unless required by applicable law or agreed to in writing, software
+#           distributed under the License is distributed on an "AS IS" BASIS,
+#           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+#           implied.
+#           See the License for the specific language governing permissions and
+#           limitations under the License.
+#
+# This class validates input parameters before passing them to Savon.
+
+module AdsCommon
+  class ParametersValidator
+    # Savon special keys.
+    IGNORED_HASH_KEYS = [:order!, :attributes!]
+
+    # We collect required namespaces into this hash during validation.
+    attr_reader :extra_namespaces
+
+    # Instance initializer.
+    #
+    # Args:
+    #  - service: instance of savon_service to validate for
+    def initialize(registry)
+      @registry = registry
+      @extra_namespaces = {}
+    end
+
+    # Validates input parameters to:
+    # - add parameter names;
+    # - resolve xsi:type where required;
+    # - convert some native types to XML.
+    def validate_args(action_name, args)
+      in_params = @registry.get_method_signature(action_name)[:input]
+      # TODO: compare number of parameters.
+      args_hash = in_params.each_with_index.inject({}) do
+          |result, (in_param, index)|
+        result.merge({in_param[:name] => deep_copy(args[index])})
+      end
+      validate_arguments(args_hash, in_params)
+      return args_hash
+    end
+
+    private
+
+    # Validates given arguments based on provided fields list.
+    def validate_arguments(args_hash, fields_list, type_ns = nil)
+      check_extra_fields(args_hash, array_from_named_list(fields_list))
+      add_order_key(args_hash, fields_list)
+      fields_list.each do |field|
+        key = field[:name]
+        item = args_hash[key]
+        check_required_argument_present(item, field)
+        if item
+          item_type = get_full_type_signature(field[:type])
+          item_ns = field[:ns] || type_ns
+          key = handle_namespace_override(args_hash, key, item_ns) if item_ns
+          validate_arg(item, args_hash, key, item_type)
+        end
+      end
+      return args_hash
+    end
+
+    # Checks if no extra fields provided outside of known ones.
+    def check_extra_fields(args_hash, known_fields)
+      extra_fields = args_hash.keys - known_fields - IGNORED_HASH_KEYS
+      unless extra_fields.empty?
+        raise AdsCommon::Errors::UnexpectedParametersError.new(extra_fields)
+      end
+    end
+
+    # Generates order of XML elements for SOAP request. Adds :order! key to
+    # keep the correct order.
+    def add_order_key(args, fields_list)
+      all_args = fields_list.map {|field| field[:name]}
+      order_array = (all_args & args.keys)
+      args[:order!] = order_array unless order_array.empty?
+    end
+
+    # Checks the provided data structure matches wsdl definition.
+    def check_required_argument_present(arg, field)
+      # At least one item required, none passed.
+      if field[:min_occurs] > 0 and arg.nil?
+        raise AdsCommon::Errors::MissingPropertyError.new(
+            field[:name], field[:type])
+      end
+      # An object passed when an array is expected.
+      if (field[:max_occurs] == :unbounded) and
+          !(arg.nil? or arg.kind_of?(Array))
+        raise AdsCommon::Errors::TypeMismatchError.new(
+            Array, arg.class, field[:name])
+      end
+      # An array passed when an object is expected.
+      if (field[:max_occurs] == 1) and arg.kind_of?(Array)
+        raise AdsCommon::Errors::TypeMismatchError.new(
+            field[:type], Array)
+      end
+    end
+
+    # Overrides non-default namespace if requested.
+    def handle_namespace_override(args, key, ns)
+      add_extra_namespace(ns)
+      new_key = prefix_key_with_namespace(key.to_s.lower_camelcase, ns)
+      rename_hash_key(args, key, new_key)
+      replace_array_item(args[:order!], key, new_key)
+      return new_key
+    end
+
+    # Validates single argument.
+    def validate_arg(arg, parent, key, arg_type)
+      result = case arg
+        when Array
+          validate_array_arg(arg, parent, key, arg_type)
+        when Hash
+          validate_hash_arg(arg, parent, key, arg_type)
+        when Time
+          validate_time_arg(arg, parent, key)
+        else
+          arg
+      end
+      return result
+    end
+
+    # Validates Array argument.
+    def validate_array_arg(arg, parent, key, arg_type)
+      result = arg.map do |item|
+        validate_arg(item, parent, key, arg_type)
+      end
+      return result
+    end
+
+    # Validates Hash argument.
+    def validate_hash_arg(arg, parent, key, arg_type)
+      arg_type = handle_xsi_type(arg, parent, key, arg_type)
+      validate_arguments(arg, arg_type[:fields], arg_type[:ns])
+    end
+
+    # Validates Time argument.
+    def validate_time_arg(arg, parent, key)
+      xml_value = time_to_xml_hash(arg)
+      parent[key] = xml_value
+      return xml_value
+    end
+
+    # Handles custom xsi:type.
+    def handle_xsi_type(arg, parent, key, arg_type)
+      xsi_type = arg.delete('xsi:type') || arg.delete(:xsi_type)
+      if xsi_type
+        xsi_field_type = get_full_type_signature(xsi_type)
+        if xsi_field_type.nil?
+          raise AdsCommon::Errors::ApiException.new(
+              "Incorrect xsi:type specified: '%s'" % [xsi_type])
+        else
+          # TODO: make sure xsi_type is derived from arg_type.
+          arg_type = xsi_field_type
+          # xsi:type needs to be from a correct namespace.
+          if xsi_field_type[:ns]
+            xsi_type = prefix_key_with_namespace(xsi_type, xsi_field_type[:ns])
+          end
+        end
+        add_xsi_type(parent, key, xsi_type)
+      end
+      return arg_type
+    end
+
+    # Replaces an item in an array with a different one into the same position.
+    def replace_array_item(data, old_item, new_item)
+      data.map! {|item| (item == old_item) ? new_item : item}
+    end
+
+    # Replaces an item in an array with a different one into the same position.
+    def rename_hash_key(data, old_key, new_key)
+      data[new_key] = data.delete(old_key)
+      return data
+    end
+
+    # Adds ":attributes!" record for Savon to specify xsi:type.
+    def add_xsi_type(parent, key, xsi_type)
+      add_attribute(parent, key, 'xsi:type', xsi_type)
+    end
+
+    # Adds Savon attribute for given node, key, name and value.
+    def add_attribute(node, key, name, value)
+      node[:attributes!] ||= {}
+      node[:attributes!][key] ||= {}
+      if node[:attributes!][key].include?(name)
+        node[:attributes!][key][name] = arrayize(node[:attributes!][key][name])
+        node[:attributes!][key][name] << value
+      else
+        node[:attributes!][key][name] = value
+      end
+    end
+
+    # Prefixes a key with a given namespace index or default namespace.
+    def prefix_key_with_namespace(key, ns_index = nil)
+      namespace = (ns_index.nil?) ? DEFAULT_NAMESPACE : ("ns%d" % ns_index)
+      return prefix_key(key, namespace)
+    end
+
+    # Prefixes with a given namespace.
+    def prefix_key(key, ns)
+      return [ns, key].join(':')
+    end
+
+    # Returns list of 'names' for objects in array.
+    def array_from_named_list(fields_list)
+      return fields_list.map {|field| field[:name]}
+    end
+
+    # Returns copy of object and its sub-objects ("deep" copy).
+    def deep_copy(data)
+      return Marshal.load(Marshal.dump(data))
+    end
+
+    # Returns type signature with all inherited fields.
+    def get_full_type_signature(type_name)
+      result = (type_name.nil?) ? nil : @registry.get_type_signature(type_name)
+      result[:fields] = implode_parent(result) if result and result[:base]
+      return result
+    end
+
+    # Returns all inherited fields of superclasses for given type.
+    def implode_parent(data_type)
+      result = []
+      if data_type[:base]
+        parent_type = @registry.get_type_signature(data_type[:base])
+        result += implode_parent(parent_type)
+      end
+      data_type[:fields].each do |field|
+        # If the parent type includes a field with the same name, overwrite it.
+        result.reject! {|parent_field| parent_field[:name].eql?(field[:name])}
+        # Storing field's namespace.
+        field[:ns] = data_type[:ns] if data_type[:ns]
+        result << field
+      end
+      return result
+    end
+
+    # Adds additional namespace for XML generation.
+    def add_extra_namespace(ns_index)
+      @extra_namespaces.merge!({
+          "xmlns:ns%d" % ns_index => @registry.get_namespace(ns_index)
+      })
+    end
+
+    # Makes sure object is an array.
+    def arrayize(object)
+      return [] if object.nil?
+      return object.is_a?(Array) ? object : [object]
+    end
+
+    # Converts Time to a hash for XML marshalling.
+    def time_to_xml_hash(time)
+      return {
+          :hour => time.hour, :minute => time.min, :second => time.sec,
+          :date => {:year => time.year, :month => time.month, :day => time.day}
+      }
+    end
+  end
+end

data/lib/ads_common/savon_headers/base_header_handler.rb

@@ -87,8 +87,8 @@ module AdsCommon
         credentials = @credential_handler.credentials(@version)
         app_name = credentials[:userAgent] || credentials[:useragent]
         # We don't know the library version here. A breaking change needs to be
-        # introduced. This is scheduled for 0.6.0, using Common version for now.
-        lib_version = '0.5.5'
+        # introduced. This is scheduled for 0.7.0, using Common version for now.
+        lib_version = '0.6.0'
         soap_user_agent = "Common-Ruby-%s; %s" % [lib_version, app_name]
         return "Savon/%s (%s)" % [Savon::Version, soap_user_agent]
       end

data/lib/ads_common/savon_service.rb

@@ -22,11 +22,10 @@
 require 'httpi'
 require 'savon'
 
+require 'ads_common/parameters_validator'
+
 module AdsCommon
   class SavonService
-    # Default namespace name.
-    DEFAULT_NAMESPACE = 'wsdl'
-
     # HTTP read timeout in seconds.
     HTTP_READ_TIMEOUT = 15 * 60
 
@@ -81,164 +80,31 @@ module AdsCommon
 
     # Executes SOAP action specified as a string with given arguments.
     def execute_action(action_name, args, &block)
-      args = validate_args(action_name, args)
-      response = execute_soap_request(action_name.to_sym, args)
+      validator = ParametersValidator.new(get_service_registry())
+      args = validator.validate_args(action_name, args)
+      response = execute_soap_request(
+          action_name.to_sym, args, validator.extra_namespaces)
       handle_errors(response)
       return extract_result(response, action_name, &block)
     end
 
     # Executes the SOAP request with original SOAP name.
-    def execute_soap_request(action, args)
+    def execute_soap_request(action, args, extra_namespaces)
       original_action_name =
           get_service_registry.get_method_signature(action)[:original_name]
       original_action_name = action if original_action_name.nil?
       response = @client.request(original_action_name) do |soap|
-        set_headers(soap, args)
+        set_headers(soap, args, extra_namespaces)
       end
       return response
     end
 
-    # Validates input parameters to:
-    # - add parameter names;
-    # - resolve xsi:type where required;
-    # - convert some native types to XML.
-    def validate_args(action_name, args)
-      validated_args = {}
-      in_params = get_service_registry.get_method_signature(action_name)[:input]
-      in_params.each_with_index do |in_param, index|
-        key = in_param[:name]
-        value = deep_copy(args[index])
-        validated_args[key] = (value.nil?) ?
-             nil : validate_arg(value, validated_args, key, in_param[:type])
-        # Adding :order! key to keep correct order in SOAP elements.
-        validated_args[:order!] =
-            generate_order_for_args(validated_args, in_params)
-      end
-      return validated_args
-    end
-
-    # Validates method argument. Runs recursively if hash or array encountered.
-    # Also handles some types that need special conversions.
-    def validate_arg(arg, parent = nil, key = nil, field_type_name = nil)
-      field_type = get_full_type_signature(field_type_name)
-      result = case arg
-        when Hash
-          validate_hash_arg(arg, parent, key, field_type)
-        when Array then arg.map do |item|
-           validate_arg(item, parent, key, field_type_name)
-          end
-        when Time then time_to_xml_hash(arg)
-        else arg
-      end
-      return result
-    end
-
-    # Generates order of XML elements for SOAP request. Returns only items
-    # existing in arg.
-    def generate_order_for_args(arg, fields)
-      all_keys = fields.map {|field| field[:name]}
-      return all_keys & arg.keys
-    end
-
-    # Validates hash argument recursively. Keeps tracking of correct place
-    # for xsi:type and adds is when required.
-    def validate_hash_arg(arg, parent = nil, key = nil, field_type = nil)
-      # Non-default namespace should be used, overriding default.
-      if field_type and field_type.include?(:ns)
-        namespace = get_service_registry.get_namespace(field_type[:ns])
-        key = prefix_key(key)
-        add_attribute(parent, key, 'xmlns', namespace)
-      end
-
-      # Handling custom xsi:type.
-      xsi_type = arg.delete('xsi:type') || arg.delete(:xsi_type)
-      if xsi_type
-        xsi_field_type = get_full_type_signature(xsi_type)
-        if xsi_field_type.nil?
-          raise AdsCommon::Errors::ApiException.new(
-              "Incorrect xsi:type specified: '%s'" % [xsi_type])
-        else
-          # TODO: make sure xsi_type is derived from field_type.
-          field_type = xsi_field_type
-        end
-        if parent and key
-          add_xsi_type(parent, key, xsi_type)
-        else
-          raise AdsCommon::Errors::ApiException.new(
-              "Can't find correct position for xsi:type (%s) [%s], [%s]" %
-                  [xsi_type, parent, key])
-        end
-      end
-
-      # Adding :order! key to keep correct order in SOAP elements.
-      if field_type and field_type.include?(:fields)
-        arg[:order!] =
-            generate_order_for_args(arg, field_type[:fields])
-      end
-
-      # Processing each key-value pair.
-      return arg.inject({}) do |result, (k, v)|
-        if (k == :attributes! or k == :order!)
-          result[k] = v
-        else
-          subfield = (field_type.nil?) ? nil :
-              get_field_by_name(field_type[:fields], k)
-          # Here we will give up if the field is unknown. For full validation
-          # we have to handle nil here.
-          subtype_name, subtype = if subfield and subfield.include?(:type)
-            subtype_name = subfield[:type]
-            subtype = (subtype_name.nil?) ? nil :
-                get_service_registry.get_type_signature(subtype_name)
-            [subtype_name, subtype]
-          end
-          # In case of non-default namespace, the children should be in
-          # overridden namespace but the node has to be in the default.
-          # We also have to fix order! list if we alter the key name.
-          new_key = if (subtype and subtype[:ns])
-            prefixed_key = prefix_key(k)
-            replace_item!(arg[:order!], k, prefixed_key)
-            prefixed_key
-          else
-            k
-          end
-          result[new_key] = validate_arg(v, result, k, subtype_name)
-        end
-        result
-      end
-    end
-
-    # Replaces an item in an array with a different one into the same position.
-    def replace_item!(data, old_item, new_item)
-      data.map! {|item| (item == old_item) ? new_item : item}
-    end
-
-    # Adds ":attributes!" record for Savon to specify xsi:type.
-    def add_xsi_type(parent, key, xsi_type)
-      add_attribute(parent, key, 'xsi:type', xsi_type)
-    end
-
-    # Adds Savon attribute for given node, key, name and value.
-    def add_attribute(node, key, name, value)
-      node[:attributes!] ||= {}
-      node[:attributes!][key] ||= {}
-      if node[:attributes!][key].include?(name)
-        node[:attributes!][key][name] = arrayize(node[:attributes!][key][name])
-        node[:attributes!][key][name] << value
-      else
-        node[:attributes!][key][name] = value
-      end
-    end
-
-    # Prefixes default namespace.
-    def prefix_key(key)
-      return "%s:%s" % [DEFAULT_NAMESPACE, key.to_s.lower_camelcase]
-    end
-
     # Executes each handler to generate SOAP headers.
-    def set_headers(soap, args)
+    def set_headers(soap, args, extra_namespaces)
       @headerhandler.each do |handler|
         handler.prepare_request(@client.http, soap, args)
       end
+      soap.namespaces.merge!(extra_namespaces) unless extra_namespaces.nil?
     end
 
     # Checks for errors in response and raises appropriate exception.
@@ -405,14 +271,6 @@ module AdsCommon
       return object.is_a?(Array) ? object : [object]
     end
 
-    # Converts Time to a hash for XML marshalling.
-    def time_to_xml_hash(time)
-      return {
-          :hour => time.hour, :minute => time.min, :second => time.sec,
-          :date => {:year => time.year, :month => time.month, :day => time.day}
-      }
-    end
-
     # Returns all inherited fields of superclasses for given type.
     def implode_parent(data_type)
       result = []
@@ -428,11 +286,6 @@ module AdsCommon
       return result
     end
 
-    # Returns copy of object and its sub-objects ("deep" copy).
-    def deep_copy(data)
-      return Marshal.load(Marshal.dump(data))
-    end
-
     # Returns type signature with all inherited fields.
     def get_full_type_signature(type_name)
       result = (type_name.nil?) ? nil :

data/test/test_parameters_validator.rb

@@ -0,0 +1,103 @@
+#!/usr/bin/ruby
+#
+# Author:: api.dklimkin@gmail.com (Danial Klimkin)
+#
+# Copyright:: Copyright 2011, Google Inc. All Rights Reserved.
+#
+# License:: Licensed under the Apache License, Version 2.0 (the "License");
+#           you may not use this file except in compliance with the License.
+#           You may obtain a copy of the License at
+#
+#           http://www.apache.org/licenses/LICENSE-2.0
+#
+#           Unless required by applicable law or agreed to in writing, software
+#           distributed under the License is distributed on an "AS IS" BASIS,
+#           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+#           implied.
+#           See the License for the specific language governing permissions and
+#           limitations under the License.
+#
+# Tests validator methods.
+
+require 'rubygems'
+require 'test/unit'
+
+require 'ads_common/parameters_validator'
+
+module AdsCommon
+  class ParametersValidator
+    public :deep_copy, :add_attribute, :array_from_named_list
+  end
+end
+
+class TestParametersValidator < Test::Unit::TestCase
+  def setup
+    @validator = AdsCommon::ParametersValidator.new(nil)
+  end
+
+  def test_deep_copy_simple
+    result1 = @validator.deep_copy(42)
+    assert_equal(42, result1)
+
+    result2 = @validator.deep_copy('Hello World')
+    assert_equal('Hello World', result2)
+
+    result3 = @validator.deep_copy(nil)
+    assert_nil(result3)
+
+    result4 = @validator.deep_copy([])
+    assert_equal([], result4)
+    assert_not_same([], result4)
+
+    result5 = @validator.deep_copy({})
+    assert_equal({}, result5)
+    assert_not_same({}, result5)
+  end
+
+  def test_deep_copy_complex
+    data = {:ab => 'ab', :cd => ['cd', 'de', 'ef']}
+
+    result1 = @validator.deep_copy(data)
+    assert_equal(data, result1)
+    assert_not_same(data, result1)
+
+    result2 = @validator.deep_copy(data)
+    assert_equal(result2, result1)
+    assert_not_same(result2, result1)
+
+    result2[:cd] = nil
+    assert_not_equal(data, result2)
+    assert_equal(data, result1)
+  end
+
+  def test_add_attribute
+    node = {}
+
+    key, name, value1, value2, value3 = 'key', 'name', 'Lorem', 'ipsum', 'dolor'
+
+    @validator.add_attribute(node, key, name, value1)
+    assert_kind_of(Hash, node)
+    assert_kind_of(Hash, node[:attributes!])
+    assert_kind_of(Hash, node[:attributes!][key])
+    assert_equal(value1, node[:attributes!][key][name])
+
+    @validator.add_attribute(node, key, name, value2)
+    assert_kind_of(Hash, node)
+    assert_kind_of(Hash, node[:attributes!])
+    assert_kind_of(Hash, node[:attributes!][key])
+    assert_kind_of(Array, node[:attributes!][key][name])
+    assert_equal(value1, node[:attributes!][key][name][0])
+    assert_equal(value2, node[:attributes!][key][name][1])
+
+    @validator.add_attribute(node, key, name, value3)
+    assert_equal(value1, node[:attributes!][key][name][0])
+    assert_equal(value2, node[:attributes!][key][name][1])
+    assert_equal(value3, node[:attributes!][key][name][2])
+  end
+
+  def test_array_from_named_list
+    src = [{:name => 'foo'}, {:name => 'bar', :bar => :baz}, {:name => 'ipsum'}]
+    result = @validator.array_from_named_list(src)
+    assert_equal(['foo', 'bar', 'ipsum'], result)
+  end
+end

data/test/test_savon_service.rb

@@ -219,64 +219,4 @@ class TestSavonService < Test::Unit::TestCase
     assert_instance_of(Float, result4)
     assert_equal(42.0, result4, 'Float is expected for nil max_occurs')
   end
-
-  def test_deep_copy_simple
-    result1 = @stub_service.private_deep_copy(42)
-    assert_equal(42, result1)
-
-    result2 = @stub_service.private_deep_copy('Hello World')
-    assert_equal('Hello World', result2)
-
-    result3 = @stub_service.private_deep_copy(nil)
-    assert_nil(result3)
-
-    result4 = @stub_service.private_deep_copy([])
-    assert_equal([], result4)
-    assert_not_same([], result4)
-
-    result5 = @stub_service.private_deep_copy({})
-    assert_equal({}, result5)
-    assert_not_same({}, result5)
-  end
-
-  def test_deep_copy_complex
-    data = {:ab => 'ab', :cd => ['cd', 'de', 'ef']}
-
-    result1 = @stub_service.private_deep_copy(data)
-    assert_equal(data, result1)
-    assert_not_same(data, result1)
-
-    result2 = @stub_service.private_deep_copy(data)
-    assert_equal(result2, result1)
-    assert_not_same(result2, result1)
-
-    result2[:cd] = nil
-    assert_not_equal(data, result2)
-    assert_equal(data, result1)
-  end
-
-  def test_add_attribute
-    node = {}
-
-    key, name, value1, value2, value3 = 'key', 'name', 'Lorem', 'ipsum', 'dolor'
-
-    @stub_service.private_add_attribute(node, key, name, value1)
-    assert_kind_of(Hash, node)
-    assert_kind_of(Hash, node[:attributes!])
-    assert_kind_of(Hash, node[:attributes!][key])
-    assert_equal(value1, node[:attributes!][key][name])
-
-    @stub_service.private_add_attribute(node, key, name, value2)
-    assert_kind_of(Hash, node)
-    assert_kind_of(Hash, node[:attributes!])
-    assert_kind_of(Hash, node[:attributes!][key])
-    assert_kind_of(Array, node[:attributes!][key][name])
-    assert_equal(value1, node[:attributes!][key][name][0])
-    assert_equal(value2, node[:attributes!][key][name][1])
-
-    @stub_service.private_add_attribute(node, key, name, value3)
-    assert_equal(value1, node[:attributes!][key][name][0])
-    assert_equal(value2, node[:attributes!][key][name][1])
-    assert_equal(value3, node[:attributes!][key][name][2])
-  end
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 5
-  - 5
-  version: 0.5.5
+  - 6
+  - 0
+  version: 0.6.0
 platform: ruby
 authors: 
 - Sergio Gomes
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-28 00:00:00 +04:00
+date: 2011-12-02 00:00:00 +04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -89,27 +89,29 @@ extra_rdoc_files:
 - COPYING
 - ChangeLog
 files: 
-- lib/ads_common/auth/base_handler.rb
 - lib/ads_common/auth/client_login_handler.rb
+- lib/ads_common/auth/base_handler.rb
 - lib/ads_common/auth/oauth_handler.rb
-- lib/ads_common/build/savon_abstract_generator.rb
+- lib/ads_common/credential_handler.rb
 - lib/ads_common/build/savon_generator.rb
-- lib/ads_common/build/savon_registry.rb
 - lib/ads_common/build/savon_registry_generator.rb
+- lib/ads_common/build/savon_registry.rb
 - lib/ads_common/build/savon_service_generator.rb
-- lib/ads_common/savon_headers/base_header_handler.rb
-- lib/ads_common/savon_headers/httpi_request_proxy.rb
-- lib/ads_common/savon_headers/oauth_header_handler.rb
-- lib/ads_common/savon_headers/simple_header_handler.rb
+- lib/ads_common/build/savon_abstract_generator.rb
 - lib/ads_common/api_config.rb
-- lib/ads_common/api.rb
 - lib/ads_common/config.rb
-- lib/ads_common/credential_handler.rb
-- lib/ads_common/errors.rb
-- lib/ads_common/http.rb
+- lib/ads_common/api.rb
+- lib/ads_common/savon_headers/base_header_handler.rb
+- lib/ads_common/savon_headers/simple_header_handler.rb
+- lib/ads_common/savon_headers/oauth_header_handler.rb
+- lib/ads_common/savon_headers/httpi_request_proxy.rb
 - lib/ads_common/savon_service.rb
+- lib/ads_common/http.rb
+- lib/ads_common/parameters_validator.rb
+- lib/ads_common/errors.rb
 - Rakefile
 - test/test_config.rb
+- test/test_parameters_validator.rb
 - test/test_savon_service.rb
 - README
 - COPYING
@@ -148,4 +150,5 @@ specification_version: 3
 summary: Common code for Google Ads APIs.
 test_files: 
 - test/test_config.rb
+- test/test_parameters_validator.rb
 - test/test_savon_service.rb