google-ads-common 0.6.4 → 0.7.0

data/lib/ads_common/savon_headers/oauth_header_handler.rb

@@ -25,22 +25,6 @@ require 'ads_common/savon_headers/httpi_request_proxy'
 module AdsCommon
   module SavonHeaders
     class OAuthHeaderHandler < BaseHeaderHandler
-      # Enriches soap object with API-specific headers like namespaces, login
-      # credentials etc. Sets the default namespace for the body to the one
-      # specified in initializer.
-      #
-      # Args:
-      #  - request: a HTTPI Request for extra configuration
-      #  - soap: a Savon soap object to fill fields in
-      #  - args: request parameters to adjust for namespaces
-      #
-      # Returns:
-      #  - Modified soap structure
-      #
-      def prepare_request(request, soap, args)
-        super(request, soap, args)
-        generate_headers(request, soap)
-      end
 
       private
 
@@ -55,20 +39,11 @@ module AdsCommon
       #  - Hash containing a header with filled in credentials
       #
       def generate_headers(request, soap)
+        super(request, soap)
         credentials = @credential_handler.credentials
-        headers = @auth_handler.headers(credentials)
-        request_header = headers.inject({}) do |request_header, (header, value)|
-          if header == :access_token
-            request.url = soap.endpoint
-            request.headers['Authorization'] =
-                @auth_handler.generate_oauth_parameters_string(credentials,
-                    request)
-          else
-            request_header[prepend_namespace(header)] = value
-          end
-          request_header
-        end
-        soap.header[prepend_namespace(@element_name)] = request_header
+        request.url = soap.endpoint
+        request.headers['Authorization'] =
+            @auth_handler.auth_string(credentials, request)
       end
     end
   end

data/lib/ads_common/savon_service.rb

@@ -19,37 +19,34 @@
 #
 # Base class for all generated API services based on Savon backend.
 
-require 'httpi'
 require 'savon'
 
 require 'ads_common/http'
 require 'ads_common/parameters_validator'
+require 'ads_common/results_extractor'
 
 module AdsCommon
   class SavonService
-    attr_accessor :headerhandler
-    attr_reader :api
+
+    attr_accessor :header_handler
+    attr_reader :config
     attr_reader :version
     attr_reader :namespace
 
     # Creates a new service.
-    def initialize(api, endpoint, namespace, version)
+    def initialize(config, endpoint, namespace, version)
       if self.class() == AdsCommon::SavonService
         raise NoMethodError, 'Tried to instantiate an abstract class'
       end
-      @api, @version, @namespace = api, version, namespace
-      @headerhandler = []
+      @config, @version, @namespace = config, version, namespace
       @client = create_savon_client(endpoint, namespace)
     end
 
     private
 
-    # 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
+    # Returns currently configured Logger.
+    def get_logger()
+      return @config.read('library.logger')
     end
 
     # Returns ServiceRegistry for the current service. Has to be overridden.
@@ -68,26 +65,35 @@ module AdsCommon
       client = Savon::Client.new do |wsdl, httpi|
         wsdl.endpoint = endpoint
         wsdl.namespace = namespace
-        AdsCommon::Http.configure_httpi(@api.config, httpi)
+        AdsCommon::Http.configure_httpi(@config, httpi)
+      end
+      Savon.configure do |config|
+        config.raise_errors = false
+        config.log_level = :debug
+        config.logger = get_logger()
       end
       return client
     end
 
     # Executes SOAP action specified as a string with given arguments.
     def execute_action(action_name, args, &block)
-      validator = ParametersValidator.new(get_service_registry())
+      registry = get_service_registry()
+      validator = ParametersValidator.new(registry)
       args = validator.validate_args(action_name, args)
       response = execute_soap_request(
           action_name.to_sym, args, validator.extra_namespaces)
       log_headers(response.http.headers)
       handle_errors(response)
-      return extract_result(response, action_name, &block)
+      extractor = ResultsExtractor.new(registry)
+      result = extractor.extract_result(response, action_name, &block)
+      run_user_block(extractor, response, result, &block) if block_given?
+      return result
     end
 
     # Logs response headers.
     # TODO: this needs to go on http or httpi level.
     def log_headers(headers)
-      @api.logger.debug(headers.map {|k, v| [k, v].join(': ')}.join(', '))
+      get_logger().debug(headers.map {|k, v| [k, v].join(': ')}.join(', '))
     end
 
     # Executes the SOAP request with original SOAP name.
@@ -96,16 +102,15 @@ module AdsCommon
           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, extra_namespaces)
+        soap.body = args
+        set_headers(soap, extra_namespaces)
       end
       return response
     end
 
     # Executes each handler to generate SOAP headers.
