activemerchant 1.5.0 → 1.5.1

data/test/remote/gateways/remote_authorize_net_test.rb

@@ -1,145 +0,0 @@
-require 'test_helper'
-
-class AuthorizeNetTest < Test::Unit::TestCase
-  def setup
-    Base.mode = :test
-    
-    @gateway = AuthorizeNetGateway.new(fixtures(:authorize_net))
-    @amount = 100
-    @credit_card = credit_card('4242424242424242')
-    @options = {
-      :order_id => generate_unique_id,
-      :billing_address => address,
-      :description => 'Store purchase'
-    }
-
-    @recurring_options = {
-      :amount => 100,
-      :subscription_name => 'Test Subscription 1',
-      :credit_card => @credit_card,
-      :billing_address => address.merge(:first_name => 'Jim', :last_name => 'Smith'),
-      :interval => {
-        :length => 1,
-        :unit => :months
-      },
-      :duration => {
-        :start_date => Date.today,
-        :occurrences => 1
-      }
-    }
-  end
-  
-  def test_successful_purchase
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-    assert_success response
-    assert response.test?
-    assert_equal 'This transaction has been approved', response.message
-    assert response.authorization
-  end
-  
-  def test_expired_credit_card
-    @credit_card.year = 2004 
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-    assert_failure response
-    assert response.test?
-    assert_equal 'The credit card has expired', response.message
-  end
-  
-  def test_forced_test_mode_purchase
-    gateway = AuthorizeNetGateway.new(fixtures(:authorize_net).update(:test => true))
-    assert response = gateway.purchase(@amount, @credit_card, @options)
-    assert_success response
-    assert response.test?
-    assert_match(/TESTMODE/, response.message)
-    assert response.authorization
-  end
-  
-  def test_successful_authorization
-    assert response = @gateway.authorize(@amount, @credit_card, @options)
-    assert_success response
-    assert_equal 'This transaction has been approved', response.message
-    assert response.authorization
-  end
-  
-  def test_authorization_and_capture
-    assert authorization = @gateway.authorize(@amount, @credit_card, @options)
-    assert_success authorization
-  
-    assert capture = @gateway.capture(@amount, authorization.authorization)
-    assert_success capture
-    assert_equal 'This transaction has been approved', capture.message
-  end
-  
-  def test_authorization_and_void
-    assert authorization = @gateway.authorize(@amount, @credit_card, @options)
-    assert_success authorization
-  
-    assert void = @gateway.void(authorization.authorization)
-    assert_success void
-    assert_equal 'This transaction has been approved', void.message
-  end
-  
-  def test_bad_login
-    gateway = AuthorizeNetGateway.new(
-      :login => 'X',
-      :password => 'Y'
-    )
-    
-    assert response = gateway.purchase(@amount, @credit_card)
-        
-    assert_equal Response, response.class
-    assert_equal ["avs_result_code",
-                  "card_code",
-                  "response_code",
-                  "response_reason_code",
-                  "response_reason_text",
-                  "transaction_id"], response.params.keys.sort
-
-    assert_match(/The merchant login ID or password is invalid/, response.message)
-    
-    assert_equal false, response.success?
-  end
-  
-  def test_using_test_request
-    gateway = AuthorizeNetGateway.new(
-      :login => 'X',
-      :password => 'Y'
-    )
-    
-    assert response = gateway.purchase(@amount, @credit_card)
-        
-    assert_equal Response, response.class
-    assert_equal ["avs_result_code",
-                  "card_code",
-                  "response_code",
-                  "response_reason_code",
-                  "response_reason_text",
-                  "transaction_id"], response.params.keys.sort
-  
-    assert_match(/The merchant login ID or password is invalid/, response.message)
-    
-    assert_equal false, response.success?    
-  end
-
-  def test_successful_recurring
-    assert response = @gateway.recurring(@amount, @credit_card, @recurring_options)
-    assert_success response
-    assert response.test?
-
-    subscription_id = response.authorization
-
-    assert response = @gateway.update_recurring(:subscription_id => subscription_id, :amount => @amount * 2)
-    assert_success response
-
-    assert response = @gateway.cancel_recurring(subscription_id)
-    assert_success response
-  end
-
-  def test_recurring_should_fail_expired_credit_card
-    @credit_card.year = 2004
-    assert response = @gateway.recurring(@amount, @credit_card, @recurring_options)
-    assert_failure response
-    assert response.test?
-    assert_equal 'E00018', response.params['code']
-  end
-end

