google-ads-common 0.14.1 → 1.0.0

data/test/test_config.rb

@@ -1,96 +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 'ads_common/config'
-
-class TestConfig < Test::Unit::TestCase
-  DEFAULT_CONFIG_HASH = {
-      :service => {:use_ruby_names => false,
-                   :environment => 'sandbox'},
-      :authentication => {:method => 'ClientLogin',
-                          :email => 'root@example.com'}
-  }
-
-  DEFAULT_CONFIG_FILENAME = 'test/test_config.yml'
-
-  # Test initializer with no arguments.
-  def test_initialize_nil
-    assert_nothing_raised do
-      config = AdsCommon::Config.new
-      assert_nil(config.read('service.use_ruby_names'))
-    end
-  end
-
-  # Test initializer with hash argument.
-  def test_initialize_hash
-    config = AdsCommon::Config.new(DEFAULT_CONFIG_HASH)
-    assert_equal(false, config.read('service.use_ruby_names'))
-    assert_equal('sandbox', config.read('service.environment'))
-    assert_equal('ClientLogin', config.read('authentication.method'))
-    assert_equal('root@example.com', config.read('authentication.email'))
-    assert_nil(config.read('unexisting.entry'))
-  end
-
-  # Test initializer with filename argument.
-  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'))
-    assert_equal('ClientLogin', config.read('authentication.method'))
-    assert_equal('root@example.com', config.read('authentication.email'))
-    assert_nil(config.read('unexisting.entry'))
-  end
-
-  # Test initializer with an incorrect existing file.
-  def test_initialize_filename_incorrect
-    assert_raises (AdsCommon::Errors::Error) do
-      AdsCommon::Config.new('/dev/null')
-    end
-  end
-
-  # Test default result.
-  def test_read_default_result
-    config = AdsCommon::Config.new(DEFAULT_CONFIG_HASH)
-    assert_nil(config.read('unexisting.entry'))
-    assert_equal('default', config.read('unexisting.entry', 'default'))
-    assert_equal('sandbox', config.read('service.environment', 'production'))
-  end
-
-  # Test setter.
-  def test_set
-    config = AdsCommon::Config.new(DEFAULT_CONFIG_HASH)
-    assert_equal('sandbox', config.read('service.environment'))
-    assert_nil(config.read('unexisting.entry'))
-    config.set('unexisting.entry', 'foobar')
-    assert_equal('sandbox', config.read('service.environment'))
-    assert_equal('foobar', config.read('unexisting.entry'))
-  end
-
-  # Test subhash.
-  def test_get_hash
-    config = AdsCommon::Config.new(DEFAULT_CONFIG_HASH)
-    result = config.read('service')
-    assert_instance_of(Hash, result)
-    assert_equal('sandbox', result[:environment])
-    assert_equal(false, result[:use_ruby_names])
-  end
-end

data/test/test_config.yml

@@ -1,11 +0,0 @@
----
-# This is a test configuration file for Ads Common library.
-:authentication:
-  :method: ClientLogin
-  :application_name: ruby_test_suit
-  :password: mySecretPassword
-  :email: root@example.com
-  :network_code: 1234567
-:service:
-  :environment: sandbox
-  :use_ruby_names: false

data/test/test_credential_handler.rb

