google-ads-common 0.5.0 → 0.5.1

data/ChangeLog

@@ -1,3 +1,8 @@
+0.5.1:
+  - Now passing response header information as :header field in response.
+  - Major performance improvements.
+  - Support for proxies.
+
 0.5.0:
   - Now support Savon 0.9.6.
   - No longer depend on Soap4r.

data/lib/ads_common/api.rb

@@ -17,7 +17,7 @@
 #           See the License for the specific language governing permissions and
 #           limitations under the License.
 #
-# Generic Api class, to be inherited from and extended by specific APIs.
+# Generic API class, to be inherited from and extended by specific APIs.
 
 require 'logger'
 
@@ -41,24 +41,8 @@ module AdsCommon
 
     # Constructor for API.
     def initialize(provided_config = nil)
-      load_config(provided_config)
-      provided_logger = @config.read('library.logger')
-      self.logger = (provided_logger.nil?) ?
-          create_default_logger() : provided_logger
-
-      # Check for valid environment.
-      env_string = @config.read('service.environment')
-      environment = (env_string.nil?) ? api_config.default_environment :
-          env_string.to_s.upcase.to_sym
-      if api_config.environments.include?(environment)
-        @config.set('service.environment', environment)
-      else
-        raise AdsCommon::Errors::Error,
-            "Unknown or unspecified environment: \"%s\"" % env_string
-      end
-
-      # Service wrappers.
       @wrappers = {}
+      load_config(provided_config)
     end
 
     # Sets the logger to use.
@@ -87,14 +71,20 @@ module AdsCommon
 
       # Check if version exists.
       if !api_config.versions.include?(version)
-        raise AdsCommon::Errors::Error, "Unknown version '%s'." % version
+        raise AdsCommon::Errors::Error, "Unknown version '%s'" % version
       end
 
       # Check if the current environment supports the requested version.
       environment = @config.read('service.environment')
+
+      if !api_config.environments.include?(environment)
+        raise AdsCommon::Errors::Error,
+            "Unknown or unspecified environment: '%s'" % environment
+      end
+
       if !api_config.environment_has_version(environment, version)
         raise AdsCommon::Errors::Error,
-            "Environment '%s' does not support version '%s'." %
+            "Environment '%s' does not support version '%s'" %
             [environment, version]
       end
 
@@ -168,7 +158,7 @@ module AdsCommon
     # - a list of SOAP header handlers; one per provided header
     #
     def soap_header_handlers(auth_handler, header_list, version, wrapper)
-      raise NotImplementedError, 'soap_header_handlers not overriden.'
+      raise NotImplementedError, 'soap_header_handlers not overridden.'
     end
 
     # Auxiliary method to get an authentication handler. Creates a new one if
@@ -196,8 +186,7 @@ module AdsCommon
     # - auth handler
     #
     def create_auth_handler(environment, version = nil)
-      auth_method_str = @config.read('authentication.method', 'ClientLogin')
-      auth_method = auth_method_str.to_s.upcase.to_sym
+      auth_method = @config.read('authentication.method', :CLIENTLOGIN)
       return case auth_method
         when :CLIENTLOGIN
           auth_server = api_config.auth_server(environment)
@@ -208,7 +197,7 @@ module AdsCommon
           AdsCommon::Auth::OAuthHandler.new(config, scope)
         else
           raise AdsCommon::Errors::Error,
-              "Unknown authentication method '%s'." % auth_method_str
+              "Unknown authentication method '%s'" % auth_method
         end
     end
 
@@ -256,13 +245,33 @@ module AdsCommon
     def load_config(provided_config = nil)
       @config = (provided_config.nil?) ?
           AdsCommon::Config.new(
-              File.join(ENV['HOME'], default_config_filename)) :
+              File.join(ENV['HOME'], api_config.default_config_filename)) :
           AdsCommon::Config.new(provided_config)
+      init_config()
     end
 