data/test/remote/gateways/remote_beanstream_interac_test.rb

@@ -1,53 +0,0 @@
-require 'test_helper'
-
-class RemoteBeanstreamInteracTest < Test::Unit::TestCase
-  
-  def setup
-    @gateway = BeanstreamInteracGateway.new(fixtures(:beanstream_interac))
-    
-    @amount = 100
-    
-    @options = { 
-      :order_id => generate_unique_id,
-      :billing_address => {
-        :name => 'xiaobo zzz',
-        :phone => '555-555-5555',
-        :address1 => '1234 Levesque St.',
-        :address2 => 'Apt B',
-        :city => 'Montreal',
-        :state => 'QC',
-        :country => 'CA',
-        :zip => 'H2C1X8'
-      },
-      :email => 'xiaobozzz@example.com',
-      :subtotal => 800,
-      :shipping => 100,
-      :tax1 => 100,
-      :tax2 => 100,
-      :custom => 'reference one'
-    }
-  end
-  
-  def test_successful_purchase
-    assert response = @gateway.purchase(@amount, @options)
-    assert_success response
-    assert_equal "R", response.params["responseType"]
-    assert_false response.redirect.blank?
-  end
-  
-  def test_failed_confirmation
-    assert response = @gateway.confirm("")
-    assert_failure response
-  end
-  
-  def test_invalid_login
-    gateway = BeanstreamInteracGateway.new(
-                :merchant_id => '',
-                :login => '',
-                :password => ''
-              )
-    assert response = gateway.purchase(@amount, @options)
-    assert_failure response
-    assert_equal 'Invalid merchant id (merchant_id = 0)', response.message
-  end
-end

data/test/remote/gateways/remote_beanstream_test.rb

