hps 1.0.2 → 2.1.2

data/tests/general_tests.rb

@@ -1,58 +1,66 @@
-require File.join( File.dirname(__FILE__), "test_helper.rb" )
-
-describe "General Tests" do
-  
-	before(:each) do
-    Hps::TestHelper.configure_hps_module()
-		@service = Hps::HpsChargeService.new()
-	end
-  
-  it "charge when amount is less than zero should throw invalid request exception" do
-    expect {
-      @service.charge(-5, "usd", Hps::TestData::valid_visa, Hps::TestData::valid_cardholder) 
-    }.to raise_error(Hps::InvalidRequestException)
-  end
-  
-  it "charge when currency is empty should throw invalid request exception" do
-    expect {
-      @service.charge(50, "", Hps::TestData::valid_visa, Hps::TestData::valid_cardholder) 
-    }.to raise_error(Hps::InvalidRequestException)
-  end
-  
-  it "charge when currency is not usd should throw invalid request exception" do
-    expect {
-      @service.charge(50, "eur", Hps::TestData::valid_visa, Hps::TestData::valid_cardholder) 
-    }.to raise_error(Hps::InvalidRequestException)
-  end
-  
-  it "charge when configuration is invalid should throw hps exception" do
-    expect {
-      @service = Hps::HpsChargeService.new :service_uri => nil
-      @service.charge(50, "usd", Hps::TestData::valid_visa, Hps::TestData::valid_cardholder) 
-    }.to raise_error(Hps::HpsException)
-  end
-  
-  it "charge when license_id is invalid should throw authentication exception" do
-    expect {
-      @service = Hps::HpsChargeService.new :license_id => 11111
-      @service.charge(50, "usd", Hps::TestData::valid_visa, Hps::TestData::valid_cardholder) 
-    }.to raise_error(Hps::AuthenticationException)
-  end
-  
-  it "charge when card number is invalid should throw hps exception" do
-    expect {
-      @service.charge(50, "usd", Hps::TestData::invalid_card, Hps::TestData::valid_cardholder) 
-    }.to raise_error(Hps::HpsException)
-  end
-  
-  it "list when charge is in filter range should show in list" do    
-    start_date = DateTime.now - 12.hours
-    charge = @service.charge(50, "usd", Hps::TestData::valid_visa, Hps::TestData::valid_cardholder) 
-    end_date = DateTime.now
-
-    charges = @service.list(start_date, end_date)
-    expect(charges).to have_at_least(1).items          
-    expect(charges.any? { |c| c.transaction_id = charge.transaction_id }).to be_true
-  end
-  
+require File.join( File.dirname(__FILE__), "test_helper.rb" )
+
+describe "General Tests" do
+  
+	before(:each) do
+    Hps::TestHelper.configure_hps_module()
+		@service = Hps::HpsChargeService.new()
+	end
+  
+  it "SecretAPIKey with spaces on Visa charge should return OK" do
+    Hps::TestHelper.configure_hps_module_secret_key_with_spaces
+	@service = Hps::HpsChargeService.new()
+    result = @service.charge(5, "usd", Hps::TestData::valid_visa, Hps::TestData::valid_cardholder)
+    expect(result.response_code).to eql("00")
+  end
+
+  
+  it "charge when amount is less than zero should throw invalid request exception" do
+    expect {
+      @service.charge(-5, "usd", Hps::TestData::valid_visa, Hps::TestData::valid_cardholder) 
+    }.to raise_error(Hps::InvalidRequestException)
+  end
+  
+  it "charge when currency is empty should throw invalid request exception" do
+    expect {
+      @service.charge(50, "", Hps::TestData::valid_visa, Hps::TestData::valid_cardholder) 
+    }.to raise_error(Hps::InvalidRequestException)
+  end
+  
+  it "charge when currency is not usd should throw invalid request exception" do
+    expect {
+      @service.charge(50, "eur", Hps::TestData::valid_visa, Hps::TestData::valid_cardholder) 
+    }.to raise_error(Hps::InvalidRequestException)
+  end
+  
+  it "charge when configuration is invalid should throw hps exception" do
+    expect {
+      @service = Hps::HpsChargeService.new :service_uri => nil
+      @service.charge(50, "usd", Hps::TestData::valid_visa, Hps::TestData::valid_cardholder) 
+    }.to raise_error(Hps::HpsException)
+  end
+  
+  it "charge when license_id is invalid should throw authentication exception" do
+    expect {
+      @service = Hps::HpsChargeService.new :license_id => 11111
+      @service.charge(50, "usd", Hps::TestData::valid_visa, Hps::TestData::valid_cardholder) 
+    }.to raise_error(Hps::AuthenticationException)
+  end
+  
+  it "charge when card number is invalid should throw hps exception" do
+    expect {
+      @service.charge(50, "usd", Hps::TestData::invalid_card, Hps::TestData::valid_cardholder) 
+    }.to raise_error(Hps::HpsException)
+  end
+  
+  it "list when charge is in filter range should show in list" do    
+    start_date = DateTime.now - 12.hours
+    charge = @service.charge(50, "usd", Hps::TestData::valid_visa, Hps::TestData::valid_cardholder) 
+    end_date = DateTime.now
+
+    charges = @service.list(start_date, end_date)
+    expect(charges).to have_at_least(1).items          
+    expect(charges.any? { |c| c.transaction_id = charge.transaction_id }).to be_true
+  end
+  
 end

