activemerchant 1.2.1 → 1.3.0

data/test/remote/gateways/remote_moneris_test.rb

@@ -0,0 +1,82 @@
+require File.dirname(__FILE__) + '/../../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_tests → remote/gateways}/remote_net_registry_test.rb

@@ -1,8 +1,6 @@
 require 'test/unit'
-require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/../../test_helper'
 
-######################################################################
-#
 # To run these tests, set the variables at the top of the class
 # definition.
 #
@@ -11,77 +9,42 @@ require File.dirname(__FILE__) + '/../test_helper'
 # 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
-  #
-  # Provide valid data here to run the tests.
-  #
-  # LOG_FILE_NAME may be nil, or a filename to write messages sent to
-  # and received from the gateway
-  #
-
-  LOG_FILE_NAME = nil
-  VALID_CARD_DETAILS = {
-    :number => '4111111111111111',
-    :month => 12,
-    :year => 2010,
-    :first_name => 'Longbob',
-    :last_name => 'Longsen',
-    :type => :visa,
-  }
 
   def setup
-    if LOG_FILE_NAME
-      @log_file = open(LOG_FILE_NAME, 'a')
-      @logger = Logger.new(@log_file)
-    end
-
     @gateway = NetRegistryGateway.new(fixtures(:net_registry))
 