-    def set_headers(soap, args, extra_namespaces)
-      @headerhandler.each do |handler|
-        handler.prepare_request(@client.http, soap, args)
-      end
+    def set_headers(soap, extra_namespaces)
+      header_handler.prepare_request(@client.http, soap)
       soap.namespaces.merge!(extra_namespaces) unless extra_namespaces.nil?
     end
 
@@ -144,22 +149,10 @@ module AdsCommon
       end
     end
 
-    # Extracts the finest results possible for the given result. Returns the
-    # response itself in worst case (contents unknown).
-    def extract_result(response, action_name, &block)
-      method = get_service_registry.get_method_signature(action_name)
-      action = method[:output][:name].to_sym
-      result = response.to_hash
-      result = result[action] if result.include?(action)
-      result = normalize_output(result, method)
-      run_user_block(response, result, &block) if block_given?
-      return result
-    end
-
     # Yields to user-specified block with additional information such as
     # headers.
-    def run_user_block(response, body, &block)
-      header = extract_header_data(response)
+    def run_user_block(extractor, response, body, &block)
+      header = extractor.extract_header_data(response)
       case block.arity
         when 1 then yield(header)
         when 2 then yield(header, body)
@@ -169,144 +162,5 @@ module AdsCommon
       end
       return nil
     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
-      process_attributes(headers, false)
-      result = headers.inject({}) do |result, (key, v)|
-        normalize_output_field(headers, header_type[:fields], key)
-        result[key] = headers[key]
-        result
-      end
-      return result
-    end
-
-    # Normalizes output starting with root node "rval".
-    def normalize_output(output_data, method_definition)
-      fields_list = method_definition[:output][:fields]
-      result = normalize_output_field(output_data, fields_list, :rval)
-      return result[:rval] || result
-    end
-
-    # Normalizes one field of a given data recursively.
-    # Args:
-    #  - output_data: XML data to normalize
-    #  - fields_list: expected list of fields from signature
-    #  - field_name: specifies field name to normalize
-    def normalize_output_field(output_data, fields_list, field_name)
-      return nil if output_data.nil?
-
-      process_attributes(output_data, true)
-
-      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
-      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|
-          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
-            normalize_output_field(field_data, sub_type_field,
-                                   sub_type_field[:name])
-          end
-        end
-      end
-      return output_data
-    end
-
-    # Converts XML input string into a native format.
-    def normalize_type(data, field)
-      type_name = field[:type]
-      result = case data
-        when Array
-          data.map {|item| normalize_item(type_name, item)}
-        else
-          normalize_item(type_name, data)
-      end
-      # If field signature allows an array, forcing array structure even for one
-      # item.
-      if !field[:min_occurs].nil? and
-          (field[:max_occurs] == :unbounded ||
-              (!field[:max_occurs].nil? and field[:max_occurs] > 1))
-        result = arrayize(result)
-      end
-      return result
-    end
-
-    # Converts one leaf item to a built-in type.
-    def normalize_item(type_name, item)
-      return (item.nil?) ? item :
-          case type_name
-            when 'long', 'int' then Integer(item)
-            when 'double', 'float' then Float(item)
-            when 'boolean' then item.kind_of?(String) ?
-                item.casecmp('true') == 0 : item
-            else item
-          end
-    end
-
-    # Finds a field in a list by its name.
-    def get_field_by_name(fields_list, name)
-      fields_array = arrayize(fields_list)
-      index = fields_array.find_index {|field| field[:name].eql?(name)}
-      return (index.nil?) ? nil : fields_array.at(index)
-    end
-
-    # Makes sure object is an array.
-    def arrayize(object)
-      return [] if object.nil?
-      return object.is_a?(Array) ? object : [object]
-    end
-
-    # Returns all inherited fields of superclasses for given type.
-    def implode_parent(data_type)
-      result = []
-      if data_type[:base]
-        parent_type = get_service_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])}
-        result << field
-      end
-      return result
-    end
-
-    # Returns type signature with all inherited fields.
-    def get_full_type_signature(type_name)
-      result = (type_name.nil?) ? nil :
-          get_service_registry.get_type_signature(type_name)
-      if result and result[:base]
-        result[:fields] = implode_parent(result)
-      end
-      return result
-    end
-
-    # Handles attributes received from Savon.
-    def process_attributes(data, keep_xsi_type = false)
-      if data.kind_of?(Hash)
-        if keep_xsi_type
-          xsi_type = data.delete(:"@xsi:type")
-          data[:xsi_type] = xsi_type if xsi_type
-        end
-        data.reject! {|key, value| key.to_s.start_with?('@')}
-      end
-    end
   end
 end

data/lib/ads_common/version.rb

@@ -21,6 +21,6 @@
 
 module AdsCommon
   module ApiConfig
-    CLIENT_LIB_VERSION = '0.6.4'
+    CLIENT_LIB_VERSION = '0.7.0'
   end
 end

