tanga_active_utils 2.2.3

data/shipit.rubygems.yml

@@ -0,0 +1 @@
+# using the default shipit config

data/tanga_active_utils.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "active_utils/version"
+
+Gem::Specification.new do |s|
+  s.name        = "tanga_active_utils"
+  s.version     = ActiveUtils::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Shopify"]
+  s.email       = ["developers@jadedpixel.com"]
+  s.homepage    = "http://github.com/shopify/active_utils"
+  s.summary     = %q{Common utils used by active_merchant, active_fulfillment, and active_shipping}
+  s.license     = 'MIT'
+
+  s.rubyforge_project = "active_utils"
+
+  s.add_dependency('activesupport', '>= 2.3.11')
+  s.add_dependency('i18n')
+
+  s.add_development_dependency('rake')
+  s.add_development_dependency('mocha')
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/test/test_helper.rb

@@ -0,0 +1,8 @@
+require 'active_utils'
+
+require 'minitest/autorun'
+
+require 'mocha'
+require 'mocha/mini_test'
+
+include ActiveMerchant

data/test/unit/connection_test.rb

@@ -0,0 +1,177 @@
+require 'test_helper'
+
+class ConnectionTest < Minitest::Test
+
+  def setup
+    @ok = stub(:code => 200, :message => 'OK', :body => 'success')
+
+    @endpoint   = 'https://example.com/tx.php'
+    @connection = ActiveMerchant::Connection.new(@endpoint)
+    @connection.logger = stub(:info => nil, :debug => nil, :error => nil)
+  end
+
+  def test_connection_endpoint_parses_string_to_uri
+    assert_equal URI.parse(@endpoint), @connection.endpoint
+  end
+
+  def test_connection_endpoint_accepts_uri
+    endpoint = URI.parse(@endpoint)
+    connection = ActiveMerchant::Connection.new(endpoint)
+    assert_equal endpoint, connection.endpoint
+  end
+
+  def test_connection_endpoint_raises_uri_error
+    assert_raises URI::InvalidURIError do
+      ActiveMerchant::Connection.new("not a URI")
+    end
+  end
+
+  def test_successful_get_request
+    @connection.logger.expects(:info).twice
+    Net::HTTP.any_instance.expects(:get).with('/tx.php', {}).returns(@ok)
+    response = @connection.request(:get, nil, {})
+    assert_equal 'success', response.body
+  end
+
+  def test_successful_post_request
+    Net::HTTP.any_instance.expects(:post).with('/tx.php', 'data', ActiveMerchant::Connection::RUBY_184_POST_HEADERS).returns(@ok)
+    response = @connection.request(:post, 'data', {})
+    assert_equal 'success', response.body
+  end
+
+  def test_successful_put_request
+    Net::HTTP.any_instance.expects(:put).with('/tx.php', 'data', {}).returns(@ok)
+    response = @connection.request(:put, 'data', {})
+    assert_equal 'success', response.body
+  end
+
+  def test_successful_delete_request
+    Net::HTTP.any_instance.expects(:delete).with('/tx.php', {}).returns(@ok)
+    response = @connection.request(:delete, nil, {})
+    assert_equal 'success', response.body
+  end
+
+  def test_get_raises_argument_error_if_passed_data
+    assert_raises(ArgumentError) do
+      @connection.request(:get, 'data', {})
+    end
+  end
+
+  def test_request_raises_when_request_method_not_supported
+    assert_raises(ArgumentError) do
+      @connection.request(:head, nil, {})
+    end
+  end
+
+  def test_override_max_retries
+    refute_equal 1, @connection.max_retries
+    @connection.max_retries = 1
+    assert_equal 1, @connection.max_retries
+  end
+
+  def test_override_ssl_version
+    refute_equal :SSLv3, @connection.ssl_version
+    @connection.ssl_version = :SSLv3
+    assert_equal :SSLv3, @connection.ssl_version
+  end
+
+  def test_default_read_timeout
+    assert_equal ActiveMerchant::Connection::READ_TIMEOUT, @connection.read_timeout
+  end
+
+  def test_override_read_timeout
+    @connection.read_timeout = 20
+    assert_equal 20, @connection.read_timeout
+  end
+
+  def test_default_open_timeout
+    @connection.open_timeout = 20
+    assert_equal 20, @connection.open_timeout
+  end
+
+  def test_default_verify_peer
+    assert_equal ActiveMerchant::Connection::VERIFY_PEER, @connection.verify_peer
+  end
+
+  def test_override_verify_peer
+    @connection.verify_peer = false
+    assert_equal false, @connection.verify_peer
+  end
+
+  def test_default_ca_file
+    assert_equal ActiveMerchant::Connection::CA_FILE, @connection.ca_file
+    assert_equal ActiveMerchant::Connection::CA_FILE, @connection.send(:http).ca_file
+  end
+
+  def test_override_ca_file
+    @connection.ca_file = "/bogus"
+    assert_equal "/bogus", @connection.ca_file
+    assert_equal "/bogus", @connection.send(:http).ca_file
+  end
+
+  def test_default_ca_path
+    assert_equal ActiveMerchant::Connection::CA_PATH, @connection.ca_path
+    assert_equal ActiveMerchant::Connection::CA_PATH, @connection.send(:http).ca_path
+  end
+
+  def test_override_ca_path
+    @connection.ca_path = "/bogus"
+    assert_equal "/bogus", @connection.ca_path
+    assert_equal "/bogus", @connection.send(:http).ca_path
+  end
+
+  def test_unrecoverable_exception
+    @connection.logger.expects(:info).once
+    Net::HTTP.any_instance.expects(:post).raises(EOFError)
+
+    assert_raises(ActiveMerchant::ConnectionError) do
+      @connection.request(:post, '')
+    end
+  end
+
+  def test_failure_then_success_with_recoverable_exception
+    @connection.logger.expects(:info).never
+    Net::HTTP.any_instance.expects(:post).times(2).raises(Errno::ECONNREFUSED).then.returns(@ok)
+
+    @connection.request(:post, '')
+  end
+
+  def test_failure_limit_reached
+    @connection.logger.expects(:info).once
+    Net::HTTP.any_instance.expects(:post).times(ActiveMerchant::Connection::MAX_RETRIES).raises(Errno::ECONNREFUSED)
+
+    assert_raises(ActiveMerchant::ConnectionError) do
+      @connection.request(:post, '')
+    end
+  end
+
+  def test_failure_then_success_with_retry_safe_enabled
+    Net::HTTP.any_instance.expects(:post).times(2).raises(EOFError).then.returns(@ok)
+
+    @connection.retry_safe = true
+
+    @connection.request(:post, '')
+  end
+
+  def test_mixture_of_failures_with_retry_safe_enabled
+    Net::HTTP.any_instance.expects(:post).times(3).raises(Errno::EHOSTUNREACH).
+                                                   raises(Errno::ECONNREFUSED).
+                                                   raises(EOFError)
+
+    @connection.retry_safe = true
+
+    assert_raises(ActiveMerchant::ConnectionError) do
+      @connection.request(:post, '')
+    end
+  end
+
+  def test_failure_with_ssl_certificate
+    @connection.logger.expects(:error).once
+    Net::HTTP.any_instance.expects(:post).raises(OpenSSL::X509::CertificateError)
+
+    assert_raises(ActiveMerchant::ClientCertificateError) do
+      @connection.request(:post, '')
+    end
+  end
+
+end