@@ -1,125 +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 credential handler methods.
-
-require 'logger'
-require 'minitest/mock'
-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
-
-  def test_generate_user_agent_simple()
-    result1 = @handler.generate_user_agent()
-    assert_kind_of(String, result1)
-  end
-
-  def test_generate_user_agent_chained()
-    test_str = 'Tester/0.2.0'
-    result1 = @handler.generate_user_agent([test_str])
-    assert_kind_of(String, result1)
-    assert_match(/#{Regexp.escape(test_str)}/, result1)
-  end
-
-  def test_generate_user_agent_include_simple()
-    test_str = 'Tester'
-    @handler.include_in_user_agent(test_str)
-    result1 = @handler.generate_user_agent()
-    assert_kind_of(String, result1)
-    assert_match(/#{Regexp.escape(test_str)}/, result1)
-    result2 = @handler.generate_user_agent()
-    assert_kind_of(String, result2)
-    assert_no_match(/#{Regexp.escape(test_str)}/, result2)
-  end
-
-  def test_generate_user_agent_include_version()
-    test_str = 'Tester/0.2.0'
-    argument1 = 'Tester'
-    argument2 = '0.2.0'
-    @handler.include_in_user_agent(argument1, argument2)
-    result1 = @handler.generate_user_agent()
-    assert_kind_of(String, result1)
-    assert_match(/#{Regexp.escape(test_str)}/, result1)
-    result2 = @handler.generate_user_agent()
-    assert_kind_of(String, result2)
-    assert_no_match(/#{Regexp.escape(test_str)}/, result2)
-  end
-
-  def test_auth_handler_callback_once()
-    mock = Minitest::Mock.new()
-    mock.expect(:property_changed,  nil, [:foo, 'bar'])
-    @handler.set_auth_handler(mock)
-    @handler.set_credential(:foo, 'bar')
-    assert(mock.verify)
-  end
-
-  def test_auth_handler_callback_compare()
-    credentials = @handler.credentials
-
-    credentials[:foo] = 'bar'
-    credentials[:baz] = 42
-    mock1 = Minitest::Mock.new()
-    mock1.expect(:property_changed, nil, [:baz, 42])
-    @handler.set_auth_handler(mock1)
-    @handler.credentials = credentials
-    assert(mock1.verify)
-
-    credentials.delete(:baz)
-    mock2 = Minitest::Mock.new()
-    mock2.expect(:property_changed, nil, [:baz, nil])
-    @handler.set_auth_handler(mock2)
-    @handler.credentials = credentials
-    assert(mock2.verify)
-
-    credentials[:foo] = nil
-    mock3 = Minitest::Mock.new()
-    mock3.expect(:property_changed, nil, [:foo, nil])
-    mock3.expect(:property_changed, nil, [:baz, nil])
-    @handler.set_auth_handler(mock3)
-    @handler.credentials = credentials
-    assert(mock3.verify)
-  end
-end

data/test/test_env.rb

@@ -1,43 +0,0 @@
-#!/usr/bin/env ruby
-# Encoding: utf-8
-#
-# Copyright:: Copyright 2016, 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 environment is correct.
-
-require 'openssl'
-require 'test/unit'
-
-class TestEnv < Test::Unit::TestCase
-
-  # Output ruby interpreter version to the tests log.
-  def test_ruby_version
-    puts "\nRunning tests with %s-%s-%s.\n" %
-        [RUBY_ENGINE, RUBY_VERSION, RUBY_PATCHLEVEL]
-  end
-
-  # Output SSL version to the tests log. There is a known issue with this
-  # required property not defined in some JRuby implementations.
-  def test_openssl_version
-    puts "\nUsing OpenSSL %s with %d methods.\n" %
-        [OpenSSL::OPENSSL_VERSION, OpenSSL::SSL::SSLContext::METHODS.count]
-  end
-
-  # Output rake version to the tests log.
-  def test_rake_version
-    puts "\nRunning with rake %s.\n" % Rake::VERSION if defined?(Rake)
-  end
-end

data/test/test_oauth2_handler.rb

@@ -1,84 +0,0 @@
-#!/usr/bin/env ruby
-# Encoding: utf-8
-#
-# Copyright:: Copyright 2015, 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 OAuth2 authentication.
-
-require 'time'
-
-require 'ads_common/auth/oauth2_handler'
-require 'ads_common/config'
-require 'webmock/test_unit'
-
-module AdsCommon
-  module Auth
-    class OAuth2Handler
-      attr_reader :scopes
-
-      def client()
-        @client
-      end
-
-      # Overrides to ensure @client stores issued_at as a string, to test
-      # converting it back.
-      def setup_client()
-        @client = Signet::OAuth2::Client.new({
-          :authorization_uri => 'https://accounts.google.com/o/oauth2/auth',
-          :token_credential_uri => 'https://accounts.google.com/o/oauth2/token',
-          :client_id => 'client_id123',
-          :client_secret => 'client_secret123',
-          :scope => 'https://www.googleapis.com/auth/adwords'
-        })
-      end
-    end
-  end
-end
-
-class TestOAuth < Test::Unit::TestCase
-  def setup()
-    stub_request(:post, 'https://accounts.google.com/o/oauth2/auth').to_return(
-        :status => 200,
-        :body => '{"access_token":"access_token123",' +
-            '"token_type":"Bearer","expires_in":"3600"}\n',
-        :headers => {}
-    )
-  end
-
-  def test_string_issued_at()
-    handler = AdsCommon::Auth::OAuth2Handler.new(AdsCommon::Config.new(), nil)
-
-    # Modify @client in the handler to get around a full setup.
-    handler.setup_client()
-    assert_not_nil(handler.client)
-    handler.client.issued_at = Time.now.to_s
-    assert_equal(Time, handler.client.issued_at.class)
-
-    # Make sure that we are still able to refresh the token.
-    assert_nothing_raised do
-      handler.refresh_token!();
-    end
-  end
-
-  def test_additional_scopes()
-    config = AdsCommon::Config.new()
-    config.set('authentication.oauth2_extra_scopes', ['extra-scope'])
-    handler = AdsCommon::Auth::OAuth2Handler.new(config, 'base-scope')
-    scopes = handler.scopes
-    assert(scopes.include?('base-scope'), 'Missing base scope.')
-    assert(scopes.include?('extra-scope'), 'Missing extra scope.')
-  end
-end

data/test/test_oauth2_service_account_handler.rb

@@ -1,61 +0,0 @@
-#!/usr/bin/env ruby
-# Encoding: utf-8
-#
-# Copyright:: Copyright 2016, 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 OAuth2 service account authentication.
-
-require 'tempfile'
-
-require 'ads_common/auth/oauth2_service_account_handler'
-require 'ads_common/config'
-
-module AdsCommon
-  module Auth
-    class OAuth2ServiceAccountHandler
-      public :validate_credentials
-    end
-  end
-end
-
-class TestOAuthServiceAccount < Test::Unit::TestCase
-  def test_file_extension_check()
-    assert_nothing_raised do
-      validate_credentials(['test', '.json'])
-    end
-    assert_raise(AdsCommon::Errors::AuthError) do
-      validate_credentials(['test', '.p12'])
-    end
-    assert_raises(AdsCommon::Errors::AuthError) do
-      validate_credentials(['test', '.other'])
-    end
-  end
-
-  def validate_credentials(filename)
-    file = Tempfile.new(filename)
-    credentials = {
-      :method => 'OAUTH2_SERVICE_ACCOUNT',
-      :oauth2_keyfile => file.path,
-      :oauth2_issuer => 'issuer',
-      :oauth2_secret => 'secret'
-    }
-    handler = AdsCommon::Auth::OAuth2ServiceAccountHandler.new(
-        AdsCommon::Config.new(), 'https://www.googleapis.com/auth/adwords')
-    handler.validate_credentials(credentials)
-    file.close
-    file.unlink
-  end
-end

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