smulube-activemerchant 1.5.1.1 → 1.5.1.2

data/test/remote/gateways/remote_verifi_test.rb

@@ -0,0 +1,107 @@
+require 'test_helper'
+
+class VerifiTest < Test::Unit::TestCase
+  include ActiveMerchant::Billing
+
+  def setup
+    @gateway = VerifiGateway.new(fixtures(:verify))
+    
+    @credit_card = credit_card('4111111111111111')
+    
+    #  Replace with your login and password for the Verifi test environment
+    @options = {
+      :order_id => '37',
+      :email => "test@example.com",   
+      :billing_address => address
+    }
+    
+    @amount = 100
+  end
+  
+  def test_successful_purchase
+    assert response = @gateway.purchase(@amount, @credit_card, @options)
+    assert_success response
+    assert_equal 'Transaction was Approved', response.message
+    assert !response.authorization.blank?
+  end
+  
+  def test_unsuccessful_purchase
+    @credit_card.number = 'invalid'
+    
+    assert response = @gateway.purchase(@amount, @credit_card, @options)
+    assert_failure response
+    assert_equal 'Transaction was Rejected by Gateway', response.message
+  end
+  
+  # FOR SOME REASON Verify DOESN'T MIND EXPIRED CARDS
+  # I talked to support and they said that they are loose on expiration dates being expired.
+  def test_expired_credit_card
+    @credit_card.year = (Time.now.year - 3) 
+    assert response = @gateway.purchase(@amount, @credit_card, @options)
+    assert_success response
+    assert_equal 'Transaction was Approved', response.message   
+  end
+    
+  def test_successful_authorization
+    assert response = @gateway.authorize(@amount, @credit_card, @options)
+    assert_success response
+    assert_equal 'Transaction was Approved', response.message
+    assert response.authorization
+  end
+  
+  def test_authorization_and_capture
+    assert authorization = @gateway.authorize(@amount, @credit_card, @options)
+    assert_success authorization
+    assert authorization
+    assert capture = @gateway.capture(@amount, authorization.authorization, @options)  
+    assert_success capture
+    assert_equal 'Transaction was Approved', capture.message
+  end
+  
+  def test_authorization_and_void
+    assert authorization = @gateway.authorize(@amount, @credit_card, @options)
+    assert_success authorization
+    assert authorization
+    assert void = @gateway.void(authorization.authorization, @options)
+    assert_success void
+    assert_equal 'Transaction was Approved', void.message
+  end
+  
+  # Credits are not enabled on test accounts, so this should always fail  
+  def test_credit
+    assert response = @gateway.credit(@amount, @credit_card, @options)
+    assert_match /Credits are not enabled/, response.params['responsetext']
+    assert_failure response  
+  end
+  
+  def test_authorization_and_void
+    assert authorization = @gateway.authorize(@amount, @credit_card, @options)
+    assert_success authorization
+    assert void = @gateway.void(authorization.authorization, @options)
+    assert_success void
+    assert_equal 'Transaction was Approved', void.message
+    assert_match /Transaction Void Successful/, void.params['responsetext']
+  end
+  
+  def test_purchase_and_credit
+    assert purchase = @gateway.purchase(@amount, @credit_card, @options)
+    assert_success purchase
+    
+    assert credit = @gateway.credit(@amount, purchase.authorization, @options)
+    assert_success credit
+    assert_equal 'Transaction was Approved', credit.message
+  end
+  
+  def test_bad_login
+    gateway = VerifiGateway.new(
+      :login => 'X',
+      :password => 'Y'
+    )
+    
+    assert response = gateway.purchase(@amount, @credit_card, @options)
+    assert_equal 'Transaction was Rejected by Gateway', response.message
+    assert_equal 'Authentication Failed', response.params['responsetext']
+    
+    assert_failure response
+  end
+end

