google-ads-common 0.6.4 → 0.7.0

data/test/test_config.rb

@@ -53,7 +53,7 @@ class TestConfig < Test::Unit::TestCase
   end
 
   # Test initializer with filename argument.
-  def test_initialize_filename
+  def test_initialize_filename_correct
     config = AdsCommon::Config.new(DEFAULT_CONFIG_FILENAME)
     assert_equal(false, config.read('service.use_ruby_names'))
     assert_equal('sandbox', config.read('service.environment'))
@@ -63,13 +63,12 @@ class TestConfig < Test::Unit::TestCase
   end
 
   # Test initializer with an incorrect existing file.
-  def test_initialize_filename
+  def test_initialize_filename_incorrect
     assert_raises (AdsCommon::Errors::Error) do
       config = AdsCommon::Config.new('/dev/null')
     end
   end
 
-
   # Test default result.
   def test_read_default_result
     config = AdsCommon::Config.new(DEFAULT_CONFIG_HASH)
@@ -89,7 +88,7 @@ class TestConfig < Test::Unit::TestCase
   end
 
   # Test subhash.
-  def test_set
+  def test_get_hash
     config = AdsCommon::Config.new(DEFAULT_CONFIG_HASH)
     result = config.read('service')
     assert_instance_of(Hash, result)

data/test/test_credential_handler.rb

@@ -0,0 +1,55 @@
+#!/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.
+#
+# Tests credential handler methods.
+
+require 'logger'
+require 'test/unit'
+
+require 'ads_common/config'
+require 'ads_common/credential_handler'
+
+class TestCredentialHandler < Test::Unit::TestCase
+
+  def setup()
+    logger = Logger.new(STDERR)
+    @default_credentials = {:client_customer_id => '1234567890', :foo => 'bar'}
+    config = AdsCommon::Config.new({
+        :library => {:logger => logger},
+        :authentication => @default_credentials
+    })
+    @handler = AdsCommon::CredentialHandler.new(config)
+  end
+
+  def test_credentials_simple()
+    credentials = @handler.credentials()
+    assert_equal(@default_credentials, credentials)
+    assert_not_same(@default_credentials, credentials)
+  end
+
+  def test_credentials_override()
+    @override = {:client_customer_id => 42}
+    credentials = @handler.credentials(@override)
+    assert_not_equal(@default_credentials, credentials)
+    assert_not_same(@default_credentials, credentials)
+    assert_equal(42, credentials[:client_customer_id])
+    assert_equal('bar', credentials[:foo])
+  end
+end

data/test/test_parameters_validator.rb

@@ -28,7 +28,7 @@ require 'ads_common/parameters_validator'
 module AdsCommon
   class ParametersValidator
     public :deep_copy, :add_attribute, :array_from_named_list
-    public :check_required_argument_present
+    public :check_required_argument_present, :arrayize
   end
 end
 
@@ -129,4 +129,27 @@ class TestParametersValidator < Test::Unit::TestCase
       @validator.check_required_argument_present([field1, field2], field2)
     end
   end
+
+  def test_arrayize_empty
+    result1 = @validator.arrayize(nil)
+    assert_instance_of(Array, result1, 'returned object is not an Array')
+    assert_equal(0, result1.size, 'array is not empty')
+
+    result2 = @validator.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 = @validator.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 = @validator.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')
+    assert_equal('b', result2[1], 'array changed data')
+  end
 end

data/test/test_results_extractor.rb