-    # Gets the default config filename.
-    def default_config_filename()
-      return api_config.default_config_filename
+    # Initializes config with default values and converts existing if required.
+    def init_config()
+      # Set up logger.
+      provided_logger = @config.read('library.logger')
+      self.logger = (provided_logger.nil?) ?
+          create_default_logger() : provided_logger
+
+      # Validating most important parameters.
+      ['service.environment', 'authentication.method'].each do |parameter|
+        symbolize_config_value(parameter)
+      end
+    end
+
+    # Converts value of a config key to uppercase symbol.
+    def symbolize_config_value(key)
+      value_str = @config.read(key).to_s
+      if !value_str.nil? and !value_str.empty?
+        value = value_str.upcase.to_sym
+        @config.set(key, value)
+      else
+        @logger.warn("Empty value for required parameter: '%s'" % key)
+      end
     end
 
     # Converts log level string (from config) to Logger value.

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.0'
+    ADS_COMMON_VERSION = '0.5.1'
 
     # Get the available API versions.
     #

data/lib/ads_common/auth/oauth_handler.rb

@@ -144,6 +144,8 @@ module AdsCommon
         validate_credentials(credentials)
         if @consumer.nil?
           oauth_config = OAUTH_CONFIG.merge({:scope => @scope})
+          proxy = @config.read('connection.proxy')
+          oauth_config[:proxy] = proxy if !proxy.nil?
           @consumer = OAuth::Consumer.new(credentials[:oauth_consumer_key],
               credentials[:oauth_consumer_secret], oauth_config)
         end
@@ -198,9 +200,9 @@ module AdsCommon
         callback = credentials[:oauth_callback] || DEFAULT_CALLBACK
         begin
           if @request_token.nil?
-            @request_token = @consumer.get_request_token(
-                {:oauth_callback => callback}, {:scope => @scope})
-            raise_oauth_verification_error(@request_token, callback)
+            @request_token = credentials[:oauth_request_token] ||
+                 @consumer.get_request_token({:oauth_callback => callback},
+                     {:scope => @scope})
           end
           verification_code = credentials[:oauth_verification_code]
           if verification_code.nil? || verification_code.empty?
@@ -236,7 +238,9 @@ module AdsCommon
       #
       def raise_oauth_verification_error(request_token, callback)
         oauth_url = request_token.authorize_url({:oauth_callback => callback})
-        raise AdsCommon::Errors::OAuthVerificationRequired, oauth_url
+        error = AdsCommon::Errors::OAuthVerificationRequired.new(
+            oauth_url, request_token)
+        raise error
       end
 
       # Extracts key-value pairs from OAuth server response.

data/lib/ads_common/build/savon_generator.rb

@@ -61,6 +61,7 @@ module AdsCommon
           config.log_level = :debug
         end
         HTTPI.logger = @logger
+        HTTPI.log_level = :debug
       end
 
       #

data/lib/ads_common/build/savon_registry_generator.rb

@@ -34,6 +34,8 @@ module AdsCommon
       #
       # <%= @generator_stamp %>
 
+      require '<%= @api_name.snakecase %>/errors'
+
       <%= @modules_open_string %>
 
         class <%= @service_name %>Registry

data/lib/ads_common/config.rb

@@ -2,7 +2,7 @@
 #
 # Authors:: api.dklimkin@gmail.com (Danial Klimkin)
 #
-# Copyright:: Copyright 2010, Google Inc. All Rights Reserved.
+# 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.
@@ -54,10 +54,10 @@ module AdsCommon
       if property_path
         last_node = @config
         last_name = property_path.split('.').inject(nil) do |last_name, section|
-          last_node = last_node[last_name.to_sym] ||= {} unless last_name.nil?
-          section
+          last_node = last_node[last_name] ||= {} unless last_name.nil?
+          section.to_sym
         end
-        last_node[last_name.to_sym] = value
+        last_node[last_name] = value
       end
       return nil
     end
@@ -65,6 +65,21 @@ module AdsCommon
     # Writes an entire set of properties.
     def set_all(properties)
       @config = process_hash_keys(properties)
+      return nil
+    end
+
+    # Reads a configuration file into instance variable as a Ruby structure with
+    # the complete set of keys and values.
+    #
+    # Args:
+    # - filename: config file to be read (*String*)
+    #
+    # Raises:
+    # - <b>Errno::ENOENT</b> if the file does not exist.
+    #
+    def load(filename)
+      @config = YAML::load_file(filename)
+      return nil
     end
 
     private
@@ -89,19 +104,5 @@ module AdsCommon
             (node.is_a?(Hash) and node.include?(key)) ? node[key] : nil
           end
     end