-    @valid_creditcard = CreditCard.new(VALID_CARD_DETAILS)
-    @invalid_creditcard = CreditCard.new(
-      VALID_CARD_DETAILS.merge(:type => :visa, :number => '4111111111111111')
-    )
-    @expired_creditcard = CreditCard.new(
-      VALID_CARD_DETAILS.merge(:year => 2000)
-    )
-    @invalid_month_creditcard = CreditCard.new(
-      VALID_CARD_DETAILS.merge(:month => 13)
-    )
-  end
-
-  def teardown
-    @log_file.close if @log_file
+    @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(100, @valid_creditcard)
+    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(100, 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
+  # #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(100, @valid_creditcard)
+      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(100,
+      response = @gateway.capture(@amount,
                                   response.authorization,
                                   :credit_card => @valid_creditcard)
       assert_success response
@@ -90,30 +53,32 @@ class NetRegistryTest < Test::Unit::TestCase
   end
 
   def test_purchase_with_invalid_credit_card
-    response = @gateway.purchase(100, @invalid_creditcard)
+    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(100, @expired_creditcard)
+    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(100, @invalid_month_creditcard)
+    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(100, @valid_creditcard)
+    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

data/test/remote/gateways/remote_netbilling_test.rb

@@ -0,0 +1,70 @@
+require File.dirname(__FILE__) + '/../../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_tests → remote/gateways}/remote_pay_junction_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/../../test_helper'
 
 class PayJunctionTest < Test::Unit::TestCase
   include ActiveMerchant::Billing
@@ -10,7 +10,7 @@ class PayJunctionTest < Test::Unit::TestCase
   def setup
     @gateway = PayJunctionGateway.new(fixtures(:pay_junction))
 
-    @creditcard = credit_card('4433221111223344')
+    @credit_card = credit_card('4444333322221111', :verification_value => '123')
     
     @valid_verification_value = '123'
     @invalid_verification_value = '1234'
@@ -22,6 +22,7 @@ class PayJunctionTest < Test::Unit::TestCase
       :state => 'CA',
       :zip => '90001'
     }
+    
     @invalid_address = {
       :address1 => '187 Apple Tree Lane.',
       :address2 => nil,
@@ -29,55 +30,45 @@ class PayJunctionTest < Test::Unit::TestCase
       :state => 'CA', 
       :zip => '94062'
     }
+    
+    @options = { :billing_address => @valid_address, :order_id => generate_unique_id }
   end
   
   def test_successful_purchase
-    assert response = @gateway.purchase(AMOUNT, 
-                                        @creditcard, 
-                                        :order_id => generate_order_id)
-    
-    #p response
-    assert_equal Response, response.class
-    assert_match /APPROVAL/, response.message
+    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_equal true, response.success?    
+    assert_equal 'charge', response.params["transaction_action"]  
+    assert_success response
+    assert response.test?
   end
 
   def test_successful_purchase_with_cvv
-    @creditcard.verification_value = @valid_verification_value
-    assert response = @gateway.purchase(AMOUNT, 
-                                        @creditcard, 
-                                        :order_id => generate_order_id)
+    @credit_card.verification_value = @valid_verification_value
+    assert response = @gateway.purchase(AMOUNT, @credit_card, @options)
         
-    assert_equal Response, response.class  
-    assert_match /APPROVAL/, response.message
+    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_equal true, response.success?
+    assert_success response
   end
 
   def test_successful_authorize
-    assert response = @gateway.authorize( AMOUNT, 
-                                          @creditcard, 
-                                          :order_id => generate_order_id)
+    assert response = @gateway.authorize( AMOUNT, @credit_card, @options)
     
-    assert_equal Response, response.class
-    assert_match /APPROVAL/, response.message
+    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_equal true, response.success?    
+    assert_success response    
   end
 
   def test_successful_capture
-    order_id = generate_order_id
-    auth = @gateway.authorize(AMOUNT, @creditcard, :order_id => order_id)
+    auth = @gateway.authorize(AMOUNT, @credit_card, @options)
     assert_success auth
-    response = @gateway.capture(AMOUNT, auth.authorization, :order_id => order_id)
-    
+
+    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,
@@ -85,26 +76,22 @@ class PayJunctionTest < Test::Unit::TestCase
   end
 
   def test_successful_credit
-    purchase = @gateway.purchase(AMOUNT, @creditcard, :order_id => generate_order_id)
+    purchase = @gateway.purchase(AMOUNT, @credit_card, @options)
     assert_success purchase
     
     assert response = @gateway.credit(success_price, purchase.authorization)
-  
-    assert_equal Response, response.class
     assert_equal 'refund', response.params["transaction_action"]
     
-    assert_equal true, response.success?    
+    assert_success response    
   end
 
   def test_successful_void
-    order_id = generate_order_id
-    purchase = @gateway.purchase(AMOUNT, @creditcard, :order_id => order_id)
+    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_equal Response, response.class
-    
-    assert_equal true, response.success?
+    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"
@@ -115,44 +102,38 @@ class PayJunctionTest < Test::Unit::TestCase
     # transaction can be executed if you have the transaction ID of a
     # previous successful transaction.
     
-    purchase = @gateway.purchase( AMOUNT, 
-                                  @creditcard, 
-                                  :order_id => generate_order_id)
+    purchase = @gateway.purchase( AMOUNT, @credit_card, @options)
     assert_success purchase
     
-    assert response = @gateway.purchase(AMOUNT, 
-                                        purchase.authorization, 
-                                        :order_id => generate_order_id)
-
-    assert_equal Response, response.class
-    assert_match /APPROVAL/, response.message
+    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_equal true, response.success?
+    assert_success response
   end
 
   def test_successful_recurring
-    assert response = @gateway.recurring(AMOUNT, @creditcard, 
-                                            :periodicity  => :monthly,
-                                            :payments     => 12,
-                                            :order_id => generate_order_id)
-    assert_equal Response, response.class
-    assert_match /APPROVAL/, response.message
+    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_equal true, response.success?
+    assert_success response
   end
 
   def test_should_send_invoice
-    order_id = generate_order_id
-    
-    response = @gateway.purchase(AMOUNT, @creditcard, :order_id => order_id)
+    response = @gateway.purchase(AMOUNT, @credit_card, @options)
     assert_success response
     
-    assert_equal order_id, response.params["invoice_number"], 'Should have set invoice'
+    assert_equal @options[:order_id], response.params["invoice_number"], 'Should have set invoice'
   end
 
   private