activemerchant 1.5.0 → 1.5.1

data/test/remote/gateways/remote_modern_payments_test.rb

@@ -1,57 +0,0 @@
-require 'test_helper'
-
-class RemoteModernPaymentTest < Test::Unit::TestCase
-
-  def setup
-    @gateway = ModernPaymentsGateway.new(fixtures(:modern_payments))
-    
-    @amount = 100
-    @credit_card = credit_card('4111111111111111')
-    @declined_card = credit_card('4000000000000000')
-    
-    @options = { 
-      :order_id => '1',
-      :billing_address => address,
-      :description => 'Store Purchase'
-    }
-    
-  end
-  
-  def test_successful_purchase
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-    
-    # Test mode seems to not return "approved = true"
-    assert_failure response
-    assert_match /RESPONSECODE=A/, response.params["auth_string"]
-    assert_equal ModernPaymentsCimGateway::FAILURE_MESSAGE, response.message
-  end
-
-  def test_unsuccessful_purchase
-    assert response = @gateway.purchase(@amount, @declined_card, @options)
-    assert_failure response
-    assert_match /RESPONSECODE=D/, response.params["auth_string"]
-    assert_equal ModernPaymentsCimGateway::FAILURE_MESSAGE, response.message
-  end
-
-  def test_invalid_login
-    gateway = ModernPaymentsGateway.new(
-                :login => '5000',
-                :password => 'password'
-              )
-    assert response = gateway.purchase(@amount, @credit_card, @options)
-    assert_failure response
-    assert_equal ModernPaymentsCimGateway::FAILURE_MESSAGE, response.message
-  end
-  
-  def test_invalid_login
-    gateway = ModernPaymentsGateway.new(
-                :login => '',
-                :password => ''
-              )
-              
-    assert_raises(ActiveMerchant::ResponseError) do
-      gateway.purchase(@amount, @credit_card, @options)
-    end
-  end
-  
-end

data/test/remote/gateways/remote_moneris_test.rb