-
-    # Reads a configuration file into instance variable as a Ruby structure with
-    # the complete set of keys and values.
-    #
-    # Args:
-    # - filename: config file to be read (*String*)
-    #
-    # Raises:
-    # - <b>Errno::ENOENT</b> if the file does not exist.
-    #
-    def load(filename)
-      @config = YAML::load_file(filename)
-      return nil
-    end
   end
 end

data/lib/ads_common/errors.rb

@@ -42,9 +42,10 @@ module AdsCommon
     # Raised when OAuth access token is required.
     class OAuthVerificationRequired < AuthError
       attr_reader :oauth_url
-      def initialize(oauth_url)
+      attr_reader :request_token
+      def initialize(oauth_url, request_token)
         super()
-        @oauth_url = oauth_url
+        @oauth_url, @request_token = oauth_url, request_token
       end
     end
 

data/lib/ads_common/http.rb

@@ -30,7 +30,7 @@ module AdsCommon
     # Performs a get on a URL, using all of the connection options in the
     # client library, returning a HTTPI::Response.
     def self.get_response(url, config = nil, headers = nil)
-      request = prepare_request(config, url, headers)
+      request = prepare_request(url, config, headers)
       response = HTTPI.get(request)
       return response
     end
@@ -44,7 +44,7 @@ module AdsCommon
     # Performs a post on a URL, using all of the connection options in the
     # client library, returning a HTTPI::Response.
     def self.post_response(url, data, config = nil, headers = nil)
-      request = prepare_request(config, url, headers, data)
+      request = prepare_request(url, config, headers, data)
       response = HTTPI.post(request)
       return response
     end
@@ -59,17 +59,22 @@ module AdsCommon
 
     # Returns a suitably configured request object for a given URL and options.
     # Defaulting to stricter :peer validation.
-    def self.prepare_request(config, url, headers = nil, data = nil)
+    def self.prepare_request(url, config = nil, headers = nil, data = nil)
       request = HTTPI::Request.new(url)
-      proxy = config.read('connection.proxy', nil)
-      request.proxy = proxy if proxy
-      strict_ssl = config.nil? or
-          !(config.read('connection.strict_ssl_verification') == 'false')
-      request.auth.ssl.verify_mode = strict_ssl ? :peer : :none
       request.headers = headers if headers
       request.body = data if data
-      logger = config.read('library.logger')
-      HTTPI.logger = logger if logger
+      if config
+        proxy = config.read('connection.proxy', nil)
+        request.proxy = proxy if !proxy.nil?
+        strict_ssl =
+            !(config.read('connection.strict_ssl_verification') == 'false')
+        request.auth.ssl.verify_mode = strict_ssl ? :peer : :none
+        logger = config.read('library.logger')
+        if logger
+          HTTPI.logger = logger
+          HTTPI.log_level = :debug
+        end
+      end
       return request
     end
   end

data/lib/ads_common/savon_headers/base_header_handler.rb

@@ -19,6 +19,8 @@
 #
 # Base class for handlers of SOAP headers.
 
+require 'savon'
+
 module AdsCommon
   module SavonHeaders
     class BaseHeaderHandler
@@ -62,8 +64,12 @@ module AdsCommon
         soap.body = args if args
         # Sets the default namespace for the body.
         soap.input[2] = {:xmlns => @namespace}
+        # Sets User-Agent in the HTTP header.
+        request.headers['User-Agent'] = generate_user_agent_string()
       end
 
+      private
+
       # Adds namespace to the given string.
       #
       # Args:
@@ -75,6 +81,17 @@ module AdsCommon
       def prepend_namespace(str)
         return "%s:%s" % [DEFAULT_NAMESPACE, str]
       end
+
+      # Generates User-Agent text for HTTP request.
+      def generate_user_agent_string()
+        credentials = @credential_handler.credentials
+        app_name = credentials[:user_agent]
+        # 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.1'
+        soap_user_agent = "Common-Ruby-%s; %s" % [lib_version, app_name]
+        return "Savon/%s (%s)" % [Savon::Version, soap_user_agent]
+      end
     end
   end
 end

data/lib/ads_common/savon_service.rb

@@ -19,6 +19,7 @@
 #
 # Base class for all generated API services based on Savon backend.
 
+require 'httpi'
 require 'savon'
 
 module AdsCommon
@@ -26,6 +27,9 @@ module AdsCommon
     # Default namespace name.
     DEFAULT_NAMESPACE = 'wsdl'
 
