google-ads-common 0.14.1 → 1.0.0

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,130 +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>"
-    test4 = "<xml><httpAuthorizationHeader>Authorization: Bearer " +
-        "1/abcdEFGH1234</httpAuthorizationHeader></xml>"
-    expected4 = "<xml><httpAuthorizationHeader>REDACTED" +
-        "</httpAuthorizationHeader></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))
-    assert_equal(expected4, @stub_service.sanitize_request(test4))
-  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

data/test/test_utils.rb

@@ -1,111 +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 utils.
-
-require 'tempfile'
-require 'test/unit'
-require 'yaml'
-
-require 'ads_common/utils'
-
-
-class TestUtils < Test::Unit::TestCase
-
-  def test_has_lower_camelcase()
-    assert('str'.respond_to?(:lower_camelcase))
-  end
-
-  def test_lower_camelcase_works()
-    data = [
-        {:input => 'lowerCamelCase', :output => 'lowerCamelCase'},
-        {:input => 'UpperCamelCase', :output => 'upperCamelCase'},
-        {:input => 'snake_case', :output => 'snakeCase'},
-        {:input => 'single1', :output => 'single1'},
-        {:input => 'Single2', :output => 'single2'},
-        {:input => '', :output => ''},
-        {:input => 'strange_MixOf_all', :output => 'strangeMixOfAll'},
-        {:input => 'number_5', :output => 'number5'},
-    ]
-    data.each do |arg|
-      result = arg[:input].lower_camelcase()
-      assert_equal(arg[:output], result)
-    end
-  end
-
-  def test_lower_camelcase_non_destructive()
-    str = 'str_snake'
-    result = str.lower_camelcase()
-    assert_not_same(str, result)
-    assert_equal('str_snake', str)
-  end
-
-  def test_hash_keys_to_str()
-    data = {:a => 'aa', :b5 => 43, 'xyz' => :abc}
-    result = AdsCommon::Utils.hash_keys_to_str(data)
-    assert_equal('aa', result['a'])
-    assert_equal(43, result['b5'])
-    assert_equal(:abc, result['xyz'])
-    assert_equal(3, result.size)
-    assert_not_same(result, data)
-  end
-
-  def test_hash_keys_to_sym()
-    data = {:a => 'aa', :b5 => 43, 'xyz' => :abc, 'f5' => :xyz}
-    result = AdsCommon::Utils.hash_keys_to_sym(data)
-    assert_equal('aa', result[:a])
-    assert_equal(43, result[:b5])
-    assert_equal(:abc, result[:xyz])
-    assert_equal(:xyz, result[:f5])
-    assert_equal(4, result.size)
-    assert_not_same(result, data)
-  end
-
-  def test_save_oauth2_token()
-    config_stub = {:authentication => {:method => 'OAuth2'}}
-    token = {:token_key => 'token_value', :token_number => 42}
-    expected_result = {
-      :authentication => {
-        :method => 'OAuth2',
-        :oauth2_token => token.dup
-      }
-    }
-    tmp_file = Tempfile.new('ruby-tests')
-    tmp_file.write(YAML::dump(config_stub))
-    filename = tmp_file.path()
-    tmp_file.close()
-    AdsCommon::Utils.save_oauth2_token(filename, token)
-
-    assert(File.exist?(filename))
-    result = YAML::load_file(filename)
-    assert_equal(expected_result, result)
-    assert(File.exist?(filename + '.backup'))
-    File.unlink(filename + '.backup')
-  end
-
-  def test_find_new_name()
-    tmp_file = Tempfile.new('ruby-tests')
-    name1 = AdsCommon::Utils.find_new_name(tmp_file.path())
-    assert_equal(tmp_file.path() + '.backup', name1)
-    File.open(name1, 'w') do |file1|
-      name2 = AdsCommon::Utils.find_new_name(tmp_file.path())
-      assert_equal(tmp_file.path() + '.backup1', name2)
-    end
-    File.unlink(name1)
-  end
-end