active_utils 1.0.0

data/lib/active_utils/common/posts_data.rb

@@ -0,0 +1,63 @@
+module ActiveMerchant #:nodoc:
+  module PostsData  #:nodoc:
+
+    def self.included(base)
+      base.superclass_delegating_accessor :ssl_strict
+      base.ssl_strict = true
+
+      base.class_attribute :retry_safe
+      base.retry_safe = false
+
+      base.superclass_delegating_accessor :open_timeout
+      base.open_timeout = 60
+
+      base.superclass_delegating_accessor :read_timeout
+      base.read_timeout = 60
+
+      base.superclass_delegating_accessor :logger
+      base.superclass_delegating_accessor :wiredump_device
+    end
+
+    def ssl_get(endpoint, headers={})
+      ssl_request(:get, endpoint, nil, headers)
+    end
+
+    def ssl_post(endpoint, data, headers = {})
+      ssl_request(:post, endpoint, data, headers)
+    end
+
+    def ssl_request(method, endpoint, data, headers)
+      handle_response(raw_ssl_request(method, endpoint, data, headers))
+    end
+
+    def raw_ssl_request(method, endpoint, data, headers = {})
+      connection = Connection.new(endpoint)
+      connection.open_timeout = open_timeout
+      connection.read_timeout = read_timeout
+      connection.retry_safe   = retry_safe
+      connection.verify_peer  = ssl_strict
+      connection.logger       = logger
+      connection.tag          = self.class.name
+      connection.wiredump_device = wiredump_device
+
+      connection.pem          = @options[:pem] if @options
+      connection.pem_password = @options[:pem_password] if @options
+
+      connection.ignore_http_status = @options[:ignore_http_status] if @options
+
+      connection.request(method, data, headers)
+    end
+
+    private
+
+    def handle_response(response)
+      case response.code.to_i
+      when 200...300
+        response.body
+      else
+        raise ResponseError.new(response)
+      end
+    end
+
+  end
+end

data/lib/active_utils/common/requires_parameters.rb

@@ -0,0 +1,16 @@
+module ActiveMerchant #:nodoc:
+  module RequiresParameters #:nodoc:
+    def requires!(hash, *params)
+      params.each do |param|
+        if param.is_a?(Array)
+          raise ArgumentError.new("Missing required parameter: #{param.first}") unless hash.has_key?(param.first)
+
+          valid_options = param[1..-1]
+          raise ArgumentError.new("Parameter: #{param.first} must be one of #{valid_options.to_sentence(:words_connector => 'or')}") unless valid_options.include?(hash[param.first])
+        else
+          raise ArgumentError.new("Missing required parameter: #{param}") unless hash.has_key?(param)
+        end
+      end
+    end
+  end
+end

data/lib/active_utils/common/utils.rb

@@ -0,0 +1,22 @@
+require 'digest/md5'
+
+module ActiveMerchant #:nodoc:
+  module Utils #:nodoc:
+    def generate_unique_id
+      md5 = Digest::MD5.new
+      now = Time.now
+      md5 << now.to_s
+      md5 << String(now.usec)
+      md5 << String(rand(0))
+      md5 << String($$)
+      md5 << self.class.name
+      md5.hexdigest
+    end
+
+    module_function :generate_unique_id
+
+    def deprecated(message)
+      warn(Kernel.caller[1] + message)
+    end
+  end
+end

data/lib/active_utils/common/validateable.rb

@@ -0,0 +1,81 @@
+module ActiveMerchant #:nodoc:
+  module Validateable #:nodoc:
+    def valid?
+      errors.clear
+
+      before_validate if respond_to?(:before_validate, true)
+      validate if respond_to?(:validate, true)
+
+      errors.empty?
+    end
+
+    def initialize(attributes = {})
+      self.attributes = attributes
+    end
+
+    def errors
+      @errors ||= Errors.new(self)
+    end
+
+    private
+
+    def attributes=(attributes)
+      unless attributes.nil?
+        for key, value in attributes
+          send("#{key}=", value )
+        end
+      end
+    end
+
+    # This hash keeps the errors of the object
+    class Errors < HashWithIndifferentAccess
+
+      def initialize(base)
+        super() { |h, k|  h[k] = [] ; h[k] }
+        @base = base
+      end
+
+      def count
+        size
+      end
+
+      def empty?
+        all? { |k, v| v && v.empty? }
+      end
+
+      # returns a specific fields error message.
+      # if more than one error is available we will only return the first. If no error is available
+      # we return an empty string
+      def on(field)
+        self[field].to_a.first
+      end
+
+      def add(field, error)
+        self[field] << error
+      end
+
+      def add_to_base(error)
+        add(:base, error)
+      end
+
+      def each_full
+        full_messages.each { |msg| yield msg }
+      end
+
+      def full_messages
+        result = []
+
+        self.each do |key, messages|
+          next if messages.blank?
+          if key == 'base'
+            result << "#{messages.first}"
+          else
+            result << "#{key.to_s.humanize} #{messages.first}"
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/active_utils/version.rb

@@ -0,0 +1,3 @@
+module ActiveUtils
+  VERSION = "1.0.0"
+end

data/lib/active_utils.rb