+    # HTTP read timeout in seconds.
+    HTTP_READ_TIMEOUT = 15 * 60
+
     attr_accessor :headerhandler
     attr_reader :api
     attr_reader :version
@@ -34,28 +38,45 @@ module AdsCommon
     # Creates a new service.
     def initialize(api, endpoint, namespace, version)
       if self.class() == AdsCommon::SavonService
-        raise NoMethodError, "Tried to instantiate an abstract class"
+        raise NoMethodError, 'Tried to instantiate an abstract class'
       end
-      @api = api
-      @version = version
-      @namespace = namespace
+      @api, @version, @namespace = api, version, namespace
       @headerhandler = []
-      @client = Savon::Client.new do |wsdl|
-        wsdl.namespace = namespace
-        wsdl.endpoint = endpoint
-      end
+      @client = create_savon_client(endpoint, namespace)
     end
 
     private
 
-    # Returns ServiceRegistry for the current service. Has to be overriden.
+    # Sets the logger in Savon-specific way. Also sets it for HTTPI used by it.
+    def self.logger=(logger)
+      Savon.configure do |config|
+        config.log_level = :debug
+        config.logger = logger
+      end
+      HTTPI.logger = logger
+      HTTPI.log_level = :debug
+    end
+
+    # Returns ServiceRegistry for the current service. Has to be overridden.
     def get_service_registry()
-      raise NoMethodError, "This methods needs to be overriden"
+      raise NoMethodError, 'This method needs to be overridden'
     end
 
-    # Returns Module for the current service. Has to be overriden.
+    # Returns Module for the current service. Has to be overridden.
     def get_module()
-      raise NoMethodError, "This methods needs to be overriden"
+      raise NoMethodError, 'This method needs to be overridden'
+    end
+
+    # Creates and sets up Savon client.
+    def create_savon_client(endpoint, namespace)
+      proxy = @api.config.read('connection.proxy')
+      client = Savon::Client.new do |wsdl, http|
+        wsdl.endpoint = endpoint
+        wsdl.namespace = namespace
+        http.proxy = proxy if !proxy.nil?
+        http.read_timeout = HTTP_READ_TIMEOUT
+      end
+      return client
     end
 
     # Executes SOAP action specified as a string with given arguments.
@@ -131,7 +152,7 @@ module AdsCommon
         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])
+              "Incorrect xsi:type specified: '%s'" % [xsi_type])
         else
           # TODO: make sure xsi_type is derived from field_type.
           field_type = xsi_field_type
@@ -167,7 +188,7 @@ module AdsCommon
             [subtype_name, subtype]
           end
           # In case of non-default namespace, the children should be in
-          # overriden namespace but the node has to be in the default.
+          # 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)
@@ -196,7 +217,12 @@ module AdsCommon
     def add_attribute(node, key, name, value)
       node[:attributes!] ||= {}
       node[:attributes!][key] ||= {}
-      node[:attributes!][key][name] = value
+      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.
@@ -253,7 +279,24 @@ module AdsCommon
       action = method[:output][:name].to_sym
       result = response.to_hash
       result = result[action] if result.include?(action)
-      return normalize_output(result, method)
+      result = normalize_output(result, method)
+      result[:header] = extract_header_data(response) if result.kind_of?(Hash)
+      return result
+    end
+
+    # Extracts misc data from response header.
+    def extract_header_data(response)
+      header_type = get_full_type_signature(:SoapResponseHeader)
+      headers = response.header[:response_header].dup
+      result = headers.inject({}) do |result, (key, v)|
+        # Attributes start with '@' and are not included in type definition.
+        if !(key.to_s.start_with?('@'))
+          normalize_output_field(headers, header_type[:fields], key)
+          result[key] = headers[key]
+        end
+        result
+      end
+      return result
     end
 
     # Normalizes output starting with root node "rval".
@@ -271,26 +314,28 @@ module AdsCommon
     def normalize_output_field(output_data, fields_list, field_name)
       return nil if output_data.nil?
       field_definition = get_field_by_name(fields_list, field_name)
+      if field_definition.nil?
+        @api.logger.warn("Can not determine type for field: %s" % field_name)
+        return output_data
+      end
+
       field_sym = field_name.to_sym
