am_credit_card 0.0.1

data/lib/active_merchant/billing/expiry_date.rb

@@ -0,0 +1,34 @@
+require 'date'
+
+module ActiveMerchant
+  module Billing
+    class CreditCard
+      class ExpiryDate #:nodoc:
+        attr_reader :month, :year
+        def initialize(month, year)
+          @month = month.to_i
+          @year = year.to_i
+        end
+        
+        def expired? #:nodoc:
+          Time.now.utc > expiration
+        end
+        
+        def expiration #:nodoc:
+          begin
+            Time.utc(year, month, month_days, 23, 59, 59)
+          rescue ArgumentError
+            Time.at(0).utc
+          end
+        end
+        
+        private
+        def month_days
+          mdays = [nil,31,28,31,30,31,30,31,31,30,31,30,31]
+          mdays[2] = 29 if Date.leap?(year)
+          mdays[month]
+        end
+      end
+    end
+  end
+end

data/lib/active_merchant/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/am_credit_card.rb

@@ -0,0 +1,32 @@
+#--
+# Copyright (c) 2005-2010 Tobias Luetke
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/object/conversions'
+require 'active_support/core_ext/object/blank'
+
+require 'active_merchant/validateable'
+require 'active_merchant/billing/base'
+require 'active_merchant/billing/credit_card_methods'
+require 'active_merchant/billing/credit_card'

data/lib/am_credit_card_version.rb

@@ -0,0 +1,3 @@
+module AmCreditCard
+  VERSION = "0.0.1"
+end

data/test/test_helper.rb

