activemerchant 1.5.0 → 1.5.1

data/test/remote/gateways/remote_sallie_mae_test.rb

@@ -1,51 +0,0 @@
-require 'test_helper'
-
-class RemoteSallieMaeTest < Test::Unit::TestCase
-  def setup
-    @gateway = SallieMaeGateway.new(fixtures(:sallie_mae))
-    
-    @amount = 100
-    @credit_card = credit_card('5454545454545454')
-    @declined_card = credit_card('4000300011112220')
-    
-    @options = { 
-      :billing_address => address,
-      :description => 'Store Purchase'
-    }
-  end
-
-  def test_successful_purchase
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-    assert_success response
-    assert_equal 'Accepted', response.message
-  end
-
-  def test_unsuccessful_purchase
-    assert response = @gateway.purchase(@amount, @declined_card, @options)
-    assert_failure response
-    assert_equal 'Cvv2 mismatch', response.message
-  end
-
-  def test_authorize_and_capture
-    amount = (@amount * rand).to_i
-    assert auth = @gateway.authorize(amount, @credit_card, @options)
-    assert_success auth
-    assert_equal 'Accepted', auth.message
-    assert auth.authorization
-    assert capture = @gateway.capture(amount, auth.authorization)
-    assert_success capture
-  end
-
-  def test_failed_capture
-    assert response = @gateway.capture(@amount, '')
-    assert_failure response
-    assert_equal 'Missing account number', response.message
-  end
-
-  def test_invalid_login
-    gateway = SallieMaeGateway.new(:login => '')
-    assert response = gateway.purchase(@amount, @credit_card, @options)
-    assert_failure response
-    assert_equal 'Invalid merchant', response.message
-  end
-end

data/test/remote/gateways/remote_secure_pay_au_test.rb

@@ -1,40 +0,0 @@
-require 'test_helper'
-
-class RemoteSecurePayAuTest < Test::Unit::TestCase
-  
-  def setup
-    @gateway = SecurePayAuGateway.new(fixtures(:secure_pay_au))
-    
-    @amount = 100
-    @credit_card = credit_card('4444333322221111')
-
-    @options = { 
-      :order_id => '1',
-      :billing_address => address,
-      :description => 'Store Purchase'
-    }
-  end
-  
-  def test_successful_purchase
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-    assert_success response
-    assert_equal 'Approved', response.message
-  end
-
-  def test_unsuccessful_purchase
-    @credit_card.year = '2005'
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-    assert_failure response
-    assert_equal 'CARD EXPIRED', response.message
-  end
-
-  def test_invalid_login
-    gateway = SecurePayAuGateway.new(
-                :login => '',
-                :password => ''
-              )
-    assert response = gateway.purchase(@amount, @credit_card, @options)
-    assert_failure response
-    assert_equal "Invalid merchant ID", response.message
-  end
-end

data/test/remote/gateways/remote_secure_pay_tech_test.rb

@@ -1,37 +0,0 @@
-require 'test_helper'
-
-class RemoteSecurePayTechTest < Test::Unit::TestCase
-  $verbose = true
-
-  def setup
-    @gateway = SecurePayTechGateway.new(fixtures(:secure_pay_tech))
-    
-    @accepted_amount = 10000
-    @declined_amount = 10075
-    
-    @credit_card = credit_card('4987654321098769', :month => '5', :year => '2013')
-    @options = { :billing_address => address }
-  end
-  
-  def test_successful_purchase
-    assert response = @gateway.purchase(@accepted_amount, @credit_card, @options)
-    assert_equal 'Transaction OK', response.message
-    assert_success response
-  end
-
-  def test_unsuccessful_purchase
-    assert response = @gateway.purchase(@declined_amount, @credit_card, @options)
-    assert_equal 'Card declined', response.message
-    assert_failure response
-  end
-
-  def test_invalid_login
-    gateway = SecurePayTechGateway.new(
-                :login => 'foo',
-                :password => 'bar'
-              )
-    assert response = gateway.purchase(@accepted_amount, @credit_card, @options)
-    assert_equal 'Bad or malformed request', response.message
-    assert_failure response
-  end
-end

data/test/remote/gateways/remote_secure_pay_test.rb