data/test/unit/country_code_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class CountryCodeTest < Minitest::Test
+  def test_alpha2_country_code
+    code = CountryCode.new('CA')
+    assert_equal 'CA', code.value
+    assert_equal 'CA', code.to_s
+    assert_equal :alpha2, code.format
+  end
+
+  def test_lower_alpha2_country_code
+    code = CountryCode.new('ca')
+    assert_equal 'CA', code.value
+    assert_equal 'CA', code.to_s
+    assert_equal :alpha2, code.format
+  end
+
+  def test_alpha2_country_code
+    code = CountryCode.new('CAN')
+    assert_equal :alpha3, code.format
+  end
+
+  def test_numeric_code
+    code = CountryCode.new('004')
+    assert_equal :numeric, code.format
+  end
+
+  def test_invalid_code_format
+    assert_raises(CountryCodeFormatError){ CountryCode.new('Canada') }
+  end
+end

data/test/unit/country_test.rb

@@ -0,0 +1,68 @@
+require 'test_helper'
+
+class CountryTest < Minitest::Test
+  def test_country_from_hash
+    country = Country.new(:name => 'Canada', :alpha2 => 'CA', :alpha3 => 'CAN', :numeric => '124')
+    assert_equal 'CA', country.code(:alpha2).value
+    assert_equal 'CAN', country.code(:alpha3).value
+    assert_equal '124', country.code(:numeric).value
+    assert_equal 'Canada', country.to_s
+  end
+
+  def test_country_for_alpha2_code
+    country = Country.find('CA')
+    assert_equal 'CA', country.code(:alpha2).value
+    assert_equal 'CAN', country.code(:alpha3).value
+    assert_equal '124', country.code(:numeric).value
+    assert_equal 'Canada', country.to_s
+  end
+
+  def test_country_for_alpha3_code
+    country = Country.find('CAN')
+    assert_equal 'Canada', country.to_s
+  end
+
+  def test_country_for_numeric_code
+    country = Country.find('124')
+    assert_equal 'Canada', country.to_s
+  end
+
+  def test_find_country_by_name
+    country = Country.find('Canada')
+    assert_equal 'Canada', country.to_s
+  end
+
+  def test_find_unknown_country_name
+    assert_raises(InvalidCountryCodeError) do
+      Country.find('Asskickistan')
+    end
+  end
+
+  def test_find_australia
+    country = Country.find('AU')
+    assert_equal 'AU', country.code(:alpha2).value
+
+    country = Country.find('Australia')
+    assert_equal 'AU', country.code(:alpha2).value
+  end
+
+  def test_find_united_kingdom
+    country = Country.find('GB')
+    assert_equal 'GB', country.code(:alpha2).value
+
+    country = Country.find('United Kingdom')
+    assert_equal 'GB', country.code(:alpha2).value
+  end
+
+  def test_raise_on_nil_name
+    assert_raises(InvalidCountryCodeError) do
+      Country.find(nil)
+    end
+  end
+
+  def test_country_names_are_alphabetized
+    country_names = Country::COUNTRIES.map { | each | each[:name] }
+    assert_equal(country_names.sort, country_names)
+  end
+
+end