@@ -1,150 +0,0 @@
-require 'test_helper'
-
-# This test suite assumes that you have enabled username/password transaction validation in your Beanstream account.
-# You will experience some test failures if username/password validation transaction validation is not enabled.
-class RemoteBeanstreamTest < Test::Unit::TestCase
-  
-  def setup
-    @gateway = BeanstreamGateway.new(fixtures(:beanstream))
-    
-    # Beanstream test cards. Cards require a CVV of 123, which is the default of the credit card helper
-    @visa                = credit_card('4030000010001234')
-    @declined_visa       = credit_card('4003050500040005')
-    
-    @mastercard          = credit_card('5100000010001004')
-    @declined_mastercard = credit_card('5100000020002000')
-    
-    @amex                = credit_card('371100001000131')
-    @declined_amex       = credit_card('342400001000180')
-    
-    # Canadian EFT
-    @check               = check(
-                             :institution_number => '001',
-                             :transit_number     => '26729'
-                           )
-    
-    @amount = 1500
-    
-    @options = { 
-      :order_id => generate_unique_id,
-      :billing_address => {
-        :name => 'xiaobo zzz',
-        :phone => '555-555-5555',
-        :address1 => '1234 Levesque St.',
-        :address2 => 'Apt B',
-        :city => 'Montreal',
-        :state => 'QC',
-        :country => 'CA',
-        :zip => 'H2C1X8'
-      },
-      :email => 'xiaobozzz@example.com',
-      :subtotal => 800,
-      :shipping => 100,
-      :tax1 => 100,
-      :tax2 => 100,
-      :custom => 'reference one'
-    }
-  end
-  
-  def test_successful_visa_purchase
-    assert response = @gateway.purchase(@amount, @visa, @options)
-    assert_success response
-    assert_false response.authorization.blank?
-    assert_equal "Approved", response.message
-  end
-
-  def test_unsuccessful_visa_purchase
-    assert response = @gateway.purchase(@amount, @declined_visa, @options)
-    assert_failure response
-    assert_equal 'DECLINE', response.message
-  end
-  
-  def test_successful_mastercard_purchase
-    assert response = @gateway.purchase(@amount, @mastercard, @options)
-    assert_success response
-    assert_false response.authorization.blank?
-    assert_equal "Approved", response.message
-  end
-
-  def test_unsuccessful_mastercard_purchase
-    assert response = @gateway.purchase(@amount, @declined_mastercard, @options)
-    assert_failure response
-    assert_equal 'DECLINE', response.message
-  end
-  
-  def test_successful_amex_purchase
-    assert response = @gateway.purchase(@amount, @amex, @options)
-    assert_success response
-    assert_false response.authorization.blank?
-    assert_equal "Approved", response.message
-  end
-
-  def test_unsuccessful_amex_purchase
-    assert response = @gateway.purchase(@amount, @declined_amex, @options)
-    assert_failure response
-    assert_equal 'DECLINE', response.message
-  end
-
-  def test_authorize_and_capture
-    assert auth = @gateway.authorize(@amount, @visa, @options)
-    assert_success auth
-    assert_equal "Approved", auth.message
-    assert_false auth.authorization.blank?
-    
-    assert capture = @gateway.capture(@amount, auth.authorization)
-    assert_success capture
-    assert_false capture.authorization.blank?
-  end
-  
-  def test_failed_capture
-    assert response = @gateway.capture(@amount, '')
-    assert_failure response
-    assert_no_match %r{You are not authorized}, response.message, "You need to enable username/password validation"
-    assert_match %r{Missing or invalid adjustment id.}, response.message
-  end
-  
-  def test_successful_purchase_and_void
-    assert purchase = @gateway.purchase(@amount, @visa, @options)
-    assert_success purchase
-    
-    assert void = @gateway.void(purchase.authorization)
-    assert_success void
-  end
-  
-  def test_successful_purchase_and_credit_and_void_credit
-    assert purchase = @gateway.purchase(@amount, @visa, @options)
-    assert_success purchase
-    
-    assert credit = @gateway.credit(@amount, purchase.authorization)
-    assert_success purchase
-    
-    assert void = @gateway.void(credit.authorization)
-    assert_success void
-  end
-  
-  def test_successful_check_purchase
-    assert response = @gateway.purchase(@amount, @check, @options)
-    assert_success response
-    assert response.test?
-    assert_false response.authorization.blank?
-  end
-  
-  def test_successful_check_purchase_and_credit
-    assert purchase = @gateway.purchase(@amount, @check, @options)
-    assert_success purchase
-    
-    assert credit = @gateway.credit(@amount, purchase.authorization)
-    assert_success credit
-  end
-  
-  def test_invalid_login
-    gateway = BeanstreamGateway.new(
-                :merchant_id => '',
-                :login => '',
-                :password => ''
-              )
-    assert response = gateway.purchase(@amount, @visa, @options)
-    assert_failure response
-    assert_equal 'Invalid merchant id (merchant_id = 0)', response.message
-  end
-end

data/test/remote/gateways/remote_braintree_test.rb