@@ -1,28 +0,0 @@
-require 'test_helper'
-
-class RemoteSecurePayTest < Test::Unit::TestCase  
-  
-  def setup
-    @gateway = SecurePayGateway.new(fixtures(:secure_pay))
-
-    @credit_card = credit_card('4111111111111111',
-      :month => '7',
-      :year  => '2014'
-    )
-    
-    @options = { :order_id => generate_unique_id,
-      :description => 'Store purchase',
-      :billing_address => address
-    }
-    
-    @amount = 100
-  end
-  
-  def test_successful_purchase
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-    assert response.success?
-    assert response.test?
-    assert_equal 'This transaction has been approved', response.message
-    assert response.authorization
-  end
-end

data/test/remote/gateways/remote_skipjack_test.rb

@@ -1,105 +0,0 @@
-require 'test_helper'
-
-class RemoteSkipJackTest < Test::Unit::TestCase
-  def setup
-    Base.mode = :test
-
-    @gateway = SkipJackGateway.new(fixtures(:skip_jack))
-
-    @credit_card = credit_card('4445999922225',
-                    :verification_value => '999'
-                  )
-
-    @amount = 100
-    
-    @options = {
-      :order_id => generate_unique_id,
-      :email => 'email@foo.com',
-      :billing_address => address
-    }
-  end
-  
-  def test_successful_authorization
-    authorization = @gateway.authorize(@amount, @credit_card, @options)
-    assert_success authorization
-    assert_false authorization.authorization.blank?
-  end
-  
-  def test_unsuccessful_authorization
-    @credit_card.number = '1234'
-    authorization = @gateway.authorize(@amount, @credit_card, @options)
-    assert_failure authorization
-  end
-  
-  def test_authorization_fails_without_phone_number
-    @options[:billing_address][:phone] = nil
-    authorization = @gateway.authorize(@amount, @credit_card, @options)
-    assert_failure authorization
-  end
-  
-  def test_successful_purchase
-    assert_success @gateway.purchase(@amount, @credit_card, @options)
-  end
-
-  def test_successful_authorization_and_capture
-    authorization = @gateway.authorize(@amount, @credit_card, @options)
-    
-    assert_success authorization
-    assert_false authorization.authorization.blank?
-    
-    capture = @gateway.capture(@amount, authorization.authorization)
-    assert_success capture
-  end
-  
-  def test_authorization_and_void
-    authorization = @gateway.authorize(101, @credit_card, @options)
-    assert_success authorization
-    void = @gateway.void(authorization.authorization)
-    assert_success void
-  end
-
-  def test_successful_authorization_and_credit
-    authorization = @gateway.authorize(@amount, @credit_card, @options)    
-    assert_success authorization
-    
-    capture = @gateway.capture(@amount, authorization.authorization, :force_settlement => true)
-    assert_success capture 
-
-    # developer login won't change transaction immediately to settled, so status will have to mismatch
-    credit = @gateway.credit(@amount, authorization.authorization)
-    assert_success credit
-  end
-
-  def test_authorization_with_invalid_verification_value
-    @credit_card.verification_value = '123'
-    
-    response = @gateway.authorize(@amount, @credit_card, @options)
-    assert_failure response
-    assert_equal "Card verification number didn't match", response.message
-  end
-
-  def test_authorization_and_status
-    authorization = @gateway.authorize(101, @credit_card, @options)
-    assert_success authorization
-    
-    status = @gateway.status(@options[:order_id])
-    assert_success status
-  end
-
-  def test_status_unkown_order
-    status = @gateway.status(generate_unique_id)
-    assert_failure status
-    assert_match /No Records Found/, status.message
-  end
-  
-  def test_invalid_login
-    gateway = SkipJackGateway.new(
-                :login => '555555555555',
-                :password => '999999999999'
-              )
-
-    response = gateway.authorize(@amount, @credit_card, @options)
-    assert_failure response
-    assert_match /Invalid serial number/, response.message
-  end
-end

data/test/remote/gateways/remote_trans_first_test.rb

@@ -1,34 +0,0 @@
-require 'test_helper'
-
-class RemoteTransFirstTest < Test::Unit::TestCase
-
-  def setup
-    @gateway = TransFirstGateway.new(fixtures(:trans_first))
-
-    @credit_card = credit_card('4111111111111111')
-    @amount = 100
-    @options = { 
-      :order_id => generate_unique_id,
-      :invoice => 'ActiveMerchant Sale',
-      :billing_address => address
-    }
-  end
-  
-  def test_successful_purchase
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-    assert_equal 'test transaction', response.message
-    assert response.test?
-    assert_success response
-    assert !response.authorization.blank?
-  end
-
-  def test_invalid_login
-    gateway = TransFirstGateway.new(
-      :login => '',
-      :password => ''
-    )
-    assert response = gateway.purchase(@amount, @credit_card, @options)
-    assert_equal 'invalid account', response.message
-    assert_failure response
-  end
-end