data/test/unit/currency_code_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+class CurrencyCodeTest < Minitest::Test
+  def test_is_iso_should_return_true_for_iso_currencies
+    assert CurrencyCode.is_iso?('CAD')
+    assert CurrencyCode.is_iso?('USD')
+    assert CurrencyCode.is_iso?('TWD')
+  end
+
+  def test_is_iso_should_return_false_for_non_iso_currencies
+    assert !CurrencyCode.is_iso?('NTD')
+    assert !CurrencyCode.is_iso?('RMB')
+  end
+
+  def test_standardize_should_not_change_iso_currencies
+    assert_equal 'CAD', CurrencyCode.standardize('CAD')
+    assert_equal 'USD', CurrencyCode.standardize('usd')
+    assert_equal 'TWD', CurrencyCode.standardize('TWD')
+  end
+
+  def test_standardize_should_convert_known_non_iso_to_iso
+    assert_equal 'TWD', CurrencyCode.standardize('NTD')
+    assert_equal 'CNY', CurrencyCode.standardize('rmb')
+  end
+
+  def test_standardize_should_raise_for_unknwon_currencies
+    assert_raises CurrencyCode::InvalidCurrencyCodeError do
+      CurrencyCode.standardize('Not Real')
+    end
+  end
+
+  def test_nil_code_should_raise_InvalidCurrencyCodeError
+    assert_raises CurrencyCode::InvalidCurrencyCodeError do
+      CurrencyCode.standardize(nil)
+    end
+  end
+end

data/test/unit/network_connection_retries_test.rb