data/test/coverage.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# Encoding: utf-8
+#
+# Author:: api.dklimkin@gmail.com (Danial Klimkin)
+#
+# Copyright:: Copyright 2012, 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.
+#
+# Runs test with coverage tool.
+
+require 'simplecov'
+
+SimpleCov.start
+
+$:.unshift File.expand_path('../../', __FILE__)
+require File.join(File.dirname(__FILE__), 'suite_unittests.rb')
+
+# Now loading all files in the library to make sure we hit all untested files.
+lib_base_path = File.expand_path('../../lib', __FILE__)
+$:.unshift lib_base_path
+
+code_files_mask = File.join(lib_base_path, '**/*.rb')
+Dir.glob(code_files_mask).each {|file| require file}

data/test/suite_unittests.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+# Encoding: utf-8
+#
+# Author:: api.dklimkin@gmail.com (Danial Klimkin)
+#
+# Copyright:: Copyright 2012, 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.
+#
+# Test suite for unit tests.
+
+require 'test/unit'
+
+$:.unshift File.expand_path('../../lib/', __FILE__)
+$:.unshift File.expand_path('../../', __FILE__)
+
+# Ads Common units tests.
+test_files_mask = File.join(File.dirname(__FILE__), 'test_*.rb')
+Dir.glob(test_files_mask).each {|file| require file}

data/test/test_client_login_handler.rb

@@ -28,14 +28,19 @@ require 'ads_common/auth/client_login_handler'
 module AdsCommon
   module Auth
     class ClientLoginHandler
+
       public :parse_token_text
       public :handle_login_error
+      public :validate_credentials
+      public :create_token_from_string
     end
   end
 end
 
+
 # Stub class for HTTP response.
 class ResponseStub
+
   attr_reader :code
   attr_reader :body
 
@@ -44,14 +49,15 @@ class ResponseStub
   end
 end
 
-class TestParametersValidator < Test::Unit::TestCase
-  def setup
+class TestClientLoginHandler < Test::Unit::TestCase
+
+  def setup()
     config = AdsCommon::Config.new({})
     @handler = AdsCommon::Auth::ClientLoginHandler.new(
-        config, 'http://www.google.com', nil)
+        config, 'http://www.google.com', 'adwords')
   end
 
-  def test_handle_login_error_captcha
+  def test_handle_login_error_captcha()
     assert_raises (AdsCommon::Errors::CaptchaRequiredError) do
       response = ResponseStub.new(403, '')
       results = {
@@ -62,15 +68,15 @@ class TestParametersValidator < Test::Unit::TestCase
     end
   end
 
-  def test_handle_login_error_other
-    assert_raises (AdsCommon::Errors::AuthError) do
+  def test_handle_login_error_other()
+    assert_raises(AdsCommon::Errors::AuthError) do
       response = ResponseStub.new(403, 'Body')
       results = {'Error' => 'SomeError', 'Info' => 'SomeInfo'}
       @handler.handle_login_error({}, response, results)
     end
   end
 
-  def test_parse_token_text_simple
+  def test_parse_token_text_simple()
     error_str = "BadAuthentication"
     text = "Error=%s\n" % error_str
     result = @handler.parse_token_text(text)
@@ -78,7 +84,7 @@ class TestParametersValidator < Test::Unit::TestCase
     assert_equal(['Error'], result.keys)
   end
 
-  def test_parse_token_text_captcha
+  def test_parse_token_text_captcha()
     captcha_token = "3u6_27iOel71j525g2tg252ge6t35g345XJtRuHYEYiTyAxsMPz2222442"
     captcha_url = "Captcha?ctoken=3u245245rgfwrg5g2fw5x3xGqQBrk_AoXXJtRuHY%3a-V"
     error_str = "CaptchaRequired"
@@ -95,4 +101,31 @@ class TestParametersValidator < Test::Unit::TestCase
     assert_equal(['CaptchaToken', 'CaptchaUrl', 'Error', 'Url'],
         result.keys.sort)
   end
+
+  def test_validate_credentials_valid()
+    credentials1 = {:email => 'email@example.com', :password => 'qwerty'}
+    credentials2 = {:auth_token => 'QazSWXEDEDCE434234'}
+    assert_nothing_raised do
+      @handler.validate_credentials(credentials1)
+    end
+    assert_nothing_raised do
+      @handler.validate_credentials(credentials2)
+    end
+  end
+
+  def test_validate_credentials_invalid()
+    credentials1 = {:email => 'email@example.com'}
+    credentials2 = {:password => 'qwerty'}
+    assert_raises(AdsCommon::Errors::AuthError) do
+      @handler.validate_credentials(credentials1)
+    end
+    assert_raises(AdsCommon::Errors::AuthError) do
+      @handler.validate_credentials(credentials2)
+    end
+  end
+
+  def test_create_token_from_string()
+    test_text = 'fooBar'
+    assert_equal(test_text, @handler.create_token_from_string(test_text))
+  end
 end