data/test/remote/gateways/remote_transax_test.rb

@@ -1,112 +0,0 @@
-require 'test_helper'
-
-class RemoteTransaxTest < Test::Unit::TestCase
-  def setup
-    @gateway = TransaxGateway.new(fixtures(:transax))
-    
-    @amount = 100
-    @credit_card = credit_card('4111111111111111', :year => 10, :month => 10)
-    @declined_card = credit_card(0xDEADBEEF_0000.to_s)
-    
-    @check = check()
-    
-    @options = { 
-      :order_id => '1',
-      :billing_address => address,
-      :description => 'Store Purchase'
-    }
-  end
-  
-  def test_successful_purchase
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-    assert_success response
-    assert_equal "This transaction has been approved", response.message
-  end
-  
-  def test_unsuccessful_purchase
-    assert response = @gateway.purchase(@amount, @declined_card, @options)
-    assert_failure response
-    assert_match /Invalid card number/, response.message
-  end
-  
-  def test_authorize_and_capture
-    assert auth = @gateway.authorize(@amount, @credit_card, @options)
-    assert_success auth
-    assert_equal "This transaction has been approved", auth.message
-    assert auth.authorization
-    assert capture = @gateway.capture(@amount, auth.authorization)
-    assert_success capture
-  end
-  
-  def test_authorize_and_void
-    assert auth = @gateway.authorize(@amount, @credit_card, @options)
-    assert_success auth
-    assert_equal "This transaction has been approved", auth.message
-    assert auth.authorization
-    assert void = @gateway.void(auth.authorization)
-    assert_equal "Transaction Void Successful", void.message
-    assert_success void
-  end
-  
-  def test_purchase_and_refund
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-    assert_success response
-    assert_equal "This transaction has been approved", response.message
-    assert response.authorization
-    assert refund = @gateway.refund(response.authorization)
-    assert_equal "This transaction has been approved", refund.message
-    assert_success refund
-  end
-  
-  def test_failed_capture
-    assert response = @gateway.capture(@amount, '')
-    assert_failure response
-    assert_match /Invalid Transaction ID/, response.message
-  end
-  
-  def test_credit
-    assert response = @gateway.credit(@amount, @credit_card, @options)
-    assert_success response
-    assert response.authorization
-    assert_equal "This transaction has been approved", response.message
-  end
-  
-  def test_purchase_and_update
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-    assert_success response
-    assert_equal "This transaction has been approved", response.message
-    assert response.authorization
-    assert update = @gateway.amend(response.authorization, :shipping_carrier => 'usps')
-    assert_equal "This transaction has been approved", update.message
-    assert_success update
-  end
-  
-  def test_successful_purchase_with_sku
-    @options['product_sku_#']='123456'
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-    assert_success response
-    assert_equal "This transaction has been approved", response.message
-  end
-  
-  def test_store_credit_card
-    assert response = @gateway.store(@credit_card)
-    assert_success response
-    assert !response.params['customer_vault_id'].blank?
-  end
-  
-  def test_store_check
-    assert response = @gateway.store(@check)
-    assert_success response
-    assert !response.params['customer_vault_id'].blank?
-  end
-  
-  def test_invalid_login
-    gateway = TransaxGateway.new(
-                :login => '',
-                :password => ''
-              )
-    assert response = gateway.purchase(@amount, @credit_card, @options)
-    assert_failure response
-    assert_equal "Invalid Username", response.message
-  end
-end

data/test/remote/gateways/remote_trust_commerce_test.rb