-      output_data[field_sym] = normalize_type(output_data[field_sym],
-          field_definition)
+      field_data = normalize_type(output_data[field_sym], field_definition)
+      output_data[field_sym] = field_data if field_data
 
       sub_type = get_full_type_signature(field_definition[:type])
       if sub_type and sub_type[:fields]
         # go recursive
         sub_type[:fields].each do |sub_type_field|
-          if output_data[field_sym].is_a?(Array)
-            items_list = output_data[field_sym]
-            output_data[field_sym] = []
-            items_list.each do |item|
-              output_data[field_sym] <<
-                  normalize_output_field(item, sub_type_field,
-                                         sub_type_field[:name])
+          field_data = output_data[field_sym]
+          if field_data.is_a?(Array)
+            field_data.each do |item|
+              normalize_output_field(item, sub_type_field,
+                                     sub_type_field[:name])
             end
           else
-            output_data[field_sym] =
-                normalize_output_field(output_data[field_sym], sub_type_field,
-                                       sub_type_field[:name])
+            normalize_output_field(field_data, sub_type_field,
+                                   sub_type_field[:name])
           end
         end
       end
@@ -356,7 +401,11 @@ module AdsCommon
         parent_type = get_service_registry.get_type_signature(data_type[:base])
         result += implode_parent(parent_type)
       end
-      result += data_type[:fields]
+      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])}
+        result << field
+      end
       return result
     end
 

data/test/test_savon_service.rb

@@ -22,12 +22,25 @@
 require 'rubygems'
 require 'test/unit'
 
+require 'ads_common/config'
 require 'ads_common/savon_service'
 
+# AdsCommon::Api is abstract, defining a stub class for the test.
+class StubApi
+  attr_accessor :config
+  def initialize()
+    @config = AdsCommon::Config.new
+  end
+  def self.get_instance()
+    @api ||= StubApi.new
+    return @api
+  end
+end
+
 # SavonService is abstract, defining a child class for the test.
-class SomeService < AdsCommon::SavonService
+class StubService < AdsCommon::SavonService
   def initialize(namespace, endpoint, version)
-    super(nil, namespace, endpoint, version)
+    super(StubApi.get_instance(), namespace, endpoint, version)
   end
   def private_get_service_registry()
     return get_service_registry
@@ -47,6 +60,9 @@ class SomeService < AdsCommon::SavonService
   def private_deep_copy(object)
     return deep_copy(object)
   end
+  def private_add_attribute(node, key, name, value)
+    return add_attribute(node, key, name, value)
+  end
 end
 
 class TestSavonService < Test::Unit::TestCase
@@ -56,7 +72,7 @@ class TestSavonService < Test::Unit::TestCase
 
   # Initialize tests.
   def setup
-    @some_service = SomeService.new(TEST_NAMESPACE, TEST_ENDPOINT, TEST_VERSION)
+    @stub_service = StubService.new(TEST_NAMESPACE, TEST_ENDPOINT, TEST_VERSION)
   end
 
   def test_initialize_abstract
@@ -65,35 +81,35 @@ class TestSavonService < Test::Unit::TestCase
           TEST_VERSION)
     end
     assert_nothing_raised do
-      SomeService.new(TEST_NAMESPACE, TEST_ENDPOINT, TEST_VERSION)
+      StubService.new(TEST_NAMESPACE, TEST_ENDPOINT, TEST_VERSION)
     end
   end
 
   def test_get_service_registry_abstract
-    assert_raises(NoMethodError) { @some_service.private_get_service_registry }
+    assert_raises(NoMethodError) { @stub_service.private_get_service_registry }
   end
 
   def test_get_module_abstract
-    assert_raises(NoMethodError) { @some_service.private_get_module }
+    assert_raises(NoMethodError) { @stub_service.private_get_module }
   end
 
   def test_arrayize_empty
-    result1 = @some_service.private_arrayize(nil)
+    result1 = @stub_service.private_arrayize(nil)
     assert_instance_of(Array, result1, 'returned object is not an Array')
     assert_equal(0, result1.size, 'array is not empty')
 
-    result2 = @some_service.private_arrayize([])
+    result2 = @stub_service.private_arrayize([])
     assert_instance_of(Array, result2, 'returned object is not an Array')
     assert_equal(0, result2.size, 'array is not empty')
   end
 
   def test_arrayize_on_array
