smulube-activemerchant 1.5.1.4 → 1.7.0

data/test/remote/gateways/remote_payflow_uk_test.rb

@@ -1,173 +0,0 @@
-require 'test_helper'
-
-class RemotePayflowUkTest < Test::Unit::TestCase
-  def setup
-    ActiveMerchant::Billing::Base.gateway_mode = :test
-
-    # The default partner is PayPalUk
-    @gateway = PayflowUkGateway.new(fixtures(:payflow_uk))
-    
-    @creditcard = CreditCard.new(
-      :number => '5105105105105100',
-      :month => 11,
-      :year => 2009,
-      :first_name => 'Cody',
-      :last_name => 'Fauser',
-      :verification_value => '000',
-      :type => 'master'
-    )
-    
-    @solo = CreditCard.new(
-      :type   => "solo",
-      :number => "6334900000000005",
-      :month  => Time.now.month,
-      :year   => Time.now.year + 1,
-      :first_name  => "Test",
-      :last_name   => "Mensch",
-      :issue_number => '01'
-    )
-    
-    @switch = CreditCard.new(
-       :type                => "switch",
-       :number              => "5641820000000005",
-       :verification_value => "000",
-       :month               => 1,
-       :year                => 2008,
-       :first_name          => 'Fred',
-       :last_name           => 'Brooks'
-      )
-
-    @options = { 
-      :billing_address => {
-         :name => 'Cody Fauser',
-         :address1 => '1234 Shady Brook Lane',
-         :city => 'Ottawa',
-         :state => 'ON',
-         :country => 'CA',
-         :zip => '90210',
-         :phone => '555-555-5555'
-      },
-      :email => 'cody@example.com'
-    }
-  end
-  
-  def test_successful_purchase
-    assert response = @gateway.purchase(100000, @creditcard, @options)
-    assert_equal "Approved", response.message
-    assert_success response
-    assert response.test?
-    assert_not_nil response.authorization
-  end
-  
-  def test_declined_purchase
-    assert response = @gateway.purchase(210000, @creditcard, @options)
-    assert_equal 'Failed merchant rule check', response.message
-    assert_failure response
-    assert response.test?
-  end
-  
-  def test_successful_purchase_solo
-     assert response = @gateway.purchase(100000, @solo, @options)
-     assert_equal "Approved", response.message
-     assert_success response
-     assert response.test?
-     assert_not_nil response.authorization
-   end
-  
-  def test_no_card_issue_or_card_start_with_switch
-    assert response = @gateway.purchase(100000, @switch, @options)
-    assert_failure response
-    
-    assert_equal "Field format error: CARDSTART or CARDISSUE must be present", response.message
-    assert_failure response
-    assert response.test?
-  end
-  
-  def test_successful_purchase_switch_with_issue_number
-    @switch.issue_number = '01'
-    assert response = @gateway.purchase(100000, @switch, @options)
-    assert_equal "Approved", response.message
-    assert_success response
-    assert response.test?
-    assert_not_nil response.authorization
-  end
-  
-  def test_successful_purchase_switch_with_start_date
-    @switch.start_month = 12
-    @switch.start_year = 1999
-    assert response = @gateway.purchase(100000, @switch, @options)
-    assert_equal "Approved", response.message
-    assert_success response
-    assert response.test?
-    assert_not_nil response.authorization
-  end
-  
-  def test_successful_purchase_switch_with_start_date_and_issue_number
-    @switch.issue_number = '05'
-    @switch.start_month = 12
-    @switch.start_year = 1999
-    assert response = @gateway.purchase(100000, @switch, @options)
-    assert_equal "Approved", response.message
-    assert_success response
-    assert response.test?
-    assert_not_nil response.authorization
-  end
-  
-  def test_successful_authorization
-    assert response = @gateway.authorize(100, @creditcard, @options)
-    assert_equal "Approved", response.message
-    assert_success response
-    assert response.test?
-    assert_not_nil response.authorization
-  end
-
-  def test_authorize_and_capture
-    amount = 100
-    assert auth = @gateway.authorize(amount, @creditcard, @options)
-    assert_success auth
-    assert_equal 'Approved', auth.message
-    assert auth.authorization
-    assert capture = @gateway.capture(amount, auth.authorization)
-    assert_success capture
-  end
-  
-  def test_failed_capture
-    assert response = @gateway.capture(100, '999')
-    assert_failure response
-    assert_equal 'Invalid tender', response.message
-  end
-  
-  def test_authorize_and_void
-    assert auth = @gateway.authorize(100, @creditcard, @options)
-    assert_success auth
-    assert_equal 'Approved', auth.message
-    assert auth.authorization
-    assert void = @gateway.void(auth.authorization)
-    assert_success void
-  end
-  
-  def test_invalid_login
-    gateway = PayflowGateway.new(
-      :login => '',
-      :password => ''
-    )
-    assert response = gateway.purchase(100, @creditcard, @options)
-    assert_equal 'Invalid vendor account', response.message
-    assert_failure response
-  end
-  
-  def test_duplicate_request_id
-    gateway = PayflowUkGateway.new(
-      :login => @login,
-      :password => @password
-    )
-    
-    request_id = Digest::SHA1.hexdigest(rand.to_s).slice(0,32)
-    gateway.expects(:generate_unique_id).times(2).returns(request_id)
-    
-    response1 = gateway.purchase(100, @creditcard, @options)
-    assert_nil response1.params['duplicate']
-    response2 = gateway.purchase(100, @creditcard, @options)
-    assert response2.params['duplicate']
-  end
-end