data/tests/hps_token_service.rb

@@ -1,56 +1,56 @@
-require 'net/http'
-
-require 'rubygems'
-require 'json'
-
-module Hps
-  class HpsTokenService
-    attr_accessor :public_api_key, :url
-
-    def initialize(public_api_key)
-      @public_api_key = public_api_key
-      if @public_api_key.nil? || @public_api_key.eql?('')
-        raise HpsException.new('Public Key Not Found', '0')
-      end
-
-      components = @public_api_key.split '_'
-      if components.size  < 3
-        raise HpsException.new('Public API Key must contain at least two underscores','0')
-      end
-
-      if components[1].downcase.eql? 'prod'
-        @url = 'https://api.heartlandportico.com/SecureSubmit.v1/api/token'
-      else
-        @url = 'https://posgateway.cert.secureexchange.net/Hps.Exchange.PosGateway.Hpf.v1/api/token'
-      end
-
-    end
-
-    def get_token(card_data)
-      data = {
-          'api_key' => @public_api_key,
-          'object' => 'token',
-          'token_type' => 'supt',
-          '_method' => 'post',
-          'card[number]' => card_data.number,
-          'card[cvv]' => card_data.cvv,
-          'card[exp_month]' => card_data.exp_month,
-          'card[exp_year]' => card_data.exp_year
-      }
-      get_result = get(data)
-      JSON.parse(get_result)
-    end
-
-    def get(data)
-      begin
-        uri = URI(@url)
-        uri.query = URI.encode_www_form(data)
-        res = Net::HTTP.get_response(uri)
-        res.body
-
-      rescue Exception => e
-        raise HpsException.new(e.message,'0')
-      end
-    end
-  end
-end
+require 'net/http'
+
+require 'rubygems'
+require 'json'
+
+module Hps
+  class HpsTokenService
+    attr_accessor :public_api_key, :url
+
+    def initialize(public_api_key)
+      @public_api_key = public_api_key
+      if @public_api_key.nil? || @public_api_key.eql?('')
+        raise HpsException.new('Public Key Not Found', '0')
+      end
+
+      components = @public_api_key.split '_'
+      if components.size  < 3
+        raise HpsException.new('Public API Key must contain at least two underscores','0')
+      end
+
+      if components[1].downcase.eql? 'prod'
+        @url = 'https://api2.heartlandportico.com/SecureSubmit.v1/api/token'
+      else
+        @url = 'https://cert.api2.heartlandportico.com/Hps.Exchange.PosGateway.Hpf.v1/api/token'
+      end
+
+    end
+
+    def get_token(card_data)
+      data = {
+          'api_key' => @public_api_key,
+          'object' => 'token',
+          'token_type' => 'supt',
+          '_method' => 'post',
+          'card[number]' => card_data.number,
+          'card[cvv]' => card_data.cvv,
+          'card[exp_month]' => card_data.exp_month,
+          'card[exp_year]' => card_data.exp_year
+      }
+      get_result = get(data)
+      JSON.parse(get_result)
+    end
+
+    def get(data)
+      begin
+        uri = URI(@url)
+        uri.query = URI.encode_www_form(data)
+        res = Net::HTTP.get_response(uri)
+        res.body
+
+      rescue Exception => e
+        raise HpsException.new(e.message,'0')
+      end
+    end
+  end
+end

data/tests/mastercard_tests.rb