-    result1 = @some_service.private_arrayize([nil])
+    result1 = @stub_service.private_arrayize([nil])
     assert_instance_of(Array, result1, 'returned object is not an Array')
     assert_equal(1, result1.size, 'array changed size')
     assert_equal(nil, result1[0], 'array changed data')
 
-    result2 = @some_service.private_arrayize(['a', 'b'])
+    result2 = @stub_service.private_arrayize(['a', 'b'])
     assert_instance_of(Array, result2, 'returned object is not an Array')
     assert_equal(2, result2.size, 'array changed size')
     assert_equal('a', result2[0], 'array changed data')
@@ -101,119 +117,124 @@ class TestSavonService < Test::Unit::TestCase
   end
 
   def test_normalize_type_int
-    result1 = @some_service.private_normalize_type(5, {:type => 'int'})
+    result1 = @stub_service.private_normalize_type(5, {:type => 'int'})
     assert_kind_of(Integer, result1)
     assert_equal(5, result1, 'bad conversion')
 
-    result2 = @some_service.private_normalize_type(2147483648, {:type => 'int'})
+    result2 = @stub_service.private_normalize_type(2147483648, {:type => 'int'})
     assert_kind_of(Integer, result2)
     assert_equal(2147483648, result2, 'bad conversion')
   end
 
   def test_normalize_type_string