data/test/remote/gateways/remote_payment_express_test.rb

@@ -1,136 +0,0 @@
-require 'test_helper'
-
-class RemotePaymentExpressTest < Test::Unit::TestCase
-
-  def setup
-    @gateway = PaymentExpressGateway.new(fixtures(:payment_express))
-    
-    @credit_card = credit_card('4111111111111111')
-
-    @options = { 
-      :order_id => generate_unique_id,
-      :billing_address => address,
-      :email => 'cody@example.com',
-      :description => 'Store purchase'
-    }
-    
-    @amount = 100
-  end
-  
-  def test_successful_purchase
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-    assert_equal "APPROVED", response.message
-    assert_success response
-    assert_not_nil response.authorization
-  end
-  
-  def test_successful_purchase_with_reference_id
-    assert response = @gateway.purchase(@amount, @credit_card, @options)
-    assert_equal "APPROVED", response.message
-    assert_success response
-    assert_not_nil response.authorization
-  end
-  
-  def test_declined_purchase
-    assert response = @gateway.purchase(176, @credit_card, @options)
-    assert_equal 'DECLINED', response.message
-    assert_failure response
-  end
-  
-  def test_successful_authorization
-    assert response = @gateway.authorize(@amount, @credit_card, @options)
-    assert_equal "APPROVED", response.message
-    assert_success response
-    assert_not_nil response.authorization
-  end
-
-  def test_authorize_and_capture
-    assert auth = @gateway.authorize(@amount, @credit_card, @options)
-    assert_success auth
-    assert_equal 'APPROVED', auth.message
-    assert auth.authorization
-    assert capture = @gateway.capture(@amount, auth.authorization)
-    assert_success capture
-  end
-  
-  def test_purchase_and_credit
-    amount = 10000
-    assert purchase = @gateway.purchase(amount, @credit_card, @options)
-    assert_success purchase
-    assert_equal 'APPROVED', purchase.message
-    assert !purchase.authorization.blank?
-    assert credit = @gateway.credit(amount, purchase.authorization, :description => "Giving a refund")
-    assert_success credit
-  end
-  
-  def test_failed_capture
-    assert response = @gateway.capture(@amount, '999')
-    assert_failure response
-    assert_equal 'IVL DPSTXNREF', response.message
-  end
-  
-  def test_invalid_login
-    gateway = PaymentExpressGateway.new(
-      :login => '',
-      :password => ''
-    )
-    assert response = gateway.purchase(@amount, @credit_card, @options)
-    assert_equal 'Invalid Credentials', response.message
-    assert_failure response
-  end
-  
-  def test_store_credit_card
-    assert response = @gateway.store(@credit_card)
-    assert_success response
-    assert_equal "APPROVED", response.message
-    assert !response.token.blank?
-    assert_not_nil response.token
-  end
-  
-  def test_store_with_custom_token
-    token = Time.now.to_i.to_s #hehe
-    assert response = @gateway.store(@credit_card, :billing_id => token)
-    assert_success response
-    assert_equal "APPROVED", response.message
-    assert !response.token.blank?
-    assert_not_nil response.token
-    assert_equal token, response.token
-  end
-  
-  def test_store_invalid_credit_card
-    original_number = @credit_card.number
-    @credit_card.number = 2
-  
-    assert response = @gateway.store(@credit_card)
-    assert_failure response
-  ensure
-    @credit_card.number = original_number
-  end
-  
-  def test_store_and_charge
-    assert response = @gateway.store(@credit_card)
-    assert_success response
-    assert_equal "APPROVED", response.message
-    assert (token = response.token)
-    
-    assert purchase = @gateway.purchase( @amount, token)
-    assert_equal "APPROVED", purchase.message
-    assert_success purchase
-    assert_not_nil purchase.authorization
-  end
-  
-  def test_store_and_authorize_and_capture
-    assert response = @gateway.store(@credit_card)
-    assert_success response
-    assert_equal "APPROVED", response.message
-    assert (token = response.token)
-
-    assert auth = @gateway.authorize(@amount, token, @options)
-    assert_success auth
-    assert_equal 'APPROVED', auth.message
-    assert auth.authorization
-    assert capture = @gateway.capture(@amount, auth.authorization)
-    assert_success capture
-  end
-  
-end