@@ -1,326 +1,387 @@
-require File.join( File.dirname(__FILE__), "test_helper" )
-
-describe "Mastercard Tests" do
-  
-  it "Mastercard when card is ok, should return valid result" do
-    charge = Hps::TestHelper.charge_valid_mastercard(50)
-    expect(charge.response_code).to eql("00")
-  end
-  
-  # avs tests
-  
-  it "Mastercard avs result code should equal A" do
-    charge = Hps::TestHelper.charge_valid_mastercard(90.01)
-    expect(charge.avs_result_code).to eql("A")
-  end
-  
-  it "Mastercard avs result code should equal N" do
-    charge = Hps::TestHelper.charge_valid_mastercard(90.02)
-    expect(charge.avs_result_code).to eql("N")
-  end
-  
-  it "Mastercard avs result code should equal R" do
-    charge = Hps::TestHelper.charge_valid_mastercard(90.03)
-    expect(charge.avs_result_code).to eql("R")
-  end
-  
-  it "Mastercard avs result code should equal S" do
-    charge = Hps::TestHelper.charge_valid_mastercard(90.04)
-    expect(charge.avs_result_code).to eql("S")
-  end
-  
-  it "Mastercard avs result code should equal U" do
-    charge = Hps::TestHelper.charge_valid_mastercard(90.05)
-    expect(charge.avs_result_code).to eql("U")
-  end
-  
-  it "Mastercard avs result code should equal W" do
-    charge = Hps::TestHelper.charge_valid_mastercard(90.06)
-    expect(charge.avs_result_code).to eql("W")
-  end
-  
-  it "Mastercard avs result code should equal X" do
-    charge = Hps::TestHelper.charge_valid_mastercard(90.07)
-    expect(charge.avs_result_code).to eql("X")
-  end
-  
-  it "Mastercard avs result code should equal Y" do
-    charge = Hps::TestHelper.charge_valid_mastercard(90.08)
-    expect(charge.avs_result_code).to eql("Y")
-  end
-  
-  it "Mastercard avs result code should equal Z" do
-    charge = Hps::TestHelper.charge_valid_mastercard(90.09)
-    expect(charge.avs_result_code).to eql("Z")
-  end
-  
-  # cvv tests
-  
-  it "Mastercard cvv result code should equal M" do
-    charge = Hps::TestHelper.charge_valid_mastercard(95.01)
-    expect(charge.cvv_result_code).to eql("M")
-  end
-  
-  it "Mastercard cvv result code should equal N" do
-    charge = Hps::TestHelper.charge_valid_mastercard(95.02)
-    expect(charge.cvv_result_code).to eql("N")
-  end
-  
-  it "Mastercard cvv result code should equal P" do
-    charge = Hps::TestHelper.charge_valid_mastercard(95.03)
-    expect(charge.cvv_result_code).to eql("P")
-  end
-  
-  it "Mastercard cvv result code should equal U" do
-    charge = Hps::TestHelper.charge_valid_mastercard(95.04)
-    expect(charge.cvv_result_code).to eql("U")
-  end
-  
-  # mastercard to 8583
-  
-  it "Mastercard response code should indicate refer card issuer" do
-    expect {
-       Hps::TestHelper.charge_valid_mastercard(10.34)
-    }.to raise_error(Hps::CardException) { |error| 
-      expect(error.code).to eql("card_declined")      
-      expect(error.response_code).to eql("02")
-      expect(error.response_text).to eql("CALL")
-    }
-  end
-  
-  it "Mastercard response code should indicate term id error" do
-    expect {
-       Hps::TestHelper.charge_valid_mastercard(10.22)
-    }.to raise_error(Hps::CardException) { |error| 
-      expect(error.code).to eql("card_declined")      
-      expect(error.response_code).to eql("03")
-      expect(error.response_text).to eql("TERM ID ERROR")
-    }
-  end
-
-  # TODO: Gateway not throwing error
-  # it "Mastercard response code should indicate invalid merchant" do
-  #   expect {
-  #      Hps::TestHelper.charge_valid_mastercard(10.01)
-  #   }.to raise_error(Hps::CardException) { |error| 
-  #     expect(error.code).to eql("card_declined")      
-  #     expect(error.response_code).to eql("04")
-  #     expect(error.response_text).to eql("HOLD-CALL")
-  #   }
-  # end
-  
-  it "Mastercard response code should indicate do not honor" do
-    expect {
-       Hps::TestHelper.charge_valid_mastercard(10.25)
-    }.to raise_error(Hps::CardException) { |error| 
-      expect(error.code).to eql("card_declined")      
-      expect(error.response_code).to eql("05")
-      expect(error.response_text).to eql("DECLINE")
-    }
-  end
-
-  # TODO: Gateway not throwing error  
-  # it "Mastercard response code should indicate invalid transaction" do
-  #   expect {
-  #      Hps::TestHelper.charge_valid_amex(10.26)
-  #   }.to raise_error(Hps::CardException) { |error| 
-  #     expect(error.code).to eql("processing_error")      
-  #     expect(error.response_code).to eql("12")
-  #     expect(error.response_text).to eql("INVALID TRANS")
-  #   }
-  # end
-  
-  it "Mastercard response code should indicate invalid amount" do
-    expect {
-       Hps::TestHelper.charge_valid_mastercard(10.27)
-    }.to raise_error(Hps::CardException) { |error| 
-      expect(error.code).to eql("invalid_amount")      
-      expect(error.response_code).to eql("13")
-      expect(error.response_text).to eql("AMOUNT ERROR")
-    }
-  end
-  
-  it "Mastercard response code should indicate invalid card" do
-    expect {
-       Hps::TestHelper.charge_valid_mastercard(10.28)
-    }.to raise_error(Hps::CardException) { |error| 
-      expect(error.code).to eql("incorrect_number")      
-      expect(error.response_code).to eql("14")
-      expect(error.response_text).to eql("CARD NO. ERROR")
-    }
-  end
-  
-  it "Mastercard response code should indicate invalid issuer" do
-    expect {
-       Hps::TestHelper.charge_valid_mastercard(10.18)
-    }.to raise_error(Hps::CardException) { |error| 
-      expect(error.code).to eql("processing_error")      
-      expect(error.response_code).to eql("15")
-      expect(error.response_text).to eql("NO SUCH ISSUER")
-    }
-  end
-  
-  it "Mastercard response code should indicate lost card" do
-    expect {
-       Hps::TestHelper.charge_valid_mastercard(10.31)
-    }.to raise_error(Hps::CardException) { |error| 
-      expect(error.code).to eql("card_declined")      
-      expect(error.response_code).to eql("41")
-      expect(error.response_text).to eql("HOLD-CALL")
-    }
-  end
-  
-  it "Mastercard response code should indicate hold call" do
-    expect {
-       Hps::TestHelper.charge_valid_mastercard(10.03)
-    }.to raise_error(Hps::CardException) { |error| 
-      expect(error.code).to eql("card_declined")      
-      expect(error.response_code).to eql("43")
-      expect(error.response_text).to eql("HOLD-CALL")
-    }
-  end
-  
-  it "Mastercard response code should indicate decline" do
-    expect {
-       Hps::TestHelper.charge_valid_mastercard(10.08)
-    }.to raise_error(Hps::CardException) { |error| 
-      expect(error.code).to eql("card_declined")      
-      expect(error.response_code).to eql("51")
-      expect(error.response_text).to eql("DECLINE")
-    }
-  end
-  
-  it "Mastercard response code should indicate expired card" do
-    expect {
-       Hps::TestHelper.charge_valid_mastercard(10.32)
-    }.to raise_error(Hps::CardException) { |error| 
-      expect(error.code).to eql("expired_card")      
-      expect(error.response_code).to eql("54")
-      expect(error.response_text).to eql("EXPIRED CARD")
-    }
-  end
-  
-  it "Mastercard response code should indicate exceeds limit" do
-    expect {
-       Hps::TestHelper.charge_valid_mastercard(10.09)
-    }.to raise_error(Hps::CardException) { |error| 
-      expect(error.code).to eql("card_declined")      
-      expect(error.response_code).to eql("61")
-      expect(error.response_text).to eql("DECLINE")
-    }
-  end
-  
-  it "Mastercard response code should indicate restricted card" do
-    expect {
-       Hps::TestHelper.charge_valid_mastercard(10.10)
-    }.to raise_error(Hps::CardException) { |error| 
-      expect(error.code).to eql("card_declined")      
-      expect(error.response_code).to eql("62")
-      expect(error.response_text).to eql("DECLINE")
-    }
-  end
-  
-  it "Mastercard response code should indicate security violation" do
-    expect {
-       Hps::TestHelper.charge_valid_mastercard(10.19)
-    }.to raise_error(Hps::CardException) { |error| 
-      expect(error.code).to eql("card_declined")      
-      expect(error.response_code).to eql("63")
-      expect(error.response_text).to eql("SEC VIOLATION")
-    }
-  end
-  
-  it "Mastercard response code should indicate exceeds freq limit" do
-    expect {
-       Hps::TestHelper.charge_valid_mastercard(10.11)
-    }.to raise_error(Hps::CardException) { |error| 
-      expect(error.code).to eql("card_declined")      
-      expect(error.response_code).to eql("65")
-      expect(error.response_text).to eql("DECLINE")
-    }
-  end
-  
-  it "Mastercard response code should indicate card no error" do
-    expect {
-       Hps::TestHelper.charge_valid_mastercard(10.14)
-    }.to raise_error(Hps::CardException) { |error| 
-      expect(error.code).to eql("incorrect_number")      
-      expect(error.response_code).to eql("14")
-      expect(error.response_text).to eql("CARD NO. ERROR")
-    }
-  end
-  
-  it "Mastercard response code should indicate invalid account" do
-    expect {
-       Hps::TestHelper.charge_valid_mastercard(10.06)
-    }.to raise_error(Hps::CardException) { |error| 
-      expect(error.code).to eql("processing_error")      
-      # TODO: Gateway change
-      #expect(error.response_code).to eql("79")
-      expect(error.response_code).to eql("EC")
-      expect(error.response_text).to eql("CID FORMAT ERROR")
-    }
-  end
-  
-  # TODO: Gateway change, used to throw exception but now it doesn't
-  it "Mastercard response code should indicate switch not available" do
-    expect {
-       Hps::TestHelper.charge_valid_mastercard(10.33)
-    }.to raise_error(Hps::HpsException) { |error|    
-    #}.to raise_error(Hps::CardException) { |error|       
-      #expect(error.code).to eql("processing_error")      
-      #expect(error.response_code).to eql("14")
-      expect(error.code).to eql("issuer_timeout")      
-      expect(error.response_code).to eql("91")
-      expect(error.response_text).to eql("NO REPLY")
-    }
-  end  
-  
-  it "Mastercard response code should indicate system error" do
-    expect {
-       Hps::TestHelper.charge_valid_mastercard(10.21)
-    }.to raise_error(Hps::CardException) { |error| 
-      expect(error.code).to eql("processing_error")      
-      expect(error.response_code).to eql("96")
-      expect(error.response_text).to eql("SYSTEM ERROR")
-    }
-  end
-  
-  # verify, authorize, refund, and capture
-  
-  it "Mastercard verify should return OK" do
-    service = Hps::HpsChargeService.new()
-    result = service.verify(Hps::TestData.valid_mastercard, Hps::TestData.valid_cardholder)
-    expect(result.response_code).to eql("85")  
-  end
-  
-  it "Mastercard authorize should return OK" do
-    service = Hps::HpsChargeService.new()
-    result = service.authorize(50.00, "usd", Hps::TestData.valid_mastercard, Hps::TestData.valid_cardholder)
-    expect(result.response_code).to eql("00")  
-  end
-  
-  it "Mastercard authorize and request token should return OK" do
-    service = Hps::HpsChargeService.new()
-    result = service.authorize(50.00, "usd", Hps::TestData.valid_mastercard, Hps::TestData.valid_cardholder, true)
-    expect(result.token_data.response_code).to eql("0")
-    expect(result.response_code).to eql("00")  
-  end
-  
-  it "Mastercard should refund OK" do 
-    service = Hps::HpsChargeService.new()
-    charge = service.charge(25.00, "usd", Hps::TestData.valid_mastercard, Hps::TestData.valid_cardholder)    
-    refund = service.refund_transaction(25.00, "usd", charge.transaction_id)
-    expect(refund.response_code).to eql("00")
-  end
-  
-  it "Mastercard authorize and capture should return OK" do
-    service = Hps::HpsChargeService.new()
-    result = service.authorize(50.00, "usd", Hps::TestData.valid_mastercard, Hps::TestData.valid_cardholder)
-    expect(result.response_code).to eql("00")  
-    
-    capture_result = service.capture(result.transaction_id)
-    expect(capture_result.response_code).to eql("00")
-  end  
-  
-end
+require File.join( File.dirname(__FILE__), "test_helper" )
+
+describe "Mastercard Tests" do
+
+  it "Mastercard when card is ok, should return valid result" do
+    charge = Hps::TestHelper.charge_valid_mastercard(50)
+    expect(charge.response_code).to eql("00")
+  end
+
+  # avs tests
+
+  it "Mastercard avs result code should equal A" do
+    charge = Hps::TestHelper.charge_valid_mastercard(90.01)
+    expect(charge.avs_result_code).to eql("A")
+  end
+
+  it "Mastercard avs result code should equal N" do
+    charge = Hps::TestHelper.charge_valid_mastercard(90.02)
+    expect(charge.avs_result_code).to eql("N")
+  end
+
+  it "Mastercard avs result code should equal R" do
+    charge = Hps::TestHelper.charge_valid_mastercard(90.03)
+    expect(charge.avs_result_code).to eql("R")
+  end
+
+  it "Mastercard avs result code should equal S" do
+    charge = Hps::TestHelper.charge_valid_mastercard(90.04)
+    expect(charge.avs_result_code).to eql("S")
+  end
+
+  it "Mastercard avs result code should equal U" do
+    charge = Hps::TestHelper.charge_valid_mastercard(90.05)
+    expect(charge.avs_result_code).to eql("U")
+  end
+
+  it "Mastercard avs result code should equal W" do
+    charge = Hps::TestHelper.charge_valid_mastercard(90.06)
+    expect(charge.avs_result_code).to eql("W")
+  end
+
+  it "Mastercard avs result code should equal X" do
+    charge = Hps::TestHelper.charge_valid_mastercard(90.07)
+    expect(charge.avs_result_code).to eql("X")
+  end
+
+  it "Mastercard avs result code should equal Y" do
+    charge = Hps::TestHelper.charge_valid_mastercard(90.08)
+    expect(charge.avs_result_code).to eql("Y")
+  end
+
+  it "Mastercard avs result code should equal Z" do
+    charge = Hps::TestHelper.charge_valid_mastercard(90.09)
+    expect(charge.avs_result_code).to eql("Z")
+  end
+
+  # cvv tests
+
+  it "Mastercard cvv result code should equal M" do
+    charge = Hps::TestHelper.charge_valid_mastercard(95.01)
+    expect(charge.cvv_result_code).to eql("M")
+  end
+
+  it "Mastercard cvv result code should equal N" do
+    charge = Hps::TestHelper.charge_valid_mastercard(95.02)
+    expect(charge.cvv_result_code).to eql("N")
+  end
+
+  it "Mastercard cvv result code should equal P" do
+    charge = Hps::TestHelper.charge_valid_mastercard(95.03)
+    expect(charge.cvv_result_code).to eql("P")
+  end
+
+  it "Mastercard cvv result code should equal U" do
+    charge = Hps::TestHelper.charge_valid_mastercard(95.04)
+    expect(charge.cvv_result_code).to eql("U")
+  end
+
+  # mastercard to 8583
+
+  it "Mastercard response code should indicate refer card issuer" do
+    expect {
+       Hps::TestHelper.charge_valid_mastercard(10.34)
+    }.to raise_error(Hps::CardException) { |error|
+      expect(error.code).to eql("card_declined")
+      expect(error.response_code).to eql("02")
+      expect(error.response_text).to eql("CALL")
+    }
+  end
+
+  it "Mastercard response code should indicate term id error" do
+    expect {
+       Hps::TestHelper.charge_valid_mastercard(10.22)
+    }.to raise_error(Hps::CardException) { |error|
+      expect(error.code).to eql("card_declined")
+      expect(error.response_code).to eql("03")
+      expect(error.response_text).to eql("TERM ID ERROR")
+    }
+  end
+
+  # TODO: Gateway not throwing error
+  # it "Mastercard response code should indicate invalid merchant" do
+  #   expect {
+  #      Hps::TestHelper.charge_valid_mastercard(10.01)
+  #   }.to raise_error(Hps::CardException) { |error|
+  #     expect(error.code).to eql("card_declined")
+  #     expect(error.response_code).to eql("04")
+  #     expect(error.response_text).to eql("HOLD-CALL")
+  #   }
+  # end
+
+  it "Mastercard response code should indicate do not honor" do
+    expect {
+       Hps::TestHelper.charge_valid_mastercard(10.25)
+    }.to raise_error(Hps::CardException) { |error|
+      expect(error.code).to eql("card_declined")
+      expect(error.response_code).to eql("05")
+      expect(error.response_text).to eql("DECLINE")
+    }
+  end
+
+  # TODO: Gateway not throwing error
+  # it "Mastercard response code should indicate invalid transaction" do
+  #   expect {
+  #      Hps::TestHelper.charge_valid_amex(10.26)
+  #   }.to raise_error(Hps::CardException) { |error|
+  #     expect(error.code).to eql("processing_error")
+  #     expect(error.response_code).to eql("12")
+  #     expect(error.response_text).to eql("INVALID TRANS")
+  #   }
+  # end
+
+  it "Mastercard response code should indicate invalid amount" do
+    expect {
+       Hps::TestHelper.charge_valid_mastercard(10.27)
+    }.to raise_error(Hps::CardException) { |error|
+      expect(error.code).to eql("invalid_amount")
+      expect(error.response_code).to eql("13")
+      expect(error.response_text).to eql("AMOUNT ERROR")
+    }
+  end
+
+  it "Mastercard response code should indicate invalid card" do
+    expect {
+       Hps::TestHelper.charge_valid_mastercard(10.28)
+    }.to raise_error(Hps::CardException) { |error|
+      expect(error.code).to eql("incorrect_number")
+      expect(error.response_code).to eql("14")
+      expect(error.response_text).to eql("CARD NO. ERROR")
+    }
+  end
+
+  it "Mastercard response code should indicate invalid issuer" do
+    expect {
+       Hps::TestHelper.charge_valid_mastercard(10.18)
+    }.to raise_error(Hps::CardException) { |error|
+      expect(error.code).to eql("processing_error")
+      expect(error.response_code).to eql("15")
+      expect(error.response_text).to eql("NO SUCH ISSUER")
+    }
+  end
+
+  it "Mastercard response code should indicate lost card" do
+    expect {
+       Hps::TestHelper.charge_valid_mastercard(10.31)
+    }.to raise_error(Hps::CardException) { |error|
+      expect(error.code).to eql("card_declined")
+      expect(error.response_code).to eql("41")
+      expect(error.response_text).to eql("HOLD-CALL")
+    }
+  end
+
+  it "Mastercard response code should indicate hold call" do
+    expect {
+       Hps::TestHelper.charge_valid_mastercard(10.03)
+    }.to raise_error(Hps::CardException) { |error|
+      expect(error.code).to eql("card_declined")
+      expect(error.response_code).to eql("43")
+      expect(error.response_text).to eql("HOLD-CALL")
+    }
+  end
+
+  it "Mastercard response code should indicate decline" do
+    expect {
+       Hps::TestHelper.charge_valid_mastercard(10.08)
+    }.to raise_error(Hps::CardException) { |error|
+      expect(error.code).to eql("card_declined")
+      expect(error.response_code).to eql("51")
+      expect(error.response_text).to eql("DECLINE")
+    }
+  end
+
+  it "Mastercard response code should indicate expired card" do
+    expect {
+       Hps::TestHelper.charge_valid_mastercard(10.32)
+    }.to raise_error(Hps::CardException) { |error|
+      expect(error.code).to eql("expired_card")
+      expect(error.response_code).to eql("54")
+      expect(error.response_text).to eql("EXPIRED CARD")
+    }
+  end
+
+  it "Mastercard response code should indicate exceeds limit" do
+    expect {
+       Hps::TestHelper.charge_valid_mastercard(10.09)
+    }.to raise_error(Hps::CardException) { |error|
+      expect(error.code).to eql("card_declined")
+      expect(error.response_code).to eql("61")
+      expect(error.response_text).to eql("DECLINE")
+    }
+  end
+
+  it "Mastercard response code should indicate restricted card" do
+    expect {
+       Hps::TestHelper.charge_valid_mastercard(10.10)
+    }.to raise_error(Hps::CardException) { |error|
+      expect(error.code).to eql("card_declined")
+      expect(error.response_code).to eql("62")
+      expect(error.response_text).to eql("DECLINE")
+    }
+  end
+
+  it "Mastercard response code should indicate security violation" do
+    expect {
+       Hps::TestHelper.charge_valid_mastercard(10.19)
+    }.to raise_error(Hps::CardException) { |error|
+      expect(error.code).to eql("card_declined")
+      expect(error.response_code).to eql("63")
+      expect(error.response_text).to eql("SEC VIOLATION")
+    }
+  end
+
+  it "Mastercard response code should indicate exceeds freq limit" do
+    expect {
+       Hps::TestHelper.charge_valid_mastercard(10.11)
+    }.to raise_error(Hps::CardException) { |error|
+      expect(error.code).to eql("card_declined")
+      expect(error.response_code).to eql("65")
+      expect(error.response_text).to eql("DECLINE")
+    }
+  end
+
+  it "Mastercard response code should indicate card no error" do
+    expect {
+       Hps::TestHelper.charge_valid_mastercard(10.14)
+    }.to raise_error(Hps::CardException) { |error|
+      expect(error.code).to eql("incorrect_number")
+      expect(error.response_code).to eql("14")
+      expect(error.response_text).to eql("CARD NO. ERROR")
+    }
+  end
+
+  it "Mastercard response code should indicate invalid account" do
+    expect {
+       Hps::TestHelper.charge_valid_mastercard(10.06)
+    }.to raise_error(Hps::CardException) { |error|
+      expect(error.code).to eql("processing_error")
+      # TODO: Gateway change
+      #expect(error.response_code).to eql("79")
+      expect(error.response_code).to eql("EC")
+      expect(error.response_text).to eql("CID FORMAT ERROR")
+    }
+  end
+
+  # TODO: Gateway change, used to throw exception but now it doesn't
+  it "Mastercard response code should indicate switch not available" do
+    expect {
+       Hps::TestHelper.charge_valid_mastercard(10.33)
+    }.to raise_error(Hps::HpsException) { |error|
+    #}.to raise_error(Hps::CardException) { |error|
+      #expect(error.code).to eql("processing_error")
+      #expect(error.response_code).to eql("14")
+      expect(error.code).to eql("issuer_timeout")
+      expect(error.response_code).to eql("91")
+      expect(error.response_text).to eql("NO REPLY")
+    }
+  end
+
+  it "Mastercard response code should indicate system error" do
+    expect {
+       Hps::TestHelper.charge_valid_mastercard(10.21)
+    }.to raise_error(Hps::CardException) { |error|
+      expect(error.code).to eql("processing_error")
+      expect(error.response_code).to eql("96")
+      expect(error.response_text).to eql("SYSTEM ERROR")
+    }
+  end
+
+  # verify, authorize, refund, and capture
+
+  it "Mastercard verify should return OK" do
+    service = Hps::HpsChargeService.new()
+    result = service.verify(Hps::TestData.valid_mastercard, Hps::TestData.valid_cardholder)
+    expect(result.response_code).to eql("85")
+  end
+
+  it "Mastercard authorize should return OK" do
+    service = Hps::HpsChargeService.new()
+    result = service.authorize(50.00, "usd", Hps::TestData.valid_mastercard, Hps::TestData.valid_cardholder)
+    expect(result.response_code).to eql("00")
+  end
+
+  it "Mastercard authorize and request token should return OK" do
+    service = Hps::HpsChargeService.new()
+    result = service.authorize(50.00, "usd", Hps::TestData.valid_mastercard, Hps::TestData.valid_cardholder, true)
+    expect(result.token_data.response_code).to eql("0")
+    expect(result.response_code).to eql("00")
+  end
+
+  it "Mastercard should refund OK" do
+    service = Hps::HpsChargeService.new()
+    charge = service.charge(25.00, "usd", Hps::TestData.valid_mastercard, Hps::TestData.valid_cardholder)
+    refund = service.refund_transaction(25.00, "usd", charge.transaction_id)
+    expect(refund.response_code).to eql("00")
+  end
+
+  it "Mastercard authorize and capture should return OK" do
+    service = Hps::HpsChargeService.new()
+    result = service.authorize(50.00, "usd", Hps::TestData.valid_mastercard, Hps::TestData.valid_cardholder)
+    expect(result.response_code).to eql("00")
+
+    capture_result = service.capture(result.transaction_id)
+    expect(capture_result.response_code).to eql("00")
+  end
+
+  it "Mastercard card present and reader not present" do
+    service = Hps::HpsChargeService.new()
+    card = Hps::TestData.valid_mastercard
+    card.card_present = true
+    result = service.charge(10.00, "usd", card, Hps::TestData.valid_cardholder)
+    expect(result.response_code).to eql("00")
+  end
+
+  it "Mastercard card present and reader present" do
+    service = Hps::HpsChargeService.new()
+    card = Hps::TestData.valid_mastercard
+    card.card_present = true
+    card.reader_present = true
+    result = service.charge(10.00, "usd", card, Hps::TestData.valid_cardholder)
+    expect(result.response_code).to eql("00")
+  end
+
+  it "Mastercard Dynamic Descriptor Authorize" do
+    service = Hps::HpsChargeService.new()
+    txn_descriptor = "Best Company Ever"
+    result = service.authorize(10.00, "usd", Hps::TestData.valid_mastercard, Hps::TestData.valid_cardholder, false, nil, txn_descriptor)
+    expect(result.response_code).to eql("00")
+    p result.transaction_id
+  end
+
+  it "Mastercard Dynamic Descriptor Charge" do
+    service = Hps::HpsChargeService.new()
+    txn_descriptor = "Best Company Ever"
+    result = service.charge(10.00, "usd", Hps::TestData.valid_mastercard, Hps::TestData.valid_cardholder, false, nil, txn_descriptor)
+    expect(result.response_code).to eql("00")
+    p result.transaction_id
+  end
+
+  it "should charge with mastercard swipe and txn descriptor" do
+    Hps::TestHelper.valid_multi_use_config
+    service = Hps::HpsChargeService.new
+    txn_descriptor = "Best Company Ever"
+    track_data = Hps::HpsTrackData.new
+    track_data.value = '%B5473500000000014^MC TEST CARD^251210199998888777766665555444433332?;5473500000000014=25121019999888877776?'
+    track_data.method_obtained = Hps::HpsTrackDataMethod::SWIPE
+
+    charge = service.charge_swipe(10.00, "usd", track_data, nil, 0, false, txn_descriptor)
+
+    expect(charge).to_not be_nil
+    expect(charge.response_code).to eql("00")
+  end
+
+  it "should authorize with mastercard swipe and txn descriptor" do
+    Hps::TestHelper.valid_multi_use_config
+    service = Hps::HpsChargeService.new
+    txn_descriptor = "Best Company Ever"
+    track_data = Hps::HpsTrackData.new
+    track_data.value = '%B5473500000000014^MC TEST CARD^251210199998888777766665555444433332?;5473500000000014=25121019999888877776?'
+    track_data.method_obtained = Hps::HpsTrackDataMethod::SWIPE
+
+    authorize = service.authorize_swipe(10.00, "usd", track_data, nil, 0, false, txn_descriptor)
+
+    expect(authorize).to_not be_nil
+    expect(authorize.response_code).to eql("00")
+  end
+
+end