@@ -0,0 +1,165 @@
+#!/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.
+#
+# Tests the array replies from services.
+
+require 'test/unit'
+
+require 'ads_common/results_extractor'
+
+module AdsCommon
+  class ResultsExtractor
+
+    public :check_array_collapse
+    public :normalize_item
+  end
+end
+
+class StubRegistry
+end
+
+class TestResultsExtractor < Test::Unit::TestCase
+
+  # Initialize tests.
+  def setup()
+    registry = StubRegistry.new()
+    @extractor = AdsCommon::ResultsExtractor.new(registry)
+  end
+
+  def test_normalize_item_nil()
+    result1 = @extractor.normalize_item(nil, {:type => 'unknown'})
+    assert_equal(nil, result1, 'bad conversion')
+  end
+
+  def test_normalize_item_int()
+    result1 = @extractor.normalize_item(5, {:type => 'int'})
+    assert_kind_of(Integer, result1)
+    assert_equal(5, result1, 'bad conversion')
+
+    result2 = @extractor.normalize_item(2147483648, {:type => 'int'})
+    assert_kind_of(Integer, result2)
+    assert_equal(2147483648, result2, 'bad conversion')
+  end
+
+  def test_normalize_item_string()
+    result1 = @extractor.normalize_item('foobar',
+        {:type => 'string'})
+    assert_kind_of(String, result1)
+    assert_equal('foobar', result1, 'bad conversion')
+
+    result2 = @extractor.normalize_item('', {:type => 'string'})
+    assert_kind_of(String, result2)
+    assert_equal('', result2, 'bad conversion')
+  end
+
+  def test_normalize_item_long()
+    result1 = @extractor.normalize_item(2147483648,
+        {:type => 'long'})
+    assert_kind_of(Integer, result1)
+    assert_equal(2147483648, result1, 'bad conversion')
+
+    result2 = @extractor.normalize_item(-1, {:type => 'long'})
+    assert_kind_of(Integer, result2)
+    assert_equal(-1, result2, 'bad conversion')
+  end
+
+  def test_normalize_item_boolean()
+    result1 = @extractor.normalize_item(true, {:type => 'boolean'})
+    assert_kind_of(TrueClass, result1)
+
+    result2 = @extractor.normalize_item(false, {:type => 'boolean'})
+    assert_kind_of(FalseClass, result2)
+
+    result3 = @extractor.normalize_item('true', {:type => 'boolean'})
+    assert_kind_of(TrueClass, result3)
+
+    result4 = @extractor.normalize_item('false',
+        {:type => 'boolean'})
+    assert_kind_of(FalseClass, result4)
+
+    result5 = @extractor.normalize_item('True',
+        {:type => 'boolean'})
+    assert_kind_of(TrueClass, result3)
+
+    result6 = @extractor.normalize_item('False',
+        {:type => 'boolean'})
+    assert_kind_of(FalseClass, result4)
+  end
+
+  def test_normalize_item_object()
+    result1 = @extractor.normalize_item({:a => 'b'},
+        {:type => 'StubClass'})
+    assert_equal('b', result1[:a], 'object corrupted')
+
+    result2 = @extractor.normalize_item(@extractor,
+        {:type => 'SavonService'})
+    assert_equal(@extractor.hash, result2.hash, 'object corrupted')
+  end
+
+  def test_normalize_item_double()
+    result1 = @extractor.normalize_item(3.14, {:type => 'double'})
+    assert_kind_of(Float, result1)
+    assert_equal(3.14, result1, 'bad conversion')
+
+    result2 = @extractor.normalize_item('-3.14', {:type => 'double'})
+    assert_kind_of(Float, result2)
+    assert_equal(-3.14, result2, 'bad conversion')
+
+    result3 = @extractor.normalize_item('42', {:type => 'double'})
+    assert_kind_of(Float, result3)
+    assert_equal(42.0, result3, 'bad conversion')
+  end
+
+  def test_check_array_collapse()
+    result1 = @extractor.check_array_collapse(
+        42.0, {:min_occurs => '0', :max_occurs => 1})
+    assert_kind_of(Float, result1)
+    assert_equal(42.0, result1, 'Float is expected for max_occurs 1')
+
+    result2 = @extractor.check_array_collapse(
+        42.0, {:min_occurs => '0', :max_occurs => :unbounded})
+    assert_instance_of(Array, result2)
+    assert_equal(42.0, result2[0])
+
+    result3 = @extractor.check_array_collapse(
+        42.0, {:min_occurs => '0', :max_occurs => 2})
+    assert_instance_of(Array, result3)
+    assert_equal(42.0, result3[0])
+
+    result4 = @extractor.check_array_collapse(
+        42.0, {:min_occurs => '0', :max_occurs => nil})
+    assert_instance_of(Float, result4)
+    assert_equal(42.0, result4, 'Float is expected for nil max_occurs')
+
+    result5 = @extractor.check_array_collapse(
+        [42, -1], {:min_occurs => '0', :max_occurs => :unbounded})
+    assert_instance_of(Array, result5)
+    assert_equal(42, result5[0])
+    assert_equal(-1, result5[1])
+
+    result6 = @extractor.check_array_collapse(
+        {}, {:min_occurs => '0', :max_occurs => 1})
+    assert_equal({}, result6)
+
+    result7 = @extractor.check_array_collapse(
+        {}, {:min_occurs => '0', :max_occurs => :unbounded})
+    assert_equal([{}], result7)
+  end
+end

data/test/test_savon_service.rb

@@ -25,57 +25,31 @@ 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 StubService < AdsCommon::SavonService
+
+  public :get_service_registry, :get_module
+
   def initialize(namespace, endpoint, version)
