hps 1.0.1

data/tests/secret_key.rb

@@ -0,0 +1,12 @@
+require File.join( File.dirname(__FILE__), "test_helper" )
+
+describe "Secret Key Tests" do
+  
+  it "can charge with secret key" do
+    Hps::TestHelper.configure_hps_module_secret_key()
+    service = Hps::HpsChargeService.new()
+    charge = service.charge(1.00, "usd", Hps::TestData.valid_visa, Hps::TestData.valid_cardholder)
+    expect(charge.response_code).to eql("00")
+  end
+  
+end

data/tests/test_data.rb

@@ -0,0 +1,128 @@
+require 'hps'
+
+module Hps
+  module TestData
+  
+    # card holders
+  
+    def self.valid_cardholder
+      result = HpsCardHolder.new()
+      result.first_name = "Bill"
+      result.last_name = "Johnson"
+      result.address = HpsAddress.new
+      result.address.address = "One Heartland Way"
+      result.address.city = "Jeffersonville"
+      result.address.state = "IN"
+      result.address.zip = "47130"
+      result.address.country = "United States"
+      result
+    end
+  
+    def self.cert_cardholder_shortzip
+      result = HpsCardHolder.new()
+      result.first_name = "Bill"
+      result.last_name = "Johnson"
+      result.address = HpsAddress.new
+      result.address.address = "6860 Dallas Pkwy"
+      result.address.city = "Irvine"
+      result.address.state = "TX"
+      result.address.zip = "75024"
+      result.address.country = "United States"    
+      result    
+    end
+  
+    def self.cert_cardholder_shortzip_no_street
+      result = HpsCardHolder.new()
+      result.first_name = "Bill"
+      result.last_name = "Johnson"
+      result.address = HpsAddress.new
+      result.address.city = "Irvine"
+      result.address.state = "TX"
+      result.address.zip = "75024"
+      result.address.country = "United States"    
+      result    
+    end
+  
+    def self.cert_cardholder_longzip
+      result = HpsCardHolder.new()
+      result.first_name = "Bill"
+      result.last_name = "Johnson"
+      result.address = HpsAddress.new
+      result.address.address = "6860 Dallas Pkwy"
+      result.address.city = "Irvine"
+      result.address.state = "TX"
+      result.address.zip = "750241234"
+      result.address.country = "United States"    
+      result    
+    end
+  
+    def self.cert_cardholder_longzip_no_street
+      result = HpsCardHolder.new()
+      result.first_name = "Bill"
+      result.last_name = "Johnson"
+      result.address = HpsAddress.new
+      result.address.city = "Irvine"
+      result.address.state = "TX"
+      result.address.zip = "750241234"
+      result.address.country = "United States"    
+      result    
+    end
+  
+    # credit cards
+  
+    def self.valid_visa
+      result = HpsCreditCard.new
+      result.cvv = 123
+      result.exp_month = 12
+      result.exp_year = 2015
+      result.number = 4012002000060016
+      result
+    end
+  
+    def self.valid_mastercard
+      result = HpsCreditCard.new
+      result.cvv = 123
+      result.exp_month = 12
+      result.exp_year = 2015
+      result.number = 5473500000000014
+      result
+    end
+  
+    def self.valid_discover
+      result = HpsCreditCard.new
+      result.cvv = 123
+      result.exp_month = 12
+      result.exp_year = 2015
+      result.number = 6011000990156527
+      result
+    end
+  
+    def self.valid_amex
+      result = HpsCreditCard.new
+      result.cvv = 1234
+      result.exp_month = 12
+      result.exp_year = 2015
+      result.number = 372700699251018
+      result
+    end
+  
+    def self.valid_jcb
+      result = HpsCreditCard.new
+      result.cvv = 123
+      result.exp_month = 12
+      result.exp_year = 2015
+      result.number = 3566007770007321
+      result
+    end
+  
+    def self.invalid_card
+      result = HpsCreditCard.new
+      result.cvv = 123
+      result.exp_month = 12
+      result.exp_year = 2015
+      result.number = 12345
+      result
+    end
+  
+  end
+end