@@ -1,82 +0,0 @@
-require 'test_helper'
-
-class MonerisRemoteTest < Test::Unit::TestCase
-  def setup
-    Base.mode = :test
-
-    @gateway = MonerisGateway.new(fixtures(:moneris))
-    @amount = 100
-    @credit_card = credit_card('4242424242424242')
-    @options = { 
-      :order_id => generate_unique_id,
-      :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
-    assert_false response.authorization.blank? 
-  end
-  
-  def test_successful_authorization
-    response = @gateway.authorize(@amount, @credit_card, @options)
-    assert_success response
-    assert_false response.authorization.blank?
-  end
-
-  def test_failed_authorization
-    response = @gateway.authorize(105, @credit_card, @options)
-    assert_failure response
-  end
-
-  def test_successful_authorization_and_capture
-    response = @gateway.authorize(@amount, @credit_card, @options)
-    assert_success response
-    assert response.authorization
-
-    response = @gateway.capture(@amount, response.authorization)
-    assert_success response
-  end
-  
-  def test_successful_authorization_and_void
-    response = @gateway.authorize(@amount, @credit_card, @options)
-    assert_success response
-    assert response.authorization
-    
-    void = @gateway.void(response.authorization)
-    assert_success void
-  end
-  
-  def test_successful_purchase_and_void
-    purchase = @gateway.purchase(@amount, @credit_card, @options)
-    assert_success purchase
-    
-    void = @gateway.void(purchase.authorization)
-    assert_success void
-  end
-  
-  def test_failed_purchase_and_void
-    purchase = @gateway.purchase(101, @credit_card, @options)
-    assert_failure purchase
-    
-    void = @gateway.void(purchase.authorization)
-    assert_failure void
-  end
-  
-  def test_successful_purchase_and_credit
-    purchase = @gateway.purchase(@amount, @credit_card, @options)
-    assert_success purchase
-    
-    credit = @gateway.credit(@amount, purchase.authorization)
-    assert_success credit
-  end
-
-  def test_failed_purchase_from_error
-    assert response = @gateway.purchase(150, @credit_card, @options)
-    assert_failure response
-    assert_equal 'Declined', response.message
-  end
-end

data/test/remote/gateways/remote_net_registry_test.rb

@@ -1,85 +0,0 @@
-require 'test/unit'
-require 'test_helper'
-
-# To run these tests, set the variables at the top of the class
-# definition.
-#
-# Note that NetRegistry does not provide any sort of test
-# server/account, so you'll probably want to refund any uncredited
-# purchases through the NetRegistry console at www.netregistry.com .
-# All purchases made in these tests are $1, so hopefully you won't be
-# sent broke if you forget...
-class NetRegistryTest < Test::Unit::TestCase
-
-  def setup
-    @gateway = NetRegistryGateway.new(fixtures(:net_registry))
-
-    @amount = 100
-    @valid_creditcard = credit_card
-    @invalid_creditcard = credit_card('41111111111111111')
-    @expired_creditcard = credit_card('4111111111111111', :year => '2000')
-    @invalid_month_creditcard = credit_card('4111111111111111', :month => '13')
-  end
-
-  def test_successful_purchase_and_credit
-    response = @gateway.purchase(@amount, @valid_creditcard)
-    assert_equal 'approved', response.params['status']
-    assert_success response
-    assert_match(/\A\d{16}\z/, response.authorization)
-
-    response = @gateway.credit(@amount, response.authorization)
-    assert_equal 'approved', response.params['status']
-    assert_success response
-  end
-
-  # #authorize and #capture haven't been tested because the author's
-  # account hasn't been setup to support these methods (see the
-  # documentation for the NetRegistry gateway class).  There is no
-  # mention of a #void transaction in NetRegistry's documentation,
-  # either.
-  if ENV['TEST_AUTHORIZE_AND_CAPTURE']
-    def test_successful_authorization_and_capture
-      response = @gateway.authorize(@amount, @valid_creditcard)
-      assert_success response
-      assert_equal 'approved', response.params['status']
-      assert_match(/\A\d{6}\z/, response.authorization)
-
-      response = @gateway.capture(@amount,
-                                  response.authorization,
-                                  :credit_card => @valid_creditcard)
-      assert_success response
-      assert_equal 'approved', response.params['status']
-    end
-  end
-
-  def test_purchase_with_invalid_credit_card
-    response = @gateway.purchase(@amount, @invalid_creditcard)
-    assert_equal 'declined', response.params['status']
-    assert_equal 'INVALID CARD', response.message
-    assert_failure response
-  end
-
-  def test_purchase_with_expired_credit_card
-    response = @gateway.purchase(@amount, @expired_creditcard)
-    assert_equal 'failed', response.params['status']
-    assert_equal 'CARD EXPIRED', response.message
-    assert_failure response
-  end
-
-  def test_purchase_with_invalid_month
-    response = @gateway.purchase(@amount, @invalid_month_creditcard)
-    assert_equal 'failed', response.params['status']
-    assert_equal 'Invalid month', response.message
-    assert_failure response
-  end
-
-  def test_bad_login
-    gateway = NetRegistryGateway.new(
-                 :login    => 'bad-login',
-                 :password => 'bad-login'
-               )
-    response = gateway.purchase(@amount, @valid_creditcard)
-    assert_equal 'failed', response.params['status']
-    assert_failure response
-  end
-end

data/test/remote/gateways/remote_netbilling_test.rb

@@ -1,70 +0,0 @@
-require 'test_helper'
-
-class RemoteNetbillingTest < Test::Unit::TestCase
- 
-  def setup
-    @gateway = NetbillingGateway.new(fixtures(:netbilling))
-
-    @credit_card = credit_card('4444111111111119',
-                     :month => '9',
-                     :year  => '2009',
-                     :verification_value => nil
-                   )
-
-    @address = {  :address1 => '1600 Amphitheatre Parkway',
-                  :city => 'Mountain View',
-                  :state => 'CA',
-                  :country => 'US',
-                  :zip => '94043',
-                  :phone => '650-253-0001'
-                }
-  
-    @options = {  
-      :billing_address => @address,
-      :description => 'Internet purchase'
-    }
-               
-    @amount = 100
-  end
-  
-  def test_successful_purchase
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-    assert_success response
-    assert_false response.authorization.blank?
-    assert_equal NetbillingGateway::SUCCESS_MESSAGE, response.message
-    assert response.test?
-  end
-
-  def test_unsuccessful_purchase
-    @credit_card.year = '2006'
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-    assert_equal 'CARD EXPIRED', response.message
-    assert_failure response
-  end
-
-  def test_authorize_and_capture
-    amount = @amount
-    assert auth = @gateway.authorize(amount, @credit_card, @options)
-    assert_success auth
-    assert_equal NetbillingGateway::SUCCESS_MESSAGE, 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, '1111')
-    assert_failure response
-    assert_equal NetbillingGateway::FAILURE_MESSAGE, response.message
-  end
-
-  def test_invalid_login
-    gateway = NetbillingGateway.new(
-                :login => '',
-                :password => ''
-              )
-    assert response = gateway.purchase(@amount, @credit_card, @options)
-    assert_equal NetbillingGateway::FAILURE_MESSAGE, response.message
-    assert_failure response
-  end
-end