@@ -0,0 +1,19 @@
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/hash/conversions'
+require 'active_support/core_ext/class/attribute'
+
+module ActiveMerchant
+  autoload :Connection,                'active_utils/common/connection'
+  autoload :Country,                   'active_utils/common/country'
+  autoload :CountryCode,               'active_utils/common/country'
+  autoload :ActiveMerchantError,       'active_utils/common/error'
+  autoload :ConnectionError,           'active_utils/common/error'
+  autoload :RetriableConnectionError,  'active_utils/common/error'
+  autoload :ResponseError,             'active_utils/common/error'
+  autoload :ClientCertificateError,    'active_utils/common/error'
+  autoload :PostData,                  'active_utils/common/post_data'
+  autoload :PostsData,                 'active_utils/common/posts_data'
+  autoload :RequiresParameters,        'active_utils/common/requires_parameters'
+  autoload :Utils,                     'active_utils/common/utils'
+  autoload :Validateable,              'active_utils/common/validateable'
+end

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+
+require 'test/unit'
+require 'active_utils'
+require 'mocha'
+
+include ActiveMerchant

data/test/unit/connection_test.rb

@@ -0,0 +1,131 @@
+require 'test_helper'
+
+class ConnectionTest < Test::Unit::TestCase
+
+  def setup
+    @ok = stub(:code => 200, :message => 'OK', :body => 'success')
+
+    @endpoint   = 'https://example.com/tx.php'
+    @connection = ActiveMerchant::Connection.new(@endpoint)
+  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
+    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_get_raises_argument_error_if_passed_data
+    assert_raise(ArgumentError) do
+      @connection.request(:get, 'data', {})
+    end
+  end
+
+  def test_request_raises_when_request_method_not_supported
+    assert_raise(ArgumentError) do
+      @connection.request(:delete, nil, {})
+    end
+  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_unrecoverable_exception
+    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
+    Net::HTTP.any_instance.expects(:post).times(2).raises(Errno::ECONNREFUSED).then.returns(@ok)
+
+    assert_nothing_raised do
+      @connection.request(:post, '')
+    end
+  end
+
+  def test_failure_limit_reached
+    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
+
+    assert_nothing_raised do
+      @connection.request(:post, '')
+    end
+  end
+
+  def test_mixture_of_failures_with_retry_safe_enabled
+    Net::HTTP.any_instance.expects(:post).times(3).raises(Errno::ECONNRESET).
+                                                   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
+    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 < Test::Unit::TestCase
+  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_raise(CountryCodeFormatError){ CountryCode.new('Canada') }
+  end
+end

data/test/unit/country_test.rb

@@ -0,0 +1,68 @@
+require 'test_helper'
+
+class CountryTest < Test::Unit::TestCase
+  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_raise(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_raise(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/post_data_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+class MyPost < ActiveMerchant::PostData
+  self.required_fields = [ :ccnumber, :ccexp, :firstname, :lastname, :username, :password, :order_id, :key, :time ]
+end
+
+class PostDataTest < Test::Unit::TestCase
+  def teardown
+    ActiveMerchant::PostData.required_fields = []
+  end
+
+  def test_element_assignment
+    name = 'Cody Fauser'
+    post = ActiveMerchant::PostData.new
+
+    post[:name] = name
+    assert_equal name, post[:name]
+  end
+
+  def test_ignore_blank_fields
+    post = ActiveMerchant::PostData.new
+    assert_equal 0, post.keys.size
+
+    post[:name] = ''
+    assert_equal 0, post.keys.size
+
+    post[:name] = nil
+    assert_equal 0, post.keys.size
+  end
+
+  def test_dont_ignore_required_blank_fields
+    ActiveMerchant::PostData.required_fields = [ :name ]
+    post = ActiveMerchant::PostData.new
+
+    assert_equal 0, post.keys.size
+
+    post[:name] = ''
+    assert_equal 1, post.keys.size
+    assert_equal '', post[:name]
+
+    post[:name] = nil
+    assert_equal 1, post.keys.size
+    assert_nil post[:name]
+  end
+
+  def test_subclass
+    post = MyPost.new
+    assert_equal [ :ccnumber, :ccexp, :firstname, :lastname, :username, :password, :order_id, :key, :time ], post.required_fields
+  end
+end

data/test/unit/utils_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class UtilsTest < Test::Unit::TestCase
+  def test_unique_id_should_be_32_chars_and_alphanumeric
+    assert_match /^\w{32}$/, ActiveMerchant::Utils.generate_unique_id
+  end
+end

data/test/unit/validateable_test.rb

@@ -0,0 +1,59 @@
+require 'test_helper'
+
+class Dood
+  include ActiveMerchant::Validateable
+
+  attr_accessor :name, :email, :country
+
+  def validate
+    errors.add "name", "cannot be empty" if name.blank?
+    errors.add "email", "cannot be empty" if email.blank?
+    errors.add_to_base "The country cannot be blank" if country.blank?
+  end
+
+end
+
+class ValidateableTest < Test::Unit::TestCase
+
+  def setup
+    @dood = Dood.new
+  end
+
+  def test_validation
+    assert ! @dood.valid?
+    assert ! @dood.errors.empty?
+  end
+
+  def test_assigns
+    @dood = Dood.new(:name => "tobi", :email => "tobi@neech.de", :country => 'DE')
+
+    assert_equal "tobi", @dood.name
+    assert_equal "tobi@neech.de", @dood.email
+    assert @dood.valid?
+  end
+
+  def test_multiple_calls
+    @dood.name = "tobi"
+    assert !@dood.valid?
+
+    @dood.email = "tobi@neech.de"
+    assert !@dood.valid?
+
+    @dood.country = 'DE'
+    assert @dood.valid?
+  end
+
+  def test_messages
+    @dood.valid?
+    assert_equal "cannot be empty", @dood.errors.on('name')
+    assert_equal "cannot be empty", @dood.errors.on('email')
+    assert_equal nil, @dood.errors.on('doesnt_exist')
+
+  end
+
+  def test_full_messages
+    @dood.valid?
+    assert_equal ["Email cannot be empty", "Name cannot be empty", "The country cannot be blank"], @dood.errors.full_messages.sort
+  end
+
+end