data/tests/test_helper.rb

@@ -0,0 +1,92 @@
+require File.join( File.dirname(__FILE__), "test_data.rb" )
+require "hps"
+require "rspec"
+
+module Hps
+  module TestHelper
+  
+    def self.configure_hps_module
+      Hps.configure do |config|
+        config.secret_api_key = "skapi_cert_MYl2AQAowiQAbLp5JesGKh7QFkcizOP2jcX9BrEMqQ"
+      end    
+    end
+    
+
+    def self.configure_hps_module_secret_key
+      Hps.configure do |config|
+        config.secret_api_key = "skapi_cert_MYl2AQAowiQAbLp5JesGKh7QFkcizOP2jcX9BrEMqQ"
+      end    
+    end
+    
+    def self.configure_hps_module_for_certification
+      Hps.configure do |config|
+        config.secret_api_key = "skapi_cert_MYl2AQAowiQAbLp5JesGKh7QFkcizOP2jcX9BrEMqQ"
+      end    
+    end
+  
+    def self.charge_valid_amex(amount)
+      TestHelper.configure_hps_module()
+      service = Hps::HpsChargeService.new()
+      service.charge(amount, "usd", TestData.valid_amex, TestData.valid_cardholder)
+    end
+    
+    def self.charge_valid_discover(amount)
+      TestHelper.configure_hps_module()
+      service = Hps::HpsChargeService.new()
+      service.charge(amount, "usd", TestData.valid_discover, TestData.valid_cardholder)
+    end
+    
+    def self.charge_valid_mastercard(amount)
+      TestHelper.configure_hps_module()
+      service = Hps::HpsChargeService.new()
+      service.charge(amount, "usd", TestData.valid_mastercard, TestData.valid_cardholder)
+    end
+    
+    def self.charge_valid_visa(amount)
+      TestHelper.configure_hps_module()
+      service = Hps::HpsChargeService.new()
+      service.charge(amount, "usd", TestData.valid_visa, TestData.valid_cardholder)
+    end
+
+    def self.charge_token(token_value,multi_use=false)
+      TestHelper.valid_multi_use_config
+      service = Hps::HpsChargeService.new()
+      service.charge(50, "usd", token_value, TestData.valid_cardholder,multi_use)
+    end
+
+    def self.auth_token(token_value,multi_use=false)
+      TestHelper.valid_multi_use_config
+      service = Hps::HpsChargeService.new()
+      service.authorize(50, "usd", token_value, TestData.valid_cardholder,multi_use)
+    end
+
+    def self.verify_token(token_value,multi_use=false)
+      TestHelper.valid_multi_use_config
+      service = Hps::HpsChargeService.new()
+      service.verify(token_value, TestData.valid_cardholder,multi_use)
+    end
+
+    def self.refund_token(token_value)
+      TestHelper.valid_multi_use_config
+      service = Hps::HpsChargeService.new()
+      service.refund(50,'usd',token_value, TestData.valid_cardholder)
+    end
+
+    def self.reverse_token(token_value)
+      TestHelper.valid_multi_use_config
+      service = Hps::HpsChargeService.new()
+      service.reverse(token_value,50,'usd')
+    end
+
+    def self.valid_multi_use_public_key
+      'pkapi_cert_P6dRqs1LzfWJ6HgGVZ'
+    end
+
+    def self.valid_multi_use_config
+      Hps.configure do |config|
+        config.secret_api_key ='skapi_cert_MYl2AQAowiQAbLp5JesGKh7QFkcizOP2jcX9BrEMqQ'
+      end
+    end
+  
+  end
+end

data/tests/token_tests.rb