data/test/remote/gateways/remote_viaklix_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+class RemoteViaklixTest < Test::Unit::TestCase
+  def setup
+    @gateway = ViaklixGateway.new(fixtures(:viaklix))
+    
+    @credit_card = credit_card    
+    @bad_credit_card = credit_card('invalid')
+    
+    @options = {
+      :order_id => '#1000.1',
+      :email => "paul@domain.com",   
+      :description => 'Test Transaction',
+      :billing_address => address
+    }
+    @amount = 100
+  end
+  
+  def test_successful_purchase
+    assert response = @gateway.purchase(@amount, @credit_card, @options)
+    
+    assert_success response
+    assert response.test?
+    assert_equal 'APPROVED', response.message
+    assert response.authorization
+  end
+  
+  def test_failed_purchase
+    assert response = @gateway.purchase(@amount, @bad_credit_card, @options)
+  
+    assert_failure response
+    assert response.test?
+    assert_equal 'The Credit Card Number supplied in the authorization request appears invalid.', response.message
+  end
+  
+  def test_credit
+    assert purchase = @gateway.purchase(@amount, @credit_card, @options)
+    assert_success purchase
+    
+    assert credit = @gateway.credit(@amount, @credit_card)
+    assert_success credit
+  end
+end

data/test/remote/gateways/remote_wirecard_test.rb

@@ -0,0 +1,111 @@
+require File.join(File.dirname(__FILE__), '../../test_helper')
+
+class RemoteWirecardTest < Test::Unit::TestCase
+
+
+  def setup
+    test_account = fixtures(:wirecard)
+    test_account[:signature] = test_account[:login]
+    @gateway = WirecardGateway.new(test_account)
+
+    @amount = 100
+    @credit_card = credit_card('4200000000000000')
+    @declined_card = credit_card('4000300011112220')
+
+    @options = {
+      :order_id => 1,
+      :billing_address => address,
+      :description => 'Wirecard remote test purchase',
+      :email => 'soleone@example.com'
+    }
+    
+    @german_address = {
+      :name     => 'Jim Deutsch',
+      :address1 => '1234 Meine Street',
+      :company  => 'Widgets Inc',
+      :city     => 'Koblenz',
+      :state    => 'Rheinland-Pfalz',
+      :zip      => '56070',
+      :country  => 'DE',
+      :phone    => '0261 12345 23',
+      :fax      => '0261 12345 23-4'
+    }
+  end
+
+  # Success tested
+  def test_successful_authorization
+    assert response = @gateway.authorize(@amount, @credit_card, @options)
+    assert_success response
+    assert response.test?
+    assert response.message[/THIS IS A DEMO/]
+    assert response.authorization
+  end
+
+  def test_successful_authorize_and_capture
+    amount = @amount
+    assert auth = @gateway.authorize(amount, @credit_card, @options)
+    assert_success auth
+    assert auth.message[/THIS IS A DEMO/]
+    assert auth.authorization
+    assert capture = @gateway.capture(amount, auth.authorization, @options)
+    assert_success capture
+  end
+
+  def test_successful_purchase
+    assert response = @gateway.purchase(@amount, @credit_card, @options)
+    # puts response.message
+    assert_success response
+    assert response.message[/THIS IS A DEMO/]
+  end
+  
+  def test_successful_purchase_with_german_address_german_state_and_german_phone
+    assert response = @gateway.purchase(@amount, @credit_card, @options.merge(:billing_address => @german_address))
+
+    assert_success response
+    assert response.message[/THIS IS A DEMO/]
+  end
+    
+  def test_successful_purchase_with_german_address_no_state_and_invalid_phone
+    assert response = @gateway.purchase(@amount, @credit_card, @options.merge(:billing_address => @german_address.merge({:state => nil, :phone => '1234'})))
+
+    assert_success response
+    assert response.message[/THIS IS A DEMO/]
+  end
+  
+  def test_successful_purchase_with_german_address_and_valid_phone
+    assert response = @gateway.purchase(@amount, @credit_card, @options.merge(:billing_address => @german_address.merge({:phone => '+049-261-1234-123'})))
+  
+    assert_success response
+    assert response.message[/THIS IS A DEMO/]
+  end
+
+  # Failure tested
+
+  def test_wrong_creditcard_authorization
+    assert response = @gateway.authorize(@amount, @declined_card, @options)  
+    assert_failure response
+    assert response.test?
+    assert response.message[/credit card number not allowed in demo mode/i]
+  end
+
+  def test_wrong_creditcard_purchase
+    assert response = @gateway.purchase(@amount, @declined_card, @options)
+    assert response.test?
+    assert_failure response
+    assert response.message[ /Credit card number not allowed in demo mode/ ], "Got wrong response message"
+  end
+  
+  def test_unauthorized_capture
+    assert response = @gateway.capture(@amount, "1234567890123456789012")
+    assert_failure response
+    assert_equal "Could not find referenced transaction for GuWID 1234567890123456789012.", response.message
+  end
+
+  def test_invalid_login
+    gateway = WirecardGateway.new(:login => '', :password => '', :signature => '')
+    assert response = gateway.purchase(@amount, @credit_card, @options)
+    assert_failure response
+    assert response.message[ /wrong credentials/ ]
+  end
+  
+end