@@ -1,152 +0,0 @@
-require 'test_helper'
-
-class TrustCommerceTest < Test::Unit::TestCase
-  def setup
-    @gateway = TrustCommerceGateway.new(fixtures(:trust_commerce))
-    
-    @credit_card = credit_card('4111111111111111')
-    
-    @amount = 100
-    
-    @valid_verification_value = '123'
-    @invalid_verification_value = '1234'
-    
-    @valid_address = {
-      :address1 => '123 Test St.', 
-      :address2 => nil, 
-      :city => 'Somewhere', 
-      :state => 'CA', 
-      :zip => '90001'
-    }
-    
-    @invalid_address = {
-      :address1 => '187 Apple Tree Lane.',
-      :address2 => nil,
-      :city => 'Woodside',
-      :state => 'CA',
-      :zip => '94062'
-    }
-    
-    @options = { 
-      :ip => '10.10.10.10',
-      :order_id => '#1000.1',
-      :email => 'cody@example.com', 
-      :billing_address => @valid_address,
-      :shipping_address => @valid_address
-    }
-  end
-  
-  def test_bad_login
-    @gateway.options[:login] = 'X'
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-        
-    assert_equal Response, response.class
-    assert_equal ["error",
-                  "offenders",
-                  "status"], response.params.keys.sort
-
-    assert_match /A field was improperly formatted, such as non-digit characters in a number field/, response.message
-    
-    assert_failure response
-  end
-  
-  def test_successful_purchase_with_avs
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-    assert_equal 'Y', response.avs_result['code']
-    assert_match /The transaction was successful/, response.message
-    
-    assert_success response
-    assert !response.authorization.blank?
-  end
-  
-  def test_unsuccessful_purchase_with_invalid_cvv
-    @credit_card.verification_value = @invalid_verification_value
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-        
-    assert_equal Response, response.class
-    assert_match /CVV failed; the number provided is not the correct verification number for the card/, response.message
-    assert_failure response
-  end
-    
-  def test_purchase_with_avs_for_invalid_address
-    assert response = @gateway.purchase(@amount, @credit_card, @options.update(:billing_address => @invalid_address))
-    assert_equal "N", response.params["avs"]
-    assert_match /The transaction was successful/, response.message
-    assert_success response
-  end
-  
-  def test_successful_authorize_with_avs
-    assert response = @gateway.authorize(@amount, @credit_card, :billing_address => @valid_address)
-    
-    assert_equal "Y", response.avs_result["code"]
-    assert_match /The transaction was successful/, response.message
-
-    assert_success response
-    assert !response.authorization.blank?
-  end
-  
-  def test_unsuccessful_authorize_with_invalid_cvv
-    @credit_card.verification_value = @invalid_verification_value
-    assert response = @gateway.authorize(@amount, @credit_card, @options)
-    assert_match /CVV failed; the number provided is not the correct verification number for the card/, response.message
-    assert_failure response
-  end
-  
-  def test_authorization_with_avs_for_invalid_address
-    assert response = @gateway.authorize(@amount, @credit_card, @options.update(:billing_address => @invalid_address))
-    assert_equal "N", response.params["avs"]
-    assert_match /The transaction was successful/, response.message
-    assert_success response
-  end
-  
-  def test_successful_capture
-    auth = @gateway.authorize(300, @credit_card)
-    assert_success auth
-    response = @gateway.capture(300, auth.authorization)
-    
-    assert_success response
-    assert_equal 'The transaction was successful', response.message 
-    assert_equal 'accepted', response.params['status']
-    assert response.params['transid']
-  end
-  
-  def test_authorization_and_void
-    auth = @gateway.authorize(300, @credit_card, @options)
-    assert_success auth
-    
-    void = @gateway.void(auth.authorization)
-    assert_success void
-    assert_equal 'The transaction was successful', void.message 
-    assert_equal 'accepted', void.params['status']
-    assert void.params['transid']
-  end
-  
-  def test_successful_credit
-    assert response = @gateway.credit(@amount, '011-0022698151')
-    
-    assert_match /The transaction was successful/, response.message
-    assert_success response    
-  end
-  
-  def test_store_failure
-    assert response = @gateway.store(@credit_card)
-        
-    assert_equal Response, response.class
-    assert_match %r{The merchant can't accept data passed in this field}, response.message    
-    assert_failure response   
-  end
-  
-  def test_unstore_failure
-    assert response = @gateway.unstore('testme')
-
-    assert_match %r{The merchant can't accept data passed in this field}, response.message    
-    assert_failure response
-  end
-  
-  def test_recurring_failure
-    assert response = @gateway.recurring(@amount, @credit_card, :periodicity => :weekly)
-
-    assert_match %r{The merchant can't accept data passed in this field}, response.message    
-    assert_failure response
-  end
-end