@@ -0,0 +1,513 @@
+require File.join( File.dirname(__FILE__), 'test_helper' )
+require File.join( File.dirname(__FILE__), 'hps_token_service')
+require File.join( File.dirname(__FILE__), 'test_data' )
+
+describe 'token_tests' do
+
+  let(:public_key) { Hps::TestHelper.valid_multi_use_public_key}
+  let(:token_service) { Hps::HpsTokenService.new(public_key) }
+
+
+  #Basic single token fetching tests
+
+  it 'Should return a one time use token' do
+    token_response = token_service.get_token(Hps::TestData.valid_visa)
+    token_response['token_value'].should_not eq(nil)
+    token_response['token_value'].should include('supt')
+  end
+
+  it 'Should fail getting a token due to bad key' do
+    expect { Hps::HpsTokenService.new('bad_key') }.to raise_error('Public API Key must contain at least two underscores')
+  end
+
+  it 'Should fail getting an empty JSON response due to bad key' do
+    token_service = Hps::HpsTokenService.new('Still_bad_key')
+    expect { token_service.get_token(Hps::TestData.valid_visa) }.to raise_error('A JSON text must at least contain two octets!')
+  end
+
+  it 'Should fail and return an Error Card not Recognized' do
+    card = Hps::TestData.valid_visa
+    card.number = '11111111111111111'
+    token_response = token_service.get_token(card)
+    token_response['error']['message'].should eq('Card number is not a recognized brand.')
+  end
+
+  it 'Should fail and return Card Expiration Month invalid' do
+    card = Hps::TestData.valid_visa
+    card.exp_month = 13
+    token_response = token_service.get_token(card)
+    token_response['error']['message'].should eq('Card expiration month is invalid.')
+  end
+
+  it 'Should fail and return Card Expiration Year invalid' do
+    card = Hps::TestData.valid_visa
+    card.exp_year = 12
+    token_response = token_service.get_token(card)
+    token_response['error']['message'].should eq('Card expiration year is invalid.')
+  end
+
+  #Charge Testing with a token
+
+  it 'Should get a token from a Amex card and charge it with out error' do
+    token = token_service.get_token(Hps::TestData.valid_amex)
+    charge = Hps::TestHelper.charge_token(token['token_value'])
+
+    charge.transaction_id.should_not eq(nil)
+    charge.response_code.should eq('00')
+  end
+
+  it 'Should get a token from a Discover card and charge it with out error' do
+    token = token_service.get_token(Hps::TestData.valid_discover)
+    charge = Hps::TestHelper.charge_token(token['token_value'])
+
+    charge.transaction_id.should_not eq(nil)
+    charge.response_code.should eq('00')
+  end
+
+  it 'Should get a token from a Master card and charge it with out error' do
+    token = token_service.get_token(Hps::TestData.valid_mastercard)
+    charge = Hps::TestHelper.charge_token(token['token_value'])
+
+    charge.transaction_id.should_not eq(nil)
+    charge.response_code.should eq('00')
+  end
+
+  it 'Should get a token from a Visa card and charge it with out error' do
+    token = token_service.get_token(Hps::TestData.valid_visa)
+    charge = Hps::TestHelper.charge_token(token['token_value'])
+
+    charge.transaction_id.should_not eq(nil)
+    charge.response_code.should eq('00')
+  end
+
+  # Charge Testing with a multi use token
+
+  it 'Should get a multi use token from a Amex card and charge it with out error' do
+    token = token_service.get_token(Hps::TestData.valid_amex)
+    charge = Hps::TestHelper.charge_token(token['token_value'],true)
+
+    charge.transaction_id.should_not eq(nil)
+    charge.response_code.should eq('00')
+    charge.token_data.token_value.should_not eq(nil)
+
+    multi_token = charge.token_data.token_value
+    charge_multi_token = Hps::TestHelper.charge_token(multi_token)
+    charge_multi_token.transaction_id.should_not eq(nil)
+    charge_multi_token.response_code.should eq('00')
+  end
+
+  it 'Should get a multi use token from a Discover card and charge it with out error' do
+    token = token_service.get_token(Hps::TestData.valid_discover)
+    charge = Hps::TestHelper.charge_token(token['token_value'],true)
+
+    charge.transaction_id.should_not eq(nil)
+    charge.response_code.should eq('00')
+    charge.token_data.token_value.should_not eq(nil)
+
+    multi_token = charge.token_data.token_value
+    charge_multi_token = Hps::TestHelper.charge_token(multi_token)
+    charge_multi_token.transaction_id.should_not eq(nil)
+    charge_multi_token.response_code.should eq('00')
+  end
+
+  it 'Should get a multi use token from a Master card and charge it with out error' do
+    token = token_service.get_token(Hps::TestData.valid_mastercard)
+    charge = Hps::TestHelper.charge_token(token['token_value'],true)
+
+    charge.transaction_id.should_not eq(nil)
+    charge.response_code.should eq('00')
+    charge.token_data.token_value.should_not eq(nil)
+
+    multi_token = charge.token_data.token_value
+    charge_multi_token = Hps::TestHelper.charge_token(multi_token)
+    charge_multi_token.transaction_id.should_not eq(nil)
+    charge_multi_token.response_code.should eq('00')
+  end
+
+  it 'Should get a multi use token from a Visa card and charge it with out error' do
+    token = token_service.get_token(Hps::TestData.valid_visa)
+    charge = Hps::TestHelper.charge_token(token['token_value'],true)
+
+    charge.transaction_id.should_not eq(nil)
+    charge.response_code.should eq('00')
+    charge.token_data.token_value.should_not eq(nil)
+
+    multi_token = charge.token_data.token_value
+    charge_multi_token = Hps::TestHelper.charge_token(multi_token)
+    charge_multi_token.transaction_id.should_not eq(nil)
+    charge_multi_token.response_code.should eq('00')
+  end
+
+  ## Auth Testing with a token
+
+  it 'Should get a token from a Amex card and auth it with out error' do
+    token = token_service.get_token(Hps::TestData.valid_amex)
+    auth = Hps::TestHelper.auth_token(token['token_value'])
+
+    auth.transaction_id.should_not eq(nil)
+    auth.response_code.should eq('00')
+  end
+
+  it 'Should get a token from a Discover card and auth it with out error' do
+    token = token_service.get_token(Hps::TestData.valid_discover)
+    auth = Hps::TestHelper.auth_token(token['token_value'])
+
+    auth.transaction_id.should_not eq(nil)
+    auth.response_code.should eq('00')
+  end
+
+  it 'Should get a token from a Master card and auth it with out error' do
+    token = token_service.get_token(Hps::TestData.valid_mastercard)
+    auth = Hps::TestHelper.auth_token(token['token_value'])
+
+    auth.transaction_id.should_not eq(nil)
+    auth.response_code.should eq('00')
+  end
+
+  it 'Should get a token from a Visa card and auth it with out error' do
+    token = token_service.get_token(Hps::TestData.valid_visa)
+    auth = Hps::TestHelper.auth_token(token['token_value'])
+
+    auth.transaction_id.should_not eq(nil)
+    auth.response_code.should eq('00')
+  end
+
+  # Authorize Testing with a multi use token
+
+  it 'Should get a multi use token from a Amex card and auth it with out error' do
+    token = token_service.get_token(Hps::TestData.valid_amex)
+    auth = Hps::TestHelper.auth_token(token['token_value'],true)
+
+    auth.transaction_id.should_not eq(nil)
+    auth.response_code.should eq('00')
+    auth.token_data.token_value.should_not eq(nil)
+
+    multi_token = auth.token_data.token_value
+    auth_multi_token = Hps::TestHelper.auth_token(multi_token)
+    auth_multi_token.transaction_id.should_not eq(nil)
+    auth_multi_token.response_code.should eq('00')
+  end
+
+  it 'Should get a multi use token from a Discover card and auth it with out error' do
+    token = token_service.get_token(Hps::TestData.valid_discover)
+    auth = Hps::TestHelper.auth_token(token['token_value'],true)
+
+    auth.transaction_id.should_not eq(nil)
+    auth.response_code.should eq('00')
+    auth.token_data.token_value.should_not eq(nil)
+
+    multi_token = auth.token_data.token_value
+    auth_multi_token = Hps::TestHelper.auth_token(multi_token)
+    auth_multi_token.transaction_id.should_not eq(nil)
+    auth_multi_token.response_code.should eq('00')
+  end
+
+  it 'Should get a multi use token from a Master card and auth it with out error' do
+    token = token_service.get_token(Hps::TestData.valid_mastercard)
+    auth = Hps::TestHelper.auth_token(token['token_value'],true)
+
+    auth.transaction_id.should_not eq(nil)
+    auth.response_code.should eq('00')
+    auth.token_data.token_value.should_not eq(nil)
+
+    multi_token = auth.token_data.token_value
+    auth_multi_token = Hps::TestHelper.auth_token(multi_token)
+    auth_multi_token.transaction_id.should_not eq(nil)
+    auth_multi_token.response_code.should eq('00')
+  end
+
+  it 'Should get a multi use token from a Visa card and auth it with out error' do
+    token = token_service.get_token(Hps::TestData.valid_visa)
+    auth = Hps::TestHelper.auth_token(token['token_value'],true)
+
+    auth.transaction_id.should_not eq(nil)
+    auth.response_code.should eq('00')
+    auth.token_data.token_value.should_not eq(nil)
+
+    multi_token = auth.token_data.token_value
+    auth_multi_token = Hps::TestHelper.auth_token(multi_token)
+    auth_multi_token.transaction_id.should_not eq(nil)
+    auth_multi_token.response_code.should eq('00')
+  end
+
+  # Verify Testing with a token
+
+  it 'Should get a token from a Amex card and verify it with out error' do
+    token = token_service.get_token(Hps::TestData.valid_amex)
+    verify = Hps::TestHelper.verify_token(token['token_value'])
+
+    verify.transaction_id.should_not eq(nil)
+    verify.response_code.should eq('00')
+  end
+
+  it 'Should get a token from a Discover card and verify it with out error' do
+    token = token_service.get_token(Hps::TestData.valid_discover)
+    verify = Hps::TestHelper.verify_token(token['token_value'])
+
+    verify.transaction_id.should_not eq(nil)
+    verify.response_code.should eq('85')
+  end
+
+  it 'Should get a token from a Master card and verify it with out error' do
+    token = token_service.get_token(Hps::TestData.valid_mastercard)
+    verify = Hps::TestHelper.verify_token(token['token_value'])
+
+    verify.transaction_id.should_not eq(nil)
+    verify.response_code.should eq('85')
+  end
+
+  it 'Should get a token from a Visa card and verify it with out error' do
+    token = token_service.get_token(Hps::TestData.valid_visa)
+    verify = Hps::TestHelper.verify_token(token['token_value'])
+
+    verify.transaction_id.should_not eq(nil)
+    verify.response_code.should eq('85')
+  end
+
+  # Verify Testing with a multi use token
+
+  it 'Should get a token from a Amex card verify it get a multi token and test with out error' do
+    token = token_service.get_token(Hps::TestData.valid_amex)
+    verify = Hps::TestHelper.verify_token(token['token_value'],true)
+
+    verify.transaction_id.should_not eq(nil)
+    verify.response_code.should eq('00')
+    verify.token_data.token_value.should_not eq(nil)
+
+    multi_token = verify.token_data.token_value
+    verify_multi_token = Hps::TestHelper.verify_token(multi_token)
+    verify_multi_token.transaction_id.should_not eq(nil)
+    verify_multi_token.response_code.should eq('00')
+  end
+
+  it 'Should get a token from a Discover card verify it get a multi token and test with out error' do
+    token = token_service.get_token(Hps::TestData.valid_discover)
+    verify = Hps::TestHelper.verify_token(token['token_value'],true)
+
+    verify.transaction_id.should_not eq(nil)
+    verify.response_code.should eq('85')
+    verify.token_data.token_value.should_not eq(nil)
+
+    multi_token = verify.token_data.token_value
+    verify_multi_token = Hps::TestHelper.verify_token(multi_token)
+    verify_multi_token.transaction_id.should_not eq(nil)
+    verify_multi_token.response_code.should eq('85')
+  end
+
+  it 'Should get a token from a Master card verify it get a multi token and test with out error' do
+    token = token_service.get_token(Hps::TestData.valid_mastercard)
+    verify = Hps::TestHelper.verify_token(token['token_value'],true)
+
+    verify.transaction_id.should_not eq(nil)
+    verify.response_code.should eq('85')
+    verify.token_data.token_value.should_not eq(nil)
+
+    multi_token = verify.token_data.token_value
+    verify_multi_token = Hps::TestHelper.verify_token(multi_token)
+    verify_multi_token.transaction_id.should_not eq(nil)
+    verify_multi_token.response_code.should eq('85')
+  end
+
+  it 'Should get a token from a Visa card verify it get a multi token and test with out error' do
+    token = token_service.get_token(Hps::TestData.valid_visa)
+    verify = Hps::TestHelper.verify_token(token['token_value'],true)
+
+    verify.transaction_id.should_not eq(nil)
+    verify.response_code.should eq('85')
+    verify.token_data.token_value.should_not eq(nil)
+
+    multi_token = verify.token_data.token_value
+    verify_multi_token = Hps::TestHelper.verify_token(multi_token)
+    verify_multi_token.transaction_id.should_not eq(nil)
+    verify_multi_token.response_code.should eq('85')
+  end
+
+  # Refund Token Tests
+
+  it 'Should get Amex token return should be okay' do
+    token = token_service.get_token(Hps::TestData.valid_amex)
+    refund = Hps::TestHelper.refund_token(token['token_value'])
+
+    refund.transaction_id.should_not eq(nil)
+    refund.response_code.should eq('00')
+  end
+
+
+  it 'Should get Discover token return should be okay' do
+    token = token_service.get_token(Hps::TestData.valid_discover)
+    refund = Hps::TestHelper.refund_token(token['token_value'])
+
+    refund.transaction_id.should_not eq(nil)
+    refund.response_code.should eq('00')
+  end
+
+
+  it 'Should get MasterCard token return should be okay' do
+    token = token_service.get_token(Hps::TestData.valid_mastercard)
+    refund = Hps::TestHelper.refund_token(token['token_value'])
+
+    refund.transaction_id.should_not eq(nil)
+    refund.response_code.should eq('00')
+  end
+
+  it 'Should get Visa token return should be okay' do
+    token = token_service.get_token(Hps::TestData.valid_visa)
+    refund = Hps::TestHelper.refund_token(token['token_value'])
+
+    refund.transaction_id.should_not eq(nil)
+    refund.response_code.should eq('00')
+  end
+
+  # Refund Multi Token Tests
+
+  it 'Should get Amex Mulit token return should be okay' do
+    token = token_service.get_token(Hps::TestData.valid_amex)
+    charge = Hps::TestHelper.charge_token(token['token_value'],true)
+
+    charge.transaction_id.should_not eq(nil)
+    charge.response_code.should eq('00')
+    charge.token_data.token_value.should_not eq(nil)
+
+    refund = Hps::TestHelper.refund_token(charge.token_data.token_value)
+
+    refund.transaction_id.should_not eq(nil)
+    refund.response_code.should eq('00')
+  end
+
+  it 'Should get Discover Mulit token return should be okay' do
+    token = token_service.get_token(Hps::TestData.valid_discover)
+    charge = Hps::TestHelper.charge_token(token['token_value'],true)
+
+    charge.transaction_id.should_not eq(nil)
+    charge.response_code.should eq('00')
+    charge.token_data.token_value.should_not eq(nil)
+
+    refund = Hps::TestHelper.refund_token(charge.token_data.token_value)
+
+    refund.transaction_id.should_not eq(nil)
+    refund.response_code.should eq('00')
+  end
+
+  it 'Should get MasterCard Mulit token return should be okay' do
+    token = token_service.get_token(Hps::TestData.valid_mastercard)
+    charge = Hps::TestHelper.charge_token(token['token_value'],true)
+
+    charge.transaction_id.should_not eq(nil)
+    charge.response_code.should eq('00')
+    charge.token_data.token_value.should_not eq(nil)
+
+    refund = Hps::TestHelper.refund_token(charge.token_data.token_value)
+
+    refund.transaction_id.should_not eq(nil)
+    refund.response_code.should eq('00')
+  end
+
+  it 'Should get Visa Mulit token return should be okay' do
+    token = token_service.get_token(Hps::TestData.valid_visa)
+    charge = Hps::TestHelper.charge_token(token['token_value'],true)
+
+    charge.transaction_id.should_not eq(nil)
+    charge.response_code.should eq('00')
+    charge.token_data.token_value.should_not eq(nil)
+
+    refund = Hps::TestHelper.refund_token(charge.token_data.token_value)
+
+    refund.transaction_id.should_not eq(nil)
+    refund.response_code.should eq('00')
+  end
+
+  # Reverse Token Tests
+
+  it 'Should get Amex token reverse should be okay' do
+    token = token_service.get_token(Hps::TestData.valid_amex)
+    refund = Hps::TestHelper.reverse_token(token['token_value'])
+
+    refund.transaction_id.should_not eq(nil)
+    refund.response_code.should eq('00')
+  end
+
+
+  it 'Should get Discover token reverse should be okay' do
+    token = token_service.get_token(Hps::TestData.valid_discover)
+    refund = Hps::TestHelper.reverse_token(token['token_value'])
+
+    refund.transaction_id.should_not eq(nil)
+    refund.response_code.should eq('00')
+  end
+
+
+  it 'Should get MasterCard token reverse should be okay' do
+    token = token_service.get_token(Hps::TestData.valid_mastercard)
+    refund = Hps::TestHelper.reverse_token(token['token_value'])
+
+    refund.transaction_id.should_not eq(nil)
+    refund.response_code.should eq('00')
+  end
+
+  it 'Should get Visa token reverse should be okay' do
+    token = token_service.get_token(Hps::TestData.valid_visa)
+    refund = Hps::TestHelper.reverse_token(token['token_value'])
+
+    refund.transaction_id.should_not eq(nil)
+    refund.response_code.should eq('00')
+  end
+
+  # Reverse Multi Token Tests
+
+  it 'Should get Amex Mulit token reverse should be okay' do
+    token = token_service.get_token(Hps::TestData.valid_amex)
+    charge = Hps::TestHelper.charge_token(token['token_value'],true)
+
+    charge.transaction_id.should_not eq(nil)
+    charge.response_code.should eq('00')
+    charge.token_data.token_value.should_not eq(nil)
+
+    refund = Hps::TestHelper.reverse_token(charge.token_data.token_value)
+
+    refund.transaction_id.should_not eq(nil)
+    refund.response_code.should eq('00')
+  end
+
+  it 'Should get Discover Mulit token reverse should be okay' do
+    token = token_service.get_token(Hps::TestData.valid_discover)
+    charge = Hps::TestHelper.charge_token(token['token_value'],true)
+
+    charge.transaction_id.should_not eq(nil)
+    charge.response_code.should eq('00')
+    charge.token_data.token_value.should_not eq(nil)
+
+    refund = Hps::TestHelper.reverse_token(charge.token_data.token_value)
+
+    refund.transaction_id.should_not eq(nil)
+    refund.response_code.should eq('00')
+  end
+
+  it 'Should get MasterCard Mulit token reverse should be okay' do
+    token = token_service.get_token(Hps::TestData.valid_mastercard)
+    charge = Hps::TestHelper.charge_token(token['token_value'],true)
+
+    charge.transaction_id.should_not eq(nil)
+    charge.response_code.should eq('00')
+    charge.token_data.token_value.should_not eq(nil)
+
+    refund = Hps::TestHelper.reverse_token(charge.token_data.token_value)
+
+    refund.transaction_id.should_not eq(nil)
+    refund.response_code.should eq('00')
+  end
+
+  it 'Should get Visa Mulit token reverse should be okay' do
+    token = token_service.get_token(Hps::TestData.valid_visa)
+    charge = Hps::TestHelper.charge_token(token['token_value'],true)
+
+    charge.transaction_id.should_not eq(nil)
+    charge.response_code.should eq('00')
+    charge.token_data.token_value.should_not eq(nil)
+
+    refund = Hps::TestHelper.reverse_token(charge.token_data.token_value)
+
+    refund.transaction_id.should_not eq(nil)
+    refund.response_code.should eq('00')
+  end
+
+end