data/test/remote/integrations/remote_gestpay_integration_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+class RemoteGestpayIntegrationTest < Test::Unit::TestCase
+  include ActiveMerchant::Billing::Integrations
+
+  def setup
+    # Your Gestpay ShopLogin
+    @shop_login = 'SHOPLOGIN'
+    
+    @helper = Gestpay::Helper.new('order-500', @shop_login, :amount => '5.00', :currency => 'EUR')
+  end
+
+  def test_get_encryption_string
+    # Extra fields don't work yet
+    # @helper.customer :first_name => 'Cody', :last_name => 'Fauser', :email => 'codyfauser@gmail.com'
+    response = @helper.send(:get_encrypted_string)
+    assert !response.blank?
+  end
+  
+  def test_get_encryption_string_fails
+    @helper = Gestpay::Helper.new('order-500','99999999', :amount => '5.00', :currency => 'EUR')
+    assert_raise(StandardError) do
+      assert @helper.send(:get_encrypted_string).blank?
+    end
+  end
+  
+  def test_unknown_shop_for_decryption_request
+    assert_raise(StandardError) do 
+      Gestpay::Notification.new(raw_query_string)
+    end
+  end
+  
+  private
+  def raw_query_string
+    "a=900000&b=F7DEB36478FD84760F9134F23C922697272D57DE6D4518EB9B4D468B769D9A3A8071B6EB160B35CB412FC1820C7CC12D17B3141855B1ED55468613702A2E213DDE9DE5B0209E13C416448AE833525959F05693172D7F0656"
+  end
+end