data/test/remote/gateways/remote_paypal_express_test.rb

@@ -1,49 +0,0 @@
-require 'test_helper'
-
-class PaypalExpressTest < Test::Unit::TestCase
-  def setup
-    Base.gateway_mode = :test
-    
-    @gateway = PaypalExpressGateway.new(fixtures(:paypal_certificate))
-  
-    @options = {
-      :order_id => '230000',
-      :email => 'buyer@jadedpallet.com',
-      :billing_address => { :name => 'Fred Brooks',
-                    :address1 => '1234 Penny Lane',
-                    :city => 'Jonsetown',
-                    :state => 'NC',
-                    :country => 'US',
-                    :zip => '23456'
-                  } ,
-      :description => 'Stuff that you purchased, yo!',
-      :ip => '10.0.0.1',
-      :return_url => 'http://example.com/return',
-      :cancel_return_url => 'http://example.com/cancel'
-    }
-  end
-  
-  def test_set_express_authorization
-    @options.update(
-      :return_url => 'http://example.com',
-      :cancel_return_url => 'http://example.com',
-      :email => 'Buyer1@paypal.com'
-    )
-    response = @gateway.setup_authorization(500, @options)
-    assert response.success?
-    assert response.test?
-    assert !response.params['token'].blank?
-  end
-  
-  def test_set_express_purchase
-    @options.update(
-      :return_url => 'http://example.com',
-      :cancel_return_url => 'http://example.com',
-      :email => 'Buyer1@paypal.com'
-    )
-    response = @gateway.setup_purchase(500, @options)
-    assert response.success?
-    assert response.test?
-    assert !response.params['token'].blank?
-  end
-end 

data/test/remote/gateways/remote_paypal_test.rb