-    super(StubApi.get_instance(), namespace, endpoint, version)
-  end
-  def private_get_service_registry()
-    return get_service_registry
-  end
-  def private_get_module()
-    return get_module
-  end
-  def private_normalize_type(data, field)
-    return normalize_type(data, field)
-  end
-  def private_get_field_by_name(fields_list, name)
-    return get_field_by_name(fields_list, name)
-  end
-  def private_arrayize(object)
-    return arrayize(object)
-  end
-  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)
+    @logger = Logger.new(STDERR)
+    @config = AdsCommon::Config.new({:library => {:logger => @logger}})
+    super(@config, namespace, endpoint, version)
   end
 end
 
+
 class TestSavonService < Test::Unit::TestCase
+
   TEST_NAMESPACE = 'namespace'
   TEST_ENDPOINT = 'endpoint'
   TEST_VERSION = :vVersion
 
   # Initialize tests.
-  def setup
+  def setup()
     @stub_service = StubService.new(TEST_NAMESPACE, TEST_ENDPOINT, TEST_VERSION)
   end
 
-  def test_initialize_abstract
+  def test_initialize_abstract()
     assert_raises(NoMethodError) do
       AdsCommon::SavonService.new(nil, TEST_NAMESPACE, TEST_ENDPOINT,
           TEST_VERSION)
@@ -85,138 +59,11 @@ class TestSavonService < Test::Unit::TestCase
     end
   end
 
-  def test_get_service_registry_abstract
-    assert_raises(NoMethodError) { @stub_service.private_get_service_registry }
-  end
-
-  def test_get_module_abstract
-    assert_raises(NoMethodError) { @stub_service.private_get_module }
-  end
-
-  def test_arrayize_empty
-    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 = @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 = @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 = @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')
-    assert_equal('b', result2[1], 'array changed data')
+  def test_get_service_registry_abstract()
+    assert_raises(NoMethodError) { @stub_service.get_service_registry() }
   end
 
-  def test_normalize_type_int
-    result1 = @stub_service.private_normalize_type(5, {:type => 'int'})
-    assert_kind_of(Integer, result1)
-    assert_equal(5, result1, 'bad conversion')
-
-    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 = @stub_service.private_normalize_type('foobar',
-        {:type => 'string'})
-    assert_kind_of(String, result1)
-    assert_equal('foobar', result1, 'bad conversion')
-
-    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 = @stub_service.private_normalize_type(2147483648,
-        {:type => 'long'})
-    assert_kind_of(Integer, result1)
-    assert_equal(2147483648, result1, 'bad conversion')
-
-    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 = @stub_service.private_normalize_type(true, {:type => 'boolean'})
-    assert_kind_of(TrueClass, result1)
-
-    result2 = @stub_service.private_normalize_type(false, {:type => 'boolean'})
-    assert_kind_of(FalseClass, result2)
-
-    result3 = @stub_service.private_normalize_type('true', {:type => 'boolean'})
-    assert_kind_of(TrueClass, result3)
-
-    result4 = @stub_service.private_normalize_type('false',
-        {:type => 'boolean'})
-    assert_kind_of(FalseClass, result4)
-
-    result5 = @stub_service.private_normalize_type('True',
-        {:type => 'boolean'})
-    assert_kind_of(TrueClass, result3)
-
-    result6 = @stub_service.private_normalize_type('False',
-        {:type => 'boolean'})
-    assert_kind_of(FalseClass, result4)
-  end
-
-  def test_normalize_type_object
-    result1 = @stub_service.private_normalize_type({:a => 'b'},
-        {:type => 'StubClass'})
-    assert_equal('b', result1[:a], 'object corrupted')
-
-    result2 = @stub_service.private_normalize_type(@stub_service,
-        {:type => 'SavonService'})
-    assert_equal(@stub_service.hash, result2.hash, 'object corrupted')
-  end
-
-  def test_normalize_type_double
-    result1 = @stub_service.send(:private_normalize_type, 3.14,
-        {:type => 'double'})
-    assert_kind_of(Float, result1)
-    assert_equal(3.14, result1, 'bad conversion')
-
-    result2 = @stub_service.send(:private_normalize_type, '-3.14',
-        {:type => 'double'})
-    assert_kind_of(Float, result2)
-    assert_equal(-3.14, result2, 'bad conversion')
-
-    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 = @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 is expected for max_occurs 1')
-
-    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 unbounded max_occurs')
-
-    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')
+  def test_get_module_abstract()
+    assert_raises(NoMethodError) { @stub_service.get_module() }
   end
 end