@@ -1,147 +0,0 @@
-require 'test_helper'
-
-class RemoteBraintreeTest < Test::Unit::TestCase
-  def setup
-    @gateway = BraintreeGateway.new(fixtures(:braintree))
-
-    @amount = rand(10000) + 1001
-    @credit_card = credit_card('4111111111111111')
-    @check = check()
-    @declined_amount = rand(99)
-    @options = {  :order_id => generate_unique_id,
-                  :billing_address => address
-               }
-  end
-  
-  def test_successful_purchase
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-    assert_equal 'This transaction has been approved', response.message
-    assert_success response
-  end
-    
-  def test_successful_purchase_with_echeck
-    check = ActiveMerchant::Billing::Check.new(
-              :name => 'Fredd Bloggs',
-              :routing_number => '111000025', # Valid ABA # - Bank of America, TX
-              :account_number => '999999999999',
-              :account_holder_type => 'personal',
-              :account_type => 'checking'
-            )
-    assert response = @gateway.purchase(@amount, @check, @options)
-    assert_equal 'This transaction has been approved', response.message
-    assert_success response
-  end
-  
-  def test_successful_add_to_vault
-    @options[:store] = true
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-    assert_equal 'This transaction has been approved', response.message
-    assert_success response
-    assert_not_nil response.params["customer_vault_id"]
-  end
-
-  def test_successful_add_to_vault_with_store_method
-    assert response = @gateway.store(@credit_card)
-    assert_equal 'Customer Added', response.message
-    assert_success response
-    assert_not_nil response.params["customer_vault_id"]
-  end
-
-  def test_successful_add_to_vault_and_use
-    @options[:store] = true
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-    assert_equal 'This transaction has been approved', response.message
-    assert_success response
-    assert_not_nil customer_id = response.params["customer_vault_id"]
-    
-    assert second_response = @gateway.purchase(@amount*2, customer_id, @options)
-    assert_equal 'This transaction has been approved', second_response.message
-    assert second_response.success?  
-  end
-  
-  def test_add_to_vault_with_custom_vault_id
-    @options[:store] = rand(100000)+10001
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-    assert_equal 'This transaction has been approved', response.message
-    assert_success response
-    assert_equal @options[:store], response.params["customer_vault_id"].to_i
-  end
-  
-  def test_add_to_vault_with_custom_vault_id_with_store_method
-    @options[:billing_id] = rand(100000)+10001
-    assert response = @gateway.store(@credit_card, @options.dup)
-    assert_equal 'Customer Added', response.message
-    assert_success response
-    assert_equal @options[:billing_id], response.params["customer_vault_id"].to_i
-  end
-  
-  def test_add_to_vault_with_store_and_check
-    assert response = @gateway.store(@check, @options)
-    assert_equal 'Customer Added', response.message
-    assert_success response
-  end
-  
-  def test_update_vault
-    test_add_to_vault_with_custom_vault_id
-    @credit_card = credit_card('4111111111111111', :month => 10)
-    assert response = @gateway.update(@options[:store], @credit_card)
-    assert_success response
-    assert_equal 'Customer Update Successful', response.message
-  end
-  
-  def test_delete_from_vault
-    test_add_to_vault_with_custom_vault_id
-    assert response = @gateway.delete(@options[:store])
-    assert_success response
-    assert_equal 'Customer Deleted', response.message
-  end
-
-  def test_delete_from_vault_with_unstore_method
-    test_add_to_vault_with_custom_vault_id
-    assert response = @gateway.unstore(@options[:store])
-    assert_success response
-    assert_equal 'Customer Deleted', response.message
-  end
-
-  def test_declined_purchase
-    assert response = @gateway.purchase(@declined_amount, @credit_card, @options)
-    assert_equal 'This transaction has been declined', response.message
-    assert_failure response
-  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_equal 'This transaction has been approved', capture.message
-    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_failed_capture
-    assert response = @gateway.capture(@amount, '')
-    assert_failure response
-    assert  response.message.match(/Invalid Transaction ID \/ Object ID specified:/)
-  end
-
-  def test_invalid_login
-    gateway = BraintreeGateway.new(
-                :login => '',
-                :password => ''
-              )
-    assert response = gateway.purchase(@amount, @credit_card, @options)
-    assert_equal 'Invalid Username', response.message
-    assert_failure response
-  end
-end