data/test/remote/integrations/remote_paypal_integration_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+class RemotePaypalIntegrationTest < Test::Unit::TestCase
+  include ActiveMerchant::Billing::Integrations
+
+  def setup
+    @paypal = Paypal::Notification.new('')
+  end
+
+  def tear_down
+    ActiveMerchant::Billing::Base.integration_mode = :test
+  end
+  
+  def test_raw
+    assert_equal "https://www.sandbox.paypal.com/cgi-bin/webscr", Paypal.service_url
+    assert_nothing_raised do
+      assert_equal false, @paypal.acknowledge
+    end
+  end
+  
+  def test_valid_sender_always_true
+    ActiveMerchant::Billing::Base.integration_mode = :production
+    assert @paypal.valid_sender?(nil)
+    assert @paypal.valid_sender?('127.0.0.1')
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,184 @@
+#!/usr/bin/env ruby
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rubygems'
+require 'test/unit'
+require 'money'
+require 'mocha'
+require 'yaml'
+require 'active_merchant'
+
+begin
+  gem 'actionpack'
+rescue LoadError
+  raise StandardError, "The view tests need ActionPack installed as gem to run"
+end
+
+require 'action_controller'
+require 'action_controller/test_process'
+require 'active_merchant/billing/integrations/action_view_helper'
+
+ActiveMerchant::Billing::Base.mode = :test
+
+# Test gateways
+class SimpleTestGateway < ActiveMerchant::Billing::Gateway
+end
+
+class SubclassGateway < SimpleTestGateway
+end
+
+
+module ActiveMerchant
+  module Assertions
+    AssertionClass = RUBY_VERSION > '1.9' ? MiniTest::Assertion : Test::Unit::AssertionFailedError
+    
+    def assert_field(field, value)
+      clean_backtrace do 
+        assert_equal value, @helper.fields[field]
+      end
+    end
+    
+    # Allows the testing of you to check for negative assertions: 
+    # 
+    #   # Instead of
+    #   assert !something_that_is_false
+    # 
+    #   # Do this
+    #   assert_false something_that_should_be_false
+    # 
+    # An optional +msg+ parameter is available to help you debug.
+    def assert_false(boolean, message = nil)
+      message = build_message message, '<?> is not false or nil.', boolean
+    
+      clean_backtrace do
+        assert_block message do
+          not boolean
+        end
+      end
+    end
+    
+    # A handy little assertion to check for a successful response: 
+    # 
+    #   # Instead of
+    #   assert_success response
+    # 
+    #   # DRY that up with
+    #   assert_success response
+    # 
+    # A message will automatically show the inspection of the response 
+    # object if things go afoul.
+    def assert_success(response)
+      clean_backtrace do
+        assert response.success?, "Response failed: #{response.inspect}"
+      end
+    end
+    
+    # The negative of +assert_success+
+    def assert_failure(response)
+      clean_backtrace do
+        assert_false response.success?, "Response expected to fail: #{response.inspect}"
+      end
+    end
+    
+    def assert_valid(validateable)
+      clean_backtrace do
+        assert validateable.valid?, "Expected to be valid"
+      end
+    end
+    
+    def assert_not_valid(validateable)
+      clean_backtrace do
+        assert_false validateable.valid?, "Expected to not be valid"
+      end
+    end
+    
+    private
+    def clean_backtrace(&block)
+      yield    
+    rescue AssertionClass => e
+      path = File.expand_path(__FILE__)
+      raise AssertionClass, e.message, e.backtrace.reject { |line| File.expand_path(line) =~ /#{path}/ }
+    end
+  end
+  
+  module Fixtures
+    HOME_DIR = RUBY_PLATFORM =~ /mswin32/ ? ENV['HOMEPATH'] : ENV['HOME'] unless defined?(HOME_DIR)
+    LOCAL_CREDENTIALS = File.join(HOME_DIR.to_s, '.active_merchant/fixtures.yml') unless defined?(LOCAL_CREDENTIALS)
+    DEFAULT_CREDENTIALS = File.join(File.dirname(__FILE__), 'fixtures.yml') unless defined?(DEFAULT_CREDENTIALS)
+    
+    private
+    def credit_card(number = '4242424242424242', options = {})
+      defaults = {
+        :number => number,
+        :month => 9,
+        :year => Time.now.year + 1,
+        :first_name => 'Longbob',
+        :last_name => 'Longsen',
+        :verification_value => '123',
+        :type => 'visa'
+      }.update(options)
+
+      Billing::CreditCard.new(defaults)
+    end
+    
+    def check(options = {})
+      defaults = {
+        :name => 'Jim Smith',
+        :routing_number => '244183602', 
+        :account_number => '15378535', 
+        :account_holder_type => 'personal', 
+        :account_type => 'checking', 
+        :number => '1'
+      }.update(options)
+      
+      Billing::Check.new(defaults)
+    end
+    
+    def address(options = {})
+      { 
+        :name     => 'Jim Smith',
+        :address1 => '1234 My Street',
+        :address2 => 'Apt 1',
+        :company  => 'Widgets Inc',
+        :city     => 'Ottawa',
+        :state    => 'ON',
+        :zip      => 'K1C2N6',
+        :country  => 'CA',
+        :phone    => '(555)555-5555',
+        :fax      => '(555)555-6666'
+      }.update(options)
+    end
+    
+    def all_fixtures
+      @@fixtures ||= load_fixtures
+    end
+    
+    def fixtures(key)
+      data = all_fixtures[key] || raise(StandardError, "No fixture data was found for '#{key}'")
+      
+      data.dup
+    end
+        
+    def load_fixtures
+      file = File.exists?(LOCAL_CREDENTIALS) ? LOCAL_CREDENTIALS : DEFAULT_CREDENTIALS
+      yaml_data = YAML.load(File.read(file))
+      symbolize_keys(yaml_data)
+    
+      yaml_data
+    end
+    
+    def symbolize_keys(hash)
+      return unless hash.is_a?(Hash)
+      
+      hash.symbolize_keys!
+      hash.each{|k,v| symbolize_keys(v)}
+    end
+  end
+end
+
+Test::Unit::TestCase.class_eval do
+  include ActiveMerchant::Billing
+  include ActiveMerchant::Assertions
+  include ActiveMerchant::Utils
+  include ActiveMerchant::Fixtures
+end

data/test/unit/avs_result_test.rb

@@ -0,0 +1,59 @@
+require 'test_helper'
+
+class AVSResultTest < Test::Unit::TestCase
+  def test_nil
+    result = AVSResult.new(nil)
+  end
+  
+  def test_no_match
+    result = AVSResult.new(:code => 'N')
+    assert_equal 'N', result.code
+    assert_equal 'N', result.street_match
+    assert_equal 'N', result.postal_match
+    assert_equal AVSResult.messages['N'], result.message
+  end
+  
+  def test_only_street_match
+    result = AVSResult.new(:code => 'A')
+    assert_equal 'A', result.code
+    assert_equal 'Y', result.street_match
+    assert_equal 'N', result.postal_match
+    assert_equal AVSResult.messages['A'], result.message
+  end
+  
+  def test_only_postal_match
+    result = AVSResult.new(:code => 'W')
+    assert_equal 'W', result.code
+    assert_equal 'N', result.street_match
+    assert_equal 'Y', result.postal_match
+    assert_equal AVSResult.messages['W'], result.message
+  end
+  
+  def test_nil_data
+    result = AVSResult.new(:code => nil)
+    assert_nil result.code
+    assert_nil result.message
+  end
+  
+  def test_empty_data
+    result = AVSResult.new(:code => '')
+    assert_nil result.code
+    assert_nil result.message
+  end
+  
+  def test_to_hash
+    avs_data = AVSResult.new(:code => 'X').to_hash
+    assert_equal 'X', avs_data['code']
+    assert_equal AVSResult.messages['X'], avs_data['message']
+  end
+  
+  def test_street_match
+    avs_data = AVSResult.new(:street_match => 'Y')
+    assert_equal 'Y', avs_data.street_match
+  end
+  
+  def test_postal_match
+    avs_data = AVSResult.new(:postal_match => 'Y')
+    assert_equal 'Y', avs_data.postal_match
+  end
+end

data/test/unit/base_test.rb

@@ -0,0 +1,54 @@
+require 'test_helper'
+
+class BaseTest < Test::Unit::TestCase
+  def setup
+    ActiveMerchant::Billing::Base.mode = :test
+  end
+  
+  def teardown
+    ActiveMerchant::Billing::Base.mode = :test
+  end
+  
+  def test_should_return_a_new_gateway_specified_by_symbol_name
+    assert_equal BogusGateway,         Base.gateway(:bogus)
+    assert_equal MonerisGateway,       Base.gateway(:moneris) 
+    assert_equal AuthorizeNetGateway,  Base.gateway(:authorize_net)
+    assert_equal UsaEpayGateway,       Base.gateway(:usa_epay)
+    assert_equal LinkpointGateway,     Base.gateway(:linkpoint)
+  end
+
+  def test_should_return_an_integration_by_name
+    chronopay = Base.integration(:chronopay)
+    
+    assert_equal Integrations::Chronopay, chronopay
+    assert_instance_of Integrations::Chronopay::Notification, chronopay.notification('name=cody')
+  end
+
+  def test_should_set_modes
+    Base.mode = :test
+    assert_equal :test, Base.mode
+    assert_equal :test, Base.gateway_mode
+    assert_equal :test, Base.integration_mode
+
+    Base.mode = :production
+    assert_equal :production, Base.mode
+    assert_equal :production, Base.gateway_mode
+    assert_equal :production, Base.integration_mode
+
+    Base.mode             = :development
+    Base.gateway_mode     = :test
+    Base.integration_mode = :staging
+    assert_equal :development, Base.mode
+    assert_equal :test,        Base.gateway_mode
+    assert_equal :staging,     Base.integration_mode
+  end
+  
+  def test_should_identify_if_test_mode
+    Base.gateway_mode = :test
+    assert Base.test?
+    
+    Base.gateway_mode = :production
+    assert_false Base.test?
+  end
+
+end