data/test/remote/gateways/remote_ogone_test.rb

@@ -1,115 +0,0 @@
-require 'test_helper'
-
-class RemoteOgoneTest < Test::Unit::TestCase
-
-  def setup
-    @gateway = OgoneGateway.new(fixtures(:ogone))
-    @amount = 100
-    @credit_card =   credit_card('4000100011112224')
-    @declined_card = credit_card('1111111111111111')
-    @options = {
-      :order_id => generate_unique_id[0...30],
-      :billing_address => address,
-      :description => 'Store Purchase'
-    }
-  end
-
-  def test_successful_purchase
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-    assert_success response
-    assert_equal OgoneGateway::SUCCESS_MESSAGE, response.message
-  end
-  
-  def test_successful_with_non_numeric_order_id
-    @options[:order_id] = "##{@options[:order_id][0...26]}.12"
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-    assert_success response
-    assert_equal OgoneGateway::SUCCESS_MESSAGE, response.message
-  end
-
-  def test_successful_purchase_without_order_id
-    @options.delete(:order_id)
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-    assert_success response
-    assert_equal OgoneGateway::SUCCESS_MESSAGE, response.message
-  end
-
-  def test_unsuccessful_purchase
-    assert response = @gateway.purchase(@amount, @declined_card, @options)
-    assert_failure response
-    assert_equal 'No brand', response.message
-  end
-
-  def test_authorize_and_capture
-    assert auth = @gateway.authorize(@amount, @credit_card, @options)
-    assert_success auth
-    assert_equal OgoneGateway::SUCCESS_MESSAGE, auth.message
-    assert auth.authorization
-    assert capture = @gateway.capture(@amount, auth.authorization)
-    assert_success capture
-  end
-
-  def test_unsuccessful_capture
-    assert response = @gateway.capture(@amount, '')
-    assert_failure response
-    assert_equal 'No card no, no exp date, no brand', response.message
-  end
-
-  def test_successful_void
-    assert auth = @gateway.authorize(@amount, @credit_card, @options)
-    assert_success auth
-    assert auth.authorization
-    assert void = @gateway.void(auth.authorization)
-    assert_equal OgoneGateway::SUCCESS_MESSAGE, auth.message
-    assert_success void
-  end
-
-  def test_successful_referenced_credit
-    assert purchase = @gateway.purchase(@amount, @credit_card, @options)
-    assert_success purchase
-    assert credit = @gateway.credit(@amount, purchase.authorization, @options)
-    assert_success credit
-    assert credit.authorization
-    assert_equal OgoneGateway::SUCCESS_MESSAGE, credit.message
-  end
-
-  def test_unsuccessful_referenced_credit
-    assert purchase = @gateway.purchase(@amount, @credit_card, @options)
-    assert_success purchase
-    assert credit = @gateway.credit(@amount+1, purchase.authorization, @options) # too much refund requested
-    assert_failure credit
-    assert credit.authorization
-    assert_equal 'Overflow in refunds requests', credit.message
-  end
-
-  def test_successful_unreferenced_credit
-    assert credit = @gateway.credit(@amount, @credit_card, @options)
-    assert_success credit
-    assert credit.authorization
-    assert_equal OgoneGateway::SUCCESS_MESSAGE, credit.message
-  end
-
-  def test_reference_transactions
-    # Setting an alias
-    assert response = @gateway.purchase(@amount, credit_card('4000100011112224'), @options.merge(:store => "awesomeman", :order_id=>Time.now.to_i.to_s+"1"))
-    assert_success response
-    # Updating an alias
-    assert response = @gateway.purchase(@amount, credit_card('4111111111111111'), @options.merge(:store => "awesomeman", :order_id=>Time.now.to_i.to_s+"2"))
-    assert_success response
-    # Using an alias (i.e. don't provide the credit card)
-    assert response = @gateway.purchase(@amount, "awesomeman", @options.merge(:order_id=>Time.now.to_i.to_s+"3"))
-    assert_success response
-  end
-
-  def test_invalid_login
-    gateway = OgoneGateway.new(
-                :login => '',
-                :user => '',
-                :password => ''
-              )
-    assert response = gateway.purchase(@amount, @credit_card, @options)
-    assert_failure response
-    assert_equal 'No pspid', response.message
-  end
-
-end

data/test/remote/gateways/remote_pay_junction_test.rb