@@ -0,0 +1,174 @@
+#!/usr/bin/env ruby
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+begin
+  require 'rubygems'
+  require 'bundler'
+  Bundler.setup
+rescue LoadError => e
+  puts "Error loading bundler (#{e.message}): \"gem install bundler\" for bundler support."
+end
+
+require 'test/unit'
+require "am_credit_card"
+
+module ActiveMerchant
+  module Assertions
+    AssertionClass = RUBY_VERSION > '1.9' ? MiniTest::Assertion : Test::Unit::AssertionFailedError
+    
+    def assert_field(field, value)
+      clean_backtrace do 
+        assert_equal value, @helper.fields[field]
+      end
+    end
+    
+    # Allows the testing of you to check for negative assertions: 
+    # 
+    #   # Instead of
+    #   assert !something_that_is_false
+    # 
+    #   # Do this
+    #   assert_false something_that_should_be_false
+    # 
+    # An optional +msg+ parameter is available to help you debug.
+    def assert_false(boolean, message = nil)
+      message = build_message message, '<?> is not false or nil.', boolean
+    
+      clean_backtrace do
+        assert_block message do
+          not boolean
+        end
+      end
+    end
+    
+    # A handy little assertion to check for a successful response: 
+    # 
+    #   # Instead of
+    #   assert_success response
+    # 
+    #   # DRY that up with
+    #   assert_success response
+    # 
+    # A message will automatically show the inspection of the response 
+    # object if things go afoul.
+    def assert_success(response)
+      clean_backtrace do
+        assert response.success?, "Response failed: #{response.inspect}"
+      end
+    end
+    
+    # The negative of +assert_success+
+    def assert_failure(response)
+      clean_backtrace do
+        assert_false response.success?, "Response expected to fail: #{response.inspect}"
+      end
+    end
+    
+    def assert_valid(validateable)
+      clean_backtrace do
+        assert validateable.valid?, "Expected to be valid"
+      end
+    end
+    
+    def assert_not_valid(validateable)
+      clean_backtrace do
+        assert_false validateable.valid?, "Expected to not be valid"
+      end
+    end
+
+    def assert_deprecation_warning(message, target)
+      target.expects(:deprecated).with(message)
+      yield
+    end
+    
+    private
+    def clean_backtrace(&block)
+      yield    
+    rescue AssertionClass => e
+      path = File.expand_path(__FILE__)
+      raise AssertionClass, e.message, e.backtrace.reject { |line| File.expand_path(line) =~ /#{path}/ }
+    end
+  end
+  
+  module Fixtures
+    HOME_DIR = RUBY_PLATFORM =~ /mswin32/ ? ENV['HOMEPATH'] : ENV['HOME'] unless defined?(HOME_DIR)
+    LOCAL_CREDENTIALS = File.join(HOME_DIR.to_s, '.active_merchant/fixtures.yml') unless defined?(LOCAL_CREDENTIALS)
+    DEFAULT_CREDENTIALS = File.join(File.dirname(__FILE__), 'fixtures.yml') unless defined?(DEFAULT_CREDENTIALS)
+    
+    private
+    def credit_card(number = '4242424242424242', options = {})
+      defaults = {
+        :number => number,
+        :month => 9,
+        :year => Time.now.year + 1,
+        :first_name => 'Longbob',
+        :last_name => 'Longsen',
+        :verification_value => '123',
+        :type => 'visa'
+      }.update(options)
+
+      Billing::CreditCard.new(defaults)
+    end
+    
+    def check(options = {})
+      defaults = {
+        :name => 'Jim Smith',
+        :routing_number => '244183602', 
+        :account_number => '15378535', 
+        :account_holder_type => 'personal', 
+        :account_type => 'checking', 
+        :number => '1'
+      }.update(options)
+      
+      Billing::Check.new(defaults)
+    end
+    
+    def address(options = {})
+      { 
+        :name     => 'Jim Smith',
+        :address1 => '1234 My Street',
+        :address2 => 'Apt 1',
+        :company  => 'Widgets Inc',
+        :city     => 'Ottawa',
+        :state    => 'ON',
+        :zip      => 'K1C2N6',
+        :country  => 'CA',
+        :phone    => '(555)555-5555',
+        :fax      => '(555)555-6666'
+      }.update(options)
+    end
+    
+    def all_fixtures
+      @@fixtures ||= load_fixtures
+    end
+    
+    def fixtures(key)
+      data = all_fixtures[key] || raise(StandardError, "No fixture data was found for '#{key}'")
+      
+      data.dup
+    end
+        
+    def load_fixtures
+      file = File.exists?(LOCAL_CREDENTIALS) ? LOCAL_CREDENTIALS : DEFAULT_CREDENTIALS
+      yaml_data = YAML.load(File.read(file))
+      symbolize_keys(yaml_data)
+    
+      yaml_data
+    end
+    
+    def symbolize_keys(hash)
+      return unless hash.is_a?(Hash)
+      
+      hash.symbolize_keys!
+      hash.each{|k,v| symbolize_keys(v)}
+    end
+  end
+end
+
+ActiveMerchant::Billing::Base.mode = :test
+
+Test::Unit::TestCase.class_eval do
+  include ActiveMerchant::Billing
+  include ActiveMerchant::Assertions
+  include ActiveMerchant::Fixtures
+end

data/test/unit/credit_card_methods_test.rb

@@ -0,0 +1,195 @@
+require 'test_helper'
+
+class CreditCardMethodsTest < Test::Unit::TestCase
+  include ActiveMerchant::Billing::CreditCardMethods
+  
+  class CreditCard
+    include ActiveMerchant::Billing::CreditCardMethods 
+  end
+  
+  def maestro_card_numbers
+    %w[
+      5000000000000000 5099999999999999 5600000000000000
+      5899999999999999 6000000000000000 6999999999999999
+      6761999999999999 6763000000000000 5038999999999999
+    ]
+  end
+  
+  def non_maestro_card_numbers
+    %w[
+      4999999999999999 5100000000000000 5599999999999999 
+      5900000000000000 5999999999999999 7000000000000000
+    ]
+  end
+  
+  def test_should_be_able_to_identify_valid_expiry_months
+    assert_false valid_month?(-1)
+    assert_false valid_month?(13)
+    assert_false valid_month?(nil)
+    assert_false valid_month?('')
+    
+    1.upto(12) { |m| assert valid_month?(m) }
+  end
+
+  def test_should_be_able_to_identify_valid_expiry_years
+    assert_false valid_expiry_year?(-1)
+    assert_false valid_expiry_year?(Time.now.year + 21)
+    
+    0.upto(20) { |n| assert valid_expiry_year?(Time.now.year + n) }
+  end
+
+  def test_should_be_able_to_identify_valid_start_years
+    assert valid_start_year?(1988)
+    assert valid_start_year?(2007)
+    assert valid_start_year?(3000)
+    
+    assert_false valid_start_year?(1987)
+  end
+  
+  def test_valid_start_year_can_handle_strings
+    assert valid_start_year?("2009")
+  end
+  
+  def test_valid_month_can_handle_strings
+    assert valid_month?("1")
+  end
+  
+  def test_valid_expiry_year_can_handle_strings
+    year = Time.now.year + 1
+    assert valid_expiry_year?(year.to_s)
+  end
+  
+  def test_should_be_able_to_identify_valid_issue_numbers
+    assert valid_issue_number?(1)
+    assert valid_issue_number?(10)
+    assert valid_issue_number?('12')
+    assert valid_issue_number?(0)
+    
+    assert_false valid_issue_number?(-1)
+    assert_false valid_issue_number?(123)
+    assert_false valid_issue_number?('CAT')
+  end
+
+  def test_should_ensure_type_from_credit_card_class_is_not_frozen
+    assert_false CreditCard.type?('4242424242424242').frozen?
+  end
+  
+  def test_should_be_dankort_card_type
+    assert_equal 'dankort', CreditCard.type?('5019717010103742')
+  end
+  
+  def test_should_detect_visa_dankort_as_visa
+    assert_equal 'visa', CreditCard.type?('4571100000000000')
+  end
+  
+  def test_should_detect_electron_dk_as_visa
+    assert_equal 'visa', CreditCard.type?('4175001000000000')
+  end
+  
+  def test_should_detect_diners_club
+    assert_equal 'diners_club', CreditCard.type?('36148010000000')
+  end
+  
+  def test_should_detect_diners_club_dk
+    assert_equal 'diners_club', CreditCard.type?('30401000000000')
+  end
+  
+  def test_should_detect_maestro_dk_as_maestro
+    assert_equal 'maestro', CreditCard.type?('6769271000000000')
+  end
+  
+  def test_should_detect_maestro_cards
+    assert_equal 'maestro', CreditCard.type?('5020100000000000')
+    
+    maestro_card_numbers.each { |number| assert_equal 'maestro', CreditCard.type?(number) }
+    non_maestro_card_numbers.each { |number| assert_not_equal 'maestro', CreditCard.type?(number) }
+  end
+  
+  def test_should_detect_mastercard
+    assert_equal 'master', CreditCard.type?('6771890000000000')
+    assert_equal 'master', CreditCard.type?('5413031000000000')
+  end
+  
+  def test_should_detect_forbrugsforeningen
+    assert_equal 'forbrugsforeningen', CreditCard.type?('6007221000000000')
+  end
+  
+  def test_should_detect_laser_card
+    # 16 digits
+    assert_equal 'laser', CreditCard.type?('6304985028090561')
+    
+    # 18 digits
+    assert_equal 'laser', CreditCard.type?('630498502809056151')
+    
+    # 19 digits
+    assert_equal 'laser', CreditCard.type?('6304985028090561515')
+    
+    # 17 digits
+    assert_not_equal 'laser', CreditCard.type?('63049850280905615')
+    
+    # 15 digits
+    assert_not_equal 'laser', CreditCard.type?('630498502809056')
+    
+    # Alternate format
+    assert_equal 'laser', CreditCard.type?('6706950000000000000')
+    
+    # Alternate format (16 digits)
+    assert_equal 'laser', CreditCard.type?('6706123456789012')
+
+    # New format (16 digits)
+    assert_equal 'laser', CreditCard.type?('6709123456789012')
+    
+    # Ulster bank (Ireland) with 12 digits
+    assert_equal 'laser', CreditCard.type?('677117111234')
+  end
+  
+  def test_should_detect_when_an_argument_type_does_not_match_calculated_type
+    assert CreditCard.matching_type?('4175001000000000', 'visa')
+    assert_false CreditCard.matching_type?('4175001000000000', 'master')
+  end
+  
+  def test_detecting_full_range_of_maestro_card_numbers
+    maestro = '50000000000'
+    
+    assert_equal 11, maestro.length
+    assert_not_equal 'maestro', CreditCard.type?(maestro)
+    
+    while maestro.length < 19
+      maestro << '0'
+      assert_equal 'maestro', CreditCard.type?(maestro)
+    end
+    
+    assert_equal 19, maestro.length
+    
+    maestro << '0'
+    assert_not_equal 'maestro', CreditCard.type?(maestro)
+  end
+  
+  def test_matching_discover_card
+    assert_equal 'discover', CreditCard.type?('6011000000000000')
+    assert_equal 'discover', CreditCard.type?('6500000000000000')
+    assert_equal 'discover', CreditCard.type?('6221260000000000')
+    assert_equal 'discover', CreditCard.type?('6450000000000000')
+    
+    assert_not_equal 'discover', CreditCard.type?('6010000000000000')
+    assert_not_equal 'discover', CreditCard.type?('6600000000000000')
+  end
+  
+  def test_16_digit_maestro_uk
+    number = '6759000000000000'
+    assert_equal 16, number.length
+    assert_equal 'switch', CreditCard.type?(number)
+  end
+  
+  def test_18_digit_maestro_uk
+    number = '675900000000000000'
+    assert_equal 18, number.length
+    assert_equal 'switch', CreditCard.type?(number)
+  end
+  
+  def test_19_digit_maestro_uk
+    number = '6759000000000000000'
+    assert_equal 19, number.length
+    assert_equal 'switch', CreditCard.type?(number)
+  end
+end