@@ -1,191 +0,0 @@
-require 'test_helper'
-
-class PaypalTest < Test::Unit::TestCase
-  def setup
-    Base.gateway_mode = :test
-    
-    @gateway = PaypalGateway.new(fixtures(:paypal_certificate))
-
-    @creditcard = CreditCard.new(
-      :type                => "visa",
-      :number              => "4381258770269608", # Use a generated CC from the paypal Sandbox
-      :verification_value => "000",
-      :month               => 1,
-      :year                => Time.now.year + 1,
-      :first_name          => 'Fred',
-      :last_name           => 'Brooks'
-    )
-       
-    @params = {
-      :order_id => generate_unique_id,
-      :email => 'buyer@jadedpallet.com',
-      :billing_address => { :name => 'Fred Brooks',
-                    :address1 => '1234 Penny Lane',
-                    :city => 'Jonsetown',
-                    :state => 'NC',
-                    :country => 'US',
-                    :zip => '23456'
-                  } ,
-      :description => 'Stuff that you purchased, yo!',
-      :ip => '10.0.0.1'
-    }
-      
-    @amount = 100
-    # test re-authorization, auth-id must be more than 3 days old.
-    # each auth-id can only be reauthorized and tested once.
-    # leave it commented if you don't want to test reauthorization.
-    # 
-    #@three_days_old_auth_id  = "9J780651TU4465545" 
-    #@three_days_old_auth_id2 = "62503445A3738160X" 
-  end
-
-  def test_successful_purchase
-    response = @gateway.purchase(@amount, @creditcard, @params)
-    assert_success response
-    assert response.params['transaction_id']
-  end
-  
-  def test_successful_purchase_with_api_signature
-    gateway = PaypalGateway.new(fixtures(:paypal_signature))
-    response = gateway.purchase(@amount, @creditcard, @params)
-    assert_success response
-    assert response.params['transaction_id']
-  end
-  
-  def test_failed_purchase
-    @creditcard.number = '234234234234'
-    response = @gateway.purchase(@amount, @creditcard, @params)
-    assert_failure response
-    assert_nil response.params['transaction_id']
-  end
-
-  def test_successful_authorization
-    response = @gateway.authorize(@amount, @creditcard, @params)
-    assert_success response
-    assert response.params['transaction_id']
-    assert_equal '1.00', response.params['amount']
-    assert_equal 'USD', response.params['amount_currency_id']
-  end
-  
-  def test_failed_authorization
-    @creditcard.number = '234234234234'
-    response = @gateway.authorize(@amount, @creditcard, @params)
-    assert_failure response
-    assert_nil response.params['transaction_id']
-  end
-
-  def test_successful_reauthorization
-    return if not @three_days_old_auth_id
-    auth = @gateway.reauthorize(1000, @three_days_old_auth_id)
-    assert_success auth
-    assert auth.authorization
-    
-    response = @gateway.capture(1000, auth.authorization)
-    assert_success response
-    assert response.params['transaction_id']
-    assert_equal '10.00', response.params['gross_amount']
-    assert_equal 'USD', response.params['gross_amount_currency_id']
-  end
-  
-  def test_failed_reauthorization
-    return if not @three_days_old_auth_id2  # was authed for $10, attempt $20
-    auth = @gateway.reauthorize(2000, @three_days_old_auth_id2)
-    assert_false auth?
-    assert !auth.authorization
-  end
-      
-  def test_successful_capture
-    auth = @gateway.authorize(@amount, @creditcard, @params)
-    assert_success auth
-    response = @gateway.capture(@amount, auth.authorization)
-    assert_success response
-    assert response.params['transaction_id']
-    assert_equal '1.00', response.params['gross_amount']
-    assert_equal 'USD', response.params['gross_amount_currency_id']
-  end
-  
-  # NOTE THIS SETTING: http://skitch.com/jimmybaker/nysus/payment-receiving-preferences-paypal
-  # PayPal doesn't return the InvoiceID in the response, so I am unable to check for it. Looking at the transaction
-  # on PayPal's site will show "NEWID123" as the InvoiceID.
-  def test_successful_capture_updating_the_invoice_id
-    auth = @gateway.authorize(@amount, @creditcard, @params)
-    assert_success auth
-    response = @gateway.capture(@amount, auth.authorization, :order_id => "NEWID123")
-    assert_success response
-    assert response.params['transaction_id']
-    assert_equal '1.00', response.params['gross_amount']
-    assert_equal 'USD', response.params['gross_amount_currency_id']
-  end
-  
-  def test_successful_voiding
-    auth = @gateway.authorize(@amount, @creditcard, @params)
-    assert_success auth
-    response = @gateway.void(auth.authorization)
-    assert_success response
-  end
-  
-  def test_purchase_and_full_credit
-    purchase = @gateway.purchase(@amount, @creditcard, @params)
-    assert_success purchase
-    
-    credit = @gateway.credit(@amount, purchase.authorization, :note => 'Sorry')
-    assert_success credit
-    assert credit.test?
-    assert_equal 'USD',  credit.params['net_refund_amount_currency_id']
-    assert_equal '0.67', credit.params['net_refund_amount']
-    assert_equal 'USD',  credit.params['gross_refund_amount_currency_id']
-    assert_equal '1.00', credit.params['gross_refund_amount']
-    assert_equal 'USD',  credit.params['fee_refund_amount_currency_id']
-    assert_equal '0.33', credit.params['fee_refund_amount']
-  end
-  
-  def test_failed_voiding
-    response = @gateway.void('foo')
-    assert_failure response
-  end
-  
-  def test_successful_transfer
-    response = @gateway.purchase(@amount, @creditcard, @params)
-    assert_success response
-    
-    response = @gateway.transfer(@amount, 'joe@example.com', :subject => 'Your money', :note => 'Thanks for taking care of that')
-    assert_success response
-  end
-
-  def test_failed_transfer
-     # paypal allows a max transfer of $10,000
-    response = @gateway.transfer(1000001, 'joe@example.com')
-    assert_failure response
-  end
-  
-  def test_successful_multiple_transfer
-    response = @gateway.purchase(900, @creditcard, @params)
-    assert_success response
-    
-    response = @gateway.transfer([@amount, 'joe@example.com'],
-      [600, 'jane@example.com', {:note => 'Thanks for taking care of that'}],
-      :subject => 'Your money')
-    assert_success response
-  end
-  
-  def test_failed_multiple_transfer
-    response = @gateway.purchase(25100, @creditcard, @params)
-    assert_success response
-
-    # You can only include up to 250 recipients
-    recipients = (1..251).collect {|i| [100, "person#{i}@example.com"]}
-    response = @gateway.transfer(*recipients)
-    assert_failure response
-  end
-  
-  # Makes a purchase then makes another purchase adding $1.00 using just a reference id (transaction id)
-  def test_successful_referenced_id_purchase
-    response = @gateway.purchase(@amount, @creditcard, @params)
-    assert_success response
-    id_for_reference = response.params['transaction_id']
-    
-    @params.delete(:order_id)
-    response2 = @gateway.purchase(@amount + 100, id_for_reference, @params)
-    assert_success response2
-  end
-end