@@ -0,0 +1,141 @@
+require 'test_helper'
+require 'openssl'
+require 'net/http'
+
+class NetworkConnectionRetriesTest < Minitest::Test
+  class MyNewError < StandardError
+  end
+
+  include NetworkConnectionRetries
+
+  def setup
+    @logger = stubs(:logger)
+    @requester = stubs(:requester)
+    @ok = stub(:code => 200, :message => 'OK', :body => 'success')
+  end
+
+  def test_unrecoverable_exception
+    assert_raises(ActiveMerchant::ConnectionError) do
+      retry_exceptions do
+        raise EOFError
+      end
+    end
+  end
+
+  def test_invalid_response_error
+    assert_raises(ActiveMerchant::InvalidResponseError) do
+      retry_exceptions do
+        raise Zlib::BufError
+      end
+    end
+  end
+
+  def test_unrecoverable_exception_logged_if_logger_provided
+    @logger.expects(:info).once
+    assert_raises(ActiveMerchant::ConnectionError) do
+      retry_exceptions :logger => @logger do
+        raise EOFError
+      end
+    end
+  end
+
+  def test_failure_then_success_with_recoverable_exception
+    @requester.expects(:post).times(2).raises(Errno::ECONNREFUSED).then.returns(@ok)
+
+    retry_exceptions do
+      @requester.post
+    end
+  end
+
+  def test_failure_limit_reached
+    @requester.expects(:post).times(ActiveMerchant::NetworkConnectionRetries::DEFAULT_RETRIES).raises(Errno::ECONNREFUSED)
+
+    assert_raises(ActiveMerchant::ConnectionError) do
+      retry_exceptions do
+        @requester.post
+      end
+    end
+  end
+
+  def test_failure_limit_reached_logs_final_error
+    @logger.expects(:info).times(3)
+    @requester.expects(:post).times(ActiveMerchant::NetworkConnectionRetries::DEFAULT_RETRIES).raises(Errno::ECONNREFUSED)
+
+    assert_raises(ActiveMerchant::ConnectionError) do
+      retry_exceptions(:logger => @logger) do
+        @requester.post
+      end
+    end
+  end
+
+  def test_failure_then_success_with_retry_safe_enabled
+    @requester.expects(:post).times(2).raises(EOFError).then.returns(@ok)
+
+    retry_exceptions :retry_safe => true do
+      @requester.post
+    end
+  end
+
+  def test_failure_then_success_logs_success
+    @logger.expects(:info).with(regexp_matches(/dropped/))
+    @logger.expects(:info).with(regexp_matches(/success/))
+    @requester.expects(:post).times(2).raises(EOFError).then.returns(@ok)
+
+    retry_exceptions(:logger => @logger, :retry_safe => true) do
+      @requester.post
+    end
+  end
+
+  def test_mixture_of_failures_with_retry_safe_enabled
+    @requester.expects(:post).times(3).raises(Errno::EHOSTUNREACH).
+                                       raises(Errno::ECONNREFUSED).
+                                       raises(EOFError)
+
+    assert_raises(ActiveMerchant::ConnectionError) do
+      retry_exceptions :retry_safe => true do
+        @requester.post
+      end
+    end
+  end
+
+  def test_failure_with_ssl_certificate
+    @requester.expects(:post).raises(OpenSSL::X509::CertificateError)
+
+    assert_raises(ActiveMerchant::ClientCertificateError) do
+      retry_exceptions do
+        @requester.post
+      end
+    end
+  end
+
+  def test_failure_with_ssl_certificate_logs_error_if_logger_specified
+    @logger.expects(:error).once
+    @requester.expects(:post).raises(OpenSSL::X509::CertificateError)
+
+    assert_raises(ActiveMerchant::ClientCertificateError) do
+      retry_exceptions :logger => @logger do
+        @requester.post
+      end
+    end
+  end
+
+  def test_failure_with_additional_exceptions_specified
+    @requester.expects(:post).raises(MyNewError)
+
+    assert_raises(ActiveMerchant::ConnectionError) do
+      retry_exceptions :connection_exceptions => {MyNewError => "my message"} do
+        @requester.post
+      end
+    end
+  end
+
+  def test_failure_without_additional_exceptions_specified
+    @requester.expects(:post).raises(MyNewError)
+
+    assert_raises(MyNewError) do
+      retry_exceptions do
+        @requester.post
+      end
+    end
+  end
+end