-    result1 = @some_service.private_normalize_type('foobar',
+    result1 = @stub_service.private_normalize_type('foobar',
         {:type => 'string'})
     assert_kind_of(String, result1)
     assert_equal('foobar', result1, 'bad conversion')
 
-    result2 = @some_service.private_normalize_type('', {:type => 'string'})
+    result2 = @stub_service.private_normalize_type('', {:type => 'string'})
     assert_kind_of(String, result2)
     assert_equal('', result2, 'bad conversion')
   end
 
   def test_normalize_type_long
-    result1 = @some_service.private_normalize_type(2147483648,
+    result1 = @stub_service.private_normalize_type(2147483648,
         {:type => 'long'})
     assert_kind_of(Integer, result1)
     assert_equal(2147483648, result1, 'bad conversion')
 
-    result2 = @some_service.private_normalize_type(-1, {:type => 'long'})
+    result2 = @stub_service.private_normalize_type(-1, {:type => 'long'})
     assert_kind_of(Integer, result2)
     assert_equal(-1, result2, 'bad conversion')
   end
 
   def test_normalize_type_boolean
-    result1 = @some_service.private_normalize_type(true, {:type => 'boolean'})
+    result1 = @stub_service.private_normalize_type(true, {:type => 'boolean'})
     assert_kind_of(TrueClass, result1)
 
-    result2 = @some_service.private_normalize_type(false, {:type => 'boolean'})
+    result2 = @stub_service.private_normalize_type(false, {:type => 'boolean'})
     assert_kind_of(FalseClass, result2)
 
-    result3 = @some_service.private_normalize_type('true', {:type => 'boolean'})
+    result3 = @stub_service.private_normalize_type('true', {:type => 'boolean'})
     assert_kind_of(TrueClass, result3)
 
-    result4 = @some_service.private_normalize_type('false',
+    result4 = @stub_service.private_normalize_type('false',
         {:type => 'boolean'})
     assert_kind_of(FalseClass, result4)
 
-    result5 = @some_service.private_normalize_type('True',
+    result5 = @stub_service.private_normalize_type('True',
         {:type => 'boolean'})
     assert_kind_of(TrueClass, result3)
 
-    result6 = @some_service.private_normalize_type('False',
+    result6 = @stub_service.private_normalize_type('False',
         {:type => 'boolean'})
     assert_kind_of(FalseClass, result4)
   end
 
   def test_normalize_type_object
-    result1 = @some_service.private_normalize_type({:a => 'b'},
-        {:type => 'SomeClass'})
+    result1 = @stub_service.private_normalize_type({:a => 'b'},
+        {:type => 'StubClass'})
     assert_equal('b', result1[:a], 'object corrupted')
 
-    result2 = @some_service.private_normalize_type(@some_service,
+    result2 = @stub_service.private_normalize_type(@stub_service,
         {:type => 'SavonService'})
-    assert_equal(@some_service.hash, result2.hash, 'object corrupted')
+    assert_equal(@stub_service.hash, result2.hash, 'object corrupted')
   end
 
   def test_normalize_type_double
-    result1 = @some_service.send(:private_normalize_type, 3.14,
+    result1 = @stub_service.send(:private_normalize_type, 3.14,
         {:type => 'double'})
     assert_kind_of(Float, result1)
     assert_equal(3.14, result1, 'bad conversion')
 
-    result2 = @some_service.send(:private_normalize_type, '-3.14',
+    result2 = @stub_service.send(:private_normalize_type, '-3.14',
         {:type => 'double'})
     assert_kind_of(Float, result2)
     assert_equal(-3.14, result2, 'bad conversion')
 
-    result3 = @some_service.send(:private_normalize_type, '42',
+    result3 = @stub_service.send(:private_normalize_type, '42',
         {:type => 'double'})
     assert_kind_of(Float, result3)
     assert_equal(42.0, result3, 'bad conversion')
   end
 
   def test_normalize_type_single_array_item
-    result1 = @some_service.private_normalize_type('42',
+    result1 = @stub_service.private_normalize_type('42',
         {:type => 'double', :min_occurs => '0', :max_occurs => 1})
     assert_kind_of(Float, result1)
-    assert_equal(42.0, result1, 'Float expected for max_occurs 1')
+    assert_equal(42.0, result1, 'Float is expected for max_occurs 1')
 
-    result2 = @some_service.private_normalize_type('42',
-        {:type => 'double', :min_occurs => '0', :max_occurs => nil})
+    result2 = @stub_service.private_normalize_type('42',
+        {:type => 'double', :min_occurs => '0', :max_occurs => :unbounded})
     assert_instance_of(Array, result2)
-    assert_equal(42.0, result2[0], 'Array is expected for undefined max_occurs')
+    assert_equal(42.0, result2[0], 'Array is expected for unbounded max_occurs')
 
-    result3 = @some_service.private_normalize_type('42',
+    result3 = @stub_service.private_normalize_type('42',
         {:type => 'double', :min_occurs => '0', :max_occurs => 2})
     assert_instance_of(Array, result3)
     assert_equal(42.0, result3[0], 'Array is expected for max_occurs > 1')
+
+    result4 = @stub_service.private_normalize_type('42',
+        {:type => 'double', :min_occurs => '0', :max_occurs => nil})
+    assert_instance_of(Float, result4)
+    assert_equal(42.0, result4, 'Float is expected for nil max_occurs')
   end
 
   def test_deep_copy_simple
-    result1 = @some_service.private_deep_copy(42)
+    result1 = @stub_service.private_deep_copy(42)
     assert_equal(42, result1)
 
-    result2 = @some_service.private_deep_copy('Hello World')
+    result2 = @stub_service.private_deep_copy('Hello World')
     assert_equal('Hello World', result2)
 
-    result3 = @some_service.private_deep_copy(nil)
+    result3 = @stub_service.private_deep_copy(nil)
     assert_nil(result3)
 
-    result4 = @some_service.private_deep_copy([])
+    result4 = @stub_service.private_deep_copy([])
     assert_equal([], result4)
     assert_not_same([], result4)
 
-    result5 = @some_service.private_deep_copy({})
+    result5 = @stub_service.private_deep_copy({})
     assert_equal({}, result5)
     assert_not_same({}, result5)
   end
@@ -221,11 +242,11 @@ class TestSavonService < Test::Unit::TestCase
   def test_deep_copy_complex
     data = {:ab => 'ab', :cd => ['cd', 'de', 'ef']}
 
-    result1 = @some_service.private_deep_copy(data)
+    result1 = @stub_service.private_deep_copy(data)
     assert_equal(data, result1)
     assert_not_same(data, result1)
 
-    result2 = @some_service.private_deep_copy(data)
+    result2 = @stub_service.private_deep_copy(data)
     assert_equal(result2, result1)
     assert_not_same(result2, result1)
 
@@ -233,4 +254,29 @@ class TestSavonService < Test::Unit::TestCase
     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

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: google-ads-common
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 9
   prerelease: false
   segments: 
   - 0
   - 5
-  - 0
-  version: 0.5.0
+  - 1
+  version: 0.5.1
 platform: ruby
 authors: 
 - Sergio Gomes
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-02 00:00:00 +04:00
+date: 2011-09-21 00:00:00 +04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency