google-ads-common 0.14.0 → 1.0.3

data/test/test_parameters_validator.rb

@@ -1,153 +0,0 @@
-#!/usr/bin/env ruby
-# Encoding: utf-8
-#
-# 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 'test/unit'
-
-require 'ads_common/errors'
-require 'ads_common/parameters_validator'
-
-module AdsCommon
-  class ParametersValidator
-    public :deep_copy, :add_attribute, :array_from_named_list
-    public :check_required_argument_present, :arrayize
-  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
-
-  def test_check_required_argument_present
-    field1 = {:min_occurs => 1, :max_occurs => 1,
-              :name => 'field1', :type => 'type1'}
-    assert_raises(AdsCommon::Errors::MissingPropertyError) do
-      @validator.check_required_argument_present(nil, field1)
-    end
-    assert_raises(AdsCommon::Errors::TypeMismatchError) do
-      @validator.check_required_argument_present([], field1)
-    end
-    assert_nothing_raised do
-      @validator.check_required_argument_present({}, field1)
-      @validator.check_required_argument_present('foobar', field1)
-      @validator.check_required_argument_present(42, field1)
-    end
-
-    field2 = {:min_occurs => 0, :max_occurs => :unbounded,
-              :name => 'field2', :type => 'type2'}
-    assert_raises(AdsCommon::Errors::TypeMismatchError) do
-      @validator.check_required_argument_present({}, field2)
-    end
-    assert_nothing_raised do
-      @validator.check_required_argument_present(nil, field2)
-      @validator.check_required_argument_present([], field2)
-      @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

@@ -1,250 +0,0 @@
-#!/usr/bin/env ruby
-# Encoding: utf-8
-#
-# 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
-    public :check_key_value_struct
-    public :check_key_value_hash
-    public :convert_key_value_to_hash
-  end
-end
-
-class StubRegistry
-  def get_type_signature(type_name)
-    if type_name == :SoapResponseHeader
-      return {:fields => []}
-    else
-      return nil
-    end
-  end
-end
-
-class StubResponse
-  attr_accessor :header
-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, result5)
-
-    result6 = @extractor.normalize_item('False', {:type => 'boolean'})
-    assert_kind_of(FalseClass, result6)
-  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
-
-  def test_check_array_collapse_exception()
-    result1 = @extractor.check_array_collapse(
-        42.0, {:min_occurs => '0', :max_occurs => 2, :type => 'FloatMapEntry'})
-    assert_kind_of(Float, result1)
-    assert_equal(42.0, result1)
-
-    result2 = @extractor.check_array_collapse(
-        42.0, {:min_occurs => '0', :max_occurs => 2, :type => 'MapEntryTest'})
-    assert_kind_of(Array, result2)
-    assert_equal(42.0, result2[0])
-  end
-
-  def test_extract_headers_empty()
-    headers = {}
-    response = StubResponse.new()
-    response.header = {:response_header => headers}
-    result = @extractor.extract_header_data(response)
-    assert_equal(headers, result)
-    assert_not_same(headers, result)
-  end
-
-  def test_extract_headers_passthrough()
-    headers = {:a => 'aa', :b => '42'}
-    response = StubResponse.new()
-    response.header = {:response_header => headers}
-    result = @extractor.extract_header_data(response)
-    assert_equal(headers, result)
-    assert_not_same(headers, result)
-  end
-
-  def test_extract_headers_attrs_removed()
-    headers = {:a => 'aa', :@xmlns => '42'}
-    expected = {:a => 'aa'}
-    response = StubResponse.new()
-    response.header = {:response_header => headers}
-    result = @extractor.extract_header_data(response)
-    assert_equal(expected, result)
-  end
-
-  def test_check_key_value_struct()
-    assert(!@extractor.check_key_value_struct([]))
-    assert(!@extractor.check_key_value_struct({}))
-
-    test1 = [{:key => 'foo', :value => 'bar'}]
-    assert(@extractor.check_key_value_struct(test1))
-    test2 = [{:key => 'foo'}]
-    assert(!@extractor.check_key_value_struct(test2))
-    test3 = [{:key => 'foo', :value => 'bar', :extra => 42}]
-    assert(!@extractor.check_key_value_struct(test3))
-    test4 = [{:key => 'foo', :value => 'bar'}, {:baz => 'bar'}]
-    assert(!@extractor.check_key_value_struct(test4))
-    test5 = [
-      {:key => 'foo', :value => 'bar'},
-      {:key => 'bar', :value => {:bar => 'baz'}}
-    ]
-    assert(@extractor.check_key_value_struct(test5))
-    test6 = {:key => 'foo', :value => 'bar'}
-    assert(@extractor.check_key_value_struct(test6))
-    test7 = {:key => 'foo'}
-    assert(!@extractor.check_key_value_struct(test7))
-    test8 = {:value => 'baz', :key => 'foo'}
-    assert(@extractor.check_key_value_struct(test8))
-  end
-
-  def test_convert_key_value_to_hash()
-    result1 = @extractor.convert_key_value_to_hash(
-        [{:key => 'foo', :value => 'bar'}, {:key => 42, :value => 88.2}])
-    assert_kind_of(Hash, result1)
-    assert(result1.include?('foo'))
-    assert(result1.include?(42))
-    assert_equal('bar', result1['foo'])
-    assert_equal(88.2, result1[42])
-    result2 = @extractor.convert_key_value_to_hash(
-        {:key => 'foo', :value => 'bar'})
-    assert_kind_of(Hash, result2)
-    assert_equal(['foo'], result2.keys)
-    assert_equal('bar', result2['foo'])
-  end
-end

data/test/test_savon_service.rb

@@ -1,125 +0,0 @@
-#!/usr/bin/env ruby
-# Encoding: utf-8
-#
-# 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 the array replies from services.
-
-require 'test/unit'
-require 'logger'
-
-require 'ads_common/config'
-require 'ads_common/savon_service'
-
-# SavonService is abstract, defining a child class for the test.
-class StubService < AdsCommon::SavonService
-
-  public :get_service_registry, :get_module
-  public :format_headers, :sanitize_request, :format_fault
-  public :should_log_summary, :should_log_payloads
-
-  def initialize(namespace, endpoint, version)
-    @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()
-    @stub_service = StubService.new(TEST_NAMESPACE, TEST_ENDPOINT, TEST_VERSION)
-  end
-
-  def test_initialize_abstract()
-    assert_raises(NoMethodError) do
-      AdsCommon::SavonService.new(nil, TEST_NAMESPACE, TEST_ENDPOINT,
-          TEST_VERSION)
-    end
-    assert_nothing_raised do
-      StubService.new(TEST_NAMESPACE, TEST_ENDPOINT, TEST_VERSION)
-    end
-  end
-
-  def test_get_service_registry_abstract()
-    assert_raises(NoMethodError) { @stub_service.get_service_registry() }
-  end
-
-  def test_get_module_abstract()
-    assert_raises(NoMethodError) { @stub_service.get_module() }
-  end
-
-  def test_format_headers()
-    test1 = {
-      'header1' => 'value1',
-      'header2' => 'value2'
-    }
-    expected1 = "header1: value1, header2: value2"
-    test2 = {
-      'Authorization' => 'Bearer ABCD',
-      'header3' => 'value3'
-    }
-    expected2 = "Authorization: REDACTED, header3: value3"
-    assert_equal(expected1, @stub_service.format_headers(test1))
-    assert_equal(expected2, @stub_service.format_headers(test2))
-  end
-
-  def test_sanitize_request()
-    test1 = "<some_xml><developerToken>ab1cdEF2GH-IJ3KL_mn4OP" +
-        "</developerToken></some_xml>"
-    expected1 = "<some_xml><developerToken>REDACTED</developerToken></some_xml>"
-    test2 = "<xml><element1></element1><element2></element2></xml>"
-    test3 = "<xml><ns1:developerToken>w-x_Y-Z_</ns1:developerToken></xml>"
-    expected3 = "<xml><ns1:developerToken>REDACTED</ns1:developerToken></xml>"
-    assert_equal(expected1, @stub_service.sanitize_request(test1))
-    assert_equal(test2, @stub_service.sanitize_request(test2))
-    assert_equal(expected3, @stub_service.sanitize_request(test3))
-  end
-
-  def test_format_fault()
-    test1 = "fault\nwith\nnewlines\nand\nunicode\n\u2713\n"+
-        "\u3084\u3063\u305F".encode('utf-8')
-    expected1 = "fault with newlines and unicode \u2713 \u3084\u3063\u305F"
-    test2 = "This needs to be more than 16000 characters......." * 1000
-    expected2 = "This needs to be more than 16000 characters......." * 320
-    assert(test2.length > AdsCommon::SavonService::MAX_FAULT_LOG_LENGTH)
-    assert(expected2.length == AdsCommon::SavonService::MAX_FAULT_LOG_LENGTH)
-    assert_equal(expected1, @stub_service.format_fault(test1))
-    assert_equal(expected2, @stub_service.format_fault(test2))
-  end
-
-  def test_log_levels()
-    assert_equal(true, @stub_service.should_log_payloads(Logger::DEBUG, true))
-    assert_equal(true, @stub_service.should_log_payloads(Logger::DEBUG, false))
-    assert_equal(true, @stub_service.should_log_payloads(Logger::INFO, true))
-    assert_equal(false, @stub_service.should_log_payloads(Logger::INFO, false))
-    assert_equal(false, @stub_service.should_log_payloads(Logger::WARN, true))
-    assert_equal(false, @stub_service.should_log_payloads(Logger::WARN, false))
-
-    assert_equal(true, @stub_service.should_log_summary(Logger::INFO, true))
-    assert_equal(true, @stub_service.should_log_summary(Logger::INFO, false))
-    assert_equal(true, @stub_service.should_log_summary(Logger::WARN, true))
-    assert_equal(false, @stub_service.should_log_summary(Logger::WARN, false))
-    assert_equal(false, @stub_service.should_log_summary(Logger::ERROR, true))
-    assert_equal(false, @stub_service.should_log_summary(Logger::ERROR, false))
-  end
-end