@@ -1,143 +0,0 @@
-require 'test_helper'
-
-class PayJunctionTest < Test::Unit::TestCase
-  include ActiveMerchant::Billing
-  
-  cattr_accessor :current_invoice
-  
-  AMOUNT = 250
-  
-  def setup
-    @gateway = PayJunctionGateway.new(fixtures(:pay_junction))
-
-    @credit_card = credit_card('4444333322221111', :verification_value => '123')
-    
-    @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 = { :billing_address => @valid_address, :order_id => generate_unique_id }
-  end
-  
-  def test_successful_purchase
-    assert response = @gateway.purchase(AMOUNT, @credit_card, @options)
-    assert_equal PayJunctionGateway::SUCCESS_MESSAGE, response.message
-    assert_equal 'capture', response.params["posture"], 'Should be captured funds'
-    assert_equal 'charge', response.params["transaction_action"]  
-    assert_success response
-    assert response.test?
-  end
-
-  def test_successful_purchase_with_cvv
-    @credit_card.verification_value = @valid_verification_value
-    assert response = @gateway.purchase(AMOUNT, @credit_card, @options)
-        
-    assert_equal PayJunctionGateway::SUCCESS_MESSAGE, response.message
-    assert_equal 'capture', response.params["posture"], 'Should be captured funds'
-    assert_equal 'charge', response.params["transaction_action"]
-    
-    assert_success response
-  end
-
-  def test_successful_authorize
-    assert response = @gateway.authorize( AMOUNT, @credit_card, @options)
-    
-    assert_equal PayJunctionGateway::SUCCESS_MESSAGE, response.message
-    assert_equal 'hold', response.params["posture"], 'Should be a held charge'
-    assert_equal 'charge', response.params["transaction_action"]
-    
-    assert_success response    
-  end
-
-  def test_successful_capture
-    auth = @gateway.authorize(AMOUNT, @credit_card, @options)
-    assert_success auth
-
-    response = @gateway.capture(AMOUNT, auth.authorization, @options)
-    assert_success response
-    assert_equal 'capture', response.params["posture"], 'Should be a capture'
-    assert_equal auth.authorization, response.authorization,
-        "Should maintain transaction ID across request"
-  end
-
-  def test_successful_credit
-    purchase = @gateway.purchase(AMOUNT, @credit_card, @options)
-    assert_success purchase
-    
-    assert response = @gateway.credit(success_price, purchase.authorization)
-    assert_equal 'refund', response.params["transaction_action"]
-    
-    assert_success response    
-  end
-
-  def test_successful_void
-    order_id = generate_unique_id
-    purchase = @gateway.purchase(AMOUNT, @credit_card, @options)
-    assert_success purchase
-    
-    assert response = @gateway.void(AMOUNT, purchase.authorization, :order_id => order_id)    
-    assert_success response
-    assert_equal 'void', response.params["posture"], 'Should be a capture'
-    assert_equal purchase.authorization, response.authorization,
-        "Should maintain transaction ID across request"
-  end
-
-  def test_successful_instant_purchase
-    # this takes advatange of the PayJunction feature where another
-    # transaction can be executed if you have the transaction ID of a
-    # previous successful transaction.
-    
-    purchase = @gateway.purchase( AMOUNT, @credit_card, @options)
-    assert_success purchase
-    
-    assert response = @gateway.purchase(AMOUNT, purchase.authorization, :order_id => generate_unique_id)
-                                        
-    assert_equal PayJunctionGateway::SUCCESS_MESSAGE, response.message
-    assert_equal 'capture', response.params["posture"], 'Should be captured funds'
-    assert_equal 'charge', response.params["transaction_action"]
-    assert_not_equal purchase.authorization, response.authorization,
-        'Should have recieved new transaction ID'
-    
-    assert_success response
-  end
-
-  def test_successful_recurring
-    assert response = @gateway.recurring(AMOUNT, @credit_card, 
-                        :periodicity  => :monthly,
-                        :payments     => 12,
-                        :order_id => generate_unique_id
-                      )
-    
-    assert_equal PayJunctionGateway::SUCCESS_MESSAGE, response.message                                        
-    assert_equal 'charge', response.params["transaction_action"]
-    
-    assert_success response
-  end
-
-  def test_should_send_invoice
-    response = @gateway.purchase(AMOUNT, @credit_card, @options)
-    assert_success response
-    
-    assert_equal @options[:order_id], response.params["invoice_number"], 'Should have set invoice'
-  end
-
-  private
-  def success_price
-    200 + rand(200)
-  end
-end