hps 1.0.1

data/lib/hps/services/hps_service.rb

@@ -0,0 +1,128 @@
+require 'active_support/core_ext/hash/conversions'
+
+module Hps
+	class HpsService
+
+		attr_accessor :exception_mapper
+    
+    attr_accessor *Configuration::VALID_CONFIG_KEYS
+
+		def initialize(options={})
+      
+      merged_options = Hps.options.merge(options)
+      
+      Configuration::VALID_CONFIG_KEYS.each do |key|
+        send("#{key}=", merged_options[key])
+      end
+       
+			@exception_mapper = Hps::ExceptionMapper.new
+		end
+
+		#protected
+
+		def doTransaction(transaction)
+
+			if configuration_invalid
+      	raise @exception_mapper.map_sdk_exception(SdkCodes.invalid_transaction_id)
+			end
+      
+      xml = Builder::XmlMarkup.new
+      xml.instruct!(:xml, :encoding => "UTF-8")      
+      xml.SOAP :Envelope, {
+        'xmlns:SOAP' => 'http://schemas.xmlsoap.org/soap/envelope/', 
+        'xmlns:hps' => 'http://Hps.Exchange.PosGateway' } do          
+        xml.SOAP :Body do
+          xml.hps :PosRequest do
+            xml.hps 'Ver1.0'.to_sym do
+              xml.hps :Header do
+                if self.secret_api_key
+                  self.service_uri = gateway_url_for_key self.secret_api_key                          
+                  xml.hps :SecretAPIKey, self.secret_api_key
+                else                  
+            			xml.hps :UserName, self.user_name
+            			xml.hps :Password, self.password                    
+            			xml.hps :DeviceId, self.device_id
+            			xml.hps :LicenseId, self.license_id
+            			xml.hps :SiteId, self.site_id
+                end                   
+          			xml.hps :DeveloperID, self.developer_id if self.developer_id
+          			xml.hps :VersionNbr, self.version_number if self.version_number
+          			xml.hps :SiteTrace, self.site_trace if self.site_trace                  
+              end
+              
+              xml << transaction
+              
+            end              
+          end            
+        end        
+      end   
+      
+			begin
+    
+        uri = URI.parse(self.service_uri)
+        http = Net::HTTP.new uri.host, uri.port
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        data = xml.target!        
+
+        response = http.post(uri.path, data, 'Content-type' => 'text/xml')
+        
+        # NOTE: If the HTTP request was successful
+        if response.is_a? Net::HTTPOK
+          
+          # NOTE: Convert XML to a Hash
+          soap_hash = Hash.from_xml(response.body)
+          # NOTE: Peel away the layers and return only the PosRespose
+          soap_hash["Envelope"]["Body"]["PosResponse"]["Ver1.0"]
+          
+        else
+  				raise @exception_mapper.map_sdk_exception(SdkCodes.unable_to_process_transaction)
+        end
+
+			rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError,
+       Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
+				raise @exception_mapper.map_sdk_exception(SdkCodes.unable_to_process_transaction, e)
+			end
+
+		end
+    
+    def gateway_url_for_key(api_key)
+      
+      gateway_url = "https://posgateway.secureexchange.net/Hps.Exchange.PosGateway/PosGatewayService.asmx?wsdl"
+      
+      if api_key.include? "_uat_"
+
+        gateway_url = "https://posgateway.uat.secureexchange.net/Hps.Exchange.PosGateway/PosGatewayService.asmx?wsdl"
+
+      elsif api_key.include? "_cert_"
+
+        gateway_url = "https://posgateway.cert.secureexchange.net/Hps.Exchange.PosGateway/PosGatewayService.asmx?wsdl" 
+      end      
+      
+      gateway_url
+    end
+
+		def hydrate_transaction_header(header)
+			result = HpsTransactionHeader.new
+			result.gateway_response_code = header["GatewayRspCode"]
+			result.gateway_response_message = header["GatewayRspMsg"]
+			result.response_dt = header["RspDT"]
+			result.client_txn_id = header["GatewayTxnId"]
+			result
+		end
+    
+    private
+    
+		def configuration_invalid
+      self.secret_api_key.nil? and (
+  			self.service_uri.nil? or
+  			self.user_name.nil? or
+  			self.password.nil? or
+  			self.license_id.nil? or 
+  			self.device_id.nil? or 
+  			self.site_id.nil?
+      )
+		end
+
+	end
+end

data/lib/hps/version.rb

@@ -0,0 +1,3 @@
+module Hps
+  VERSION = "1.0.1"
+end

data/tests/amex_tests.rb

@@ -0,0 +1,231 @@
+require File.join( File.dirname(__FILE__), "test_helper" )
+
+
+describe "Amex Tests" do
+  
+  it "Amex when card is ok, should return valid result" do
+    charge = Hps::TestHelper.charge_valid_amex(50)
+    expect(charge.response_code).to eql("00")
+  end
+  
+  # avs tests
+  
+  it "Amex avs result code should equal A" do
+    charge = Hps::TestHelper.charge_valid_amex(90.01)
+    expect(charge.avs_result_code).to eql("A")
+  end
+  
+  it "Amex avs result code should equal N" do
+    charge = Hps::TestHelper.charge_valid_amex(90.02)
+    expect(charge.avs_result_code).to eql("N")
+  end
+  
+  it "Amex avs result code should equal R" do
+    charge = Hps::TestHelper.charge_valid_amex(90.03)
+    expect(charge.avs_result_code).to eql("R")
+  end
+  
+  it "Amex avs result code should equal S" do
+    charge = Hps::TestHelper.charge_valid_amex(90.04)
+    expect(charge.avs_result_code).to eql("S")
+  end
+
+  it "Amex avs result code should equal U" do
+    charge = Hps::TestHelper.charge_valid_amex(90.05)
+    expect(charge.avs_result_code).to eql("U")
+  end 
+  
+  it "Amex avs result code should equal W" do
+    charge = Hps::TestHelper.charge_valid_amex(90.06)
+    expect(charge.avs_result_code).to eql("W")
+  end
+  
+  it "Amex avs result code should equal X" do
+    charge = Hps::TestHelper.charge_valid_amex(90.07)
+    expect(charge.avs_result_code).to eql("X")
+  end 
+  
+  it "Amex avs result code should equal Y" do
+    charge = Hps::TestHelper.charge_valid_amex(90.08)
+    expect(charge.avs_result_code).to eql("Y")
+  end 
+  
+  it "Amex avs result code should equal Z" do
+    charge = Hps::TestHelper.charge_valid_amex(90.09)
+    expect(charge.avs_result_code).to eql("Z")
+  end 
+  
+  # cvv tests
+  
+  # TODO: Gateway code changed, returning Y
+  it "Amex cvv result code should equal M" do
+    charge = Hps::TestHelper.charge_valid_amex(97.01)
+    #expect(charge.cvv_result_code).to eql("M")
+  end
+  
+  it "Amex cvv result code should equal N" do
+    charge = Hps::TestHelper.charge_valid_amex(97.02)
+    expect(charge.cvv_result_code).to eql("N")
+  end
+  
+  it "Amex cvv result code should equal P" do
+    charge = Hps::TestHelper.charge_valid_amex(97.03)
+    expect(charge.cvv_result_code).to eql("P")
+  end
+  
+  # amex to visa 2nd
+  it "Amex response code should indicate denied" do
+    expect {
+       Hps::TestHelper.charge_valid_amex(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 "Amex response code should card expired" do
+    expect {
+       Hps::TestHelper.charge_valid_amex(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 "Amex response code should indicate please call" do
+    expect {
+       Hps::TestHelper.charge_valid_amex(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 "Amex response code should indicate invalid merchant" do
+    expect {
+       Hps::TestHelper.charge_valid_amex(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
+  
+  it "Amex response code should indicate invalid amount" do
+    expect {
+       Hps::TestHelper.charge_valid_amex(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 "Amex response code should indicate no action taken" do
+    expect {
+       Hps::TestHelper.charge_valid_amex(10.14)
+    }.to raise_error(Hps::CardException) { |error| 
+      # TODO: Gateway response changed
+      # expect(error.code).to eql("processing_error")
+      # expect(error.response_code).to eql("76")
+      # expect(error.response_text).to eql("NO ACTION TAKEN")      
+      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 "Amex response code should indicate invalid cvv2" do
+    expect {
+       Hps::TestHelper.charge_valid_amex(10.23)
+    }.to raise_error(Hps::CardException) { |error|      
+      expect(error.code).to eql("incorrect_cvc")
+      expect(error.response_code).to eql("N7")
+      expect(error.response_text).to eql("CVV2 MISMATCH")
+    }
+  end
+  
+  it "Amex response code should indicate invalid originator" do
+    expect {
+       Hps::TestHelper.charge_valid_amex(10.30)
+    }.to raise_error(Hps::CardException) { |error|      
+      expect(error.code).to eql("processing_error")
+      expect(error.response_code).to eql("58")
+      expect(error.response_text).to eql("SERV NOT ALLOWED")
+    }
+  end
+  
+  it "Amex response code should indicate card declined" do
+    expect {
+       Hps::TestHelper.charge_valid_amex(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
+  
+  it "Amex response code should indicate account canceled" do
+    expect {
+       Hps::TestHelper.charge_valid_amex(10.13)
+    }.to raise_error(Hps::CardException) { |error|      
+      expect(error.code).to eql("card_declined")
+      expect(error.response_code).to eql("78")
+      expect(error.response_text).to eql("NO ACCOUNT")
+    }
+  end
+  
+  it "Amex response code should indicate merchant close" do
+    expect {
+       Hps::TestHelper.charge_valid_amex(10.12)
+    }.to raise_error(Hps::CardException) { |error|      
+      expect(error.code).to eql("processing_error")
+      expect(error.response_code).to eql("06")
+      expect(error.response_text).to eql("ERROR")
+    }
+  end
+  
+  it "Amex response code should indicate pickup card" do
+    expect {
+       Hps::TestHelper.charge_valid_amex(10.04)
+    }.to raise_error(Hps::CardException) { |error|      
+      expect(error.code).to eql("card_declined")
+      expect(error.response_code).to eql("44")
+      expect(error.response_text).to eql("HOLD-CALL")
+    }
+  end
+  
+  # verify, authorize & capture
+  
+  it "Amex verify should return OK" do
+    service = Hps::HpsChargeService.new()
+    result = service.verify(Hps::TestData.valid_amex, Hps::TestData.valid_cardholder)
+    expect(result.response_code).to eql("00")  
+  end
+  
+  it "Amex authorize should return OK" do
+    service = Hps::HpsChargeService.new()
+    result = service.authorize(50.00, "usd", Hps::TestData.valid_amex, Hps::TestData.valid_cardholder)
+    expect(result.response_code).to eql("00")  
+  end
+  
+  it "Amex authorize and request token should return OK" do
+    service = Hps::HpsChargeService.new()
+    result = service.authorize(50.00, "usd", Hps::TestData.valid_amex, Hps::TestData.valid_cardholder, true)
+    expect(result.token_data.response_code).to eql("0")
+    expect(result.response_code).to eql("00")  
+  end
+  
+  it "Amex authorize and capture should return OK" do
+    service = Hps::HpsChargeService.new()
+    result = service.authorize(50.00, "usd", Hps::TestData.valid_amex, 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

data/tests/cert_tests.rb

@@ -0,0 +1,81 @@
+require File.join( File.dirname(__FILE__), "test_helper" )
+
+describe "Certification Tests" do
+  
+  RSpec.configure do |config|
+    config.order_groups_and_examples do |tests|
+      tests.sort_by { |test| test.description }
+    end
+  end
+  
+	before(:each) do
+    Hps::TestHelper.configure_hps_module_for_certification()
+		@service = Hps::HpsChargeService.new()
+	end
+  
+  it "A batch should close OK" do
+    begin
+      service = Hps::HpsBatchService.new
+      batch = service.close_batch
+      expect(batch).not_to be_nil
+    rescue => e
+      expect(e.code).to eql("no_open_batch")
+    end
+  end
+  
+  it "B visa should charge OK" do
+    result = @service.charge(17.01, "usd", Hps::TestData.valid_visa, Hps::TestData.cert_cardholder_shortzip)
+    expect(result.response_code).to eql("00")
+  end
+  
+  it "C mastercard should charge OK" do
+    result = @service.charge(17.02, "usd", Hps::TestData.valid_mastercard, Hps::TestData.cert_cardholder_shortzip_no_street)
+    expect(result.response_code).to eql("00")
+  end
+  
+  it "D discover should charge OK" do
+    result = @service.charge(17.03, "usd", Hps::TestData.valid_discover, Hps::TestData.cert_cardholder_longzip_no_street)
+    expect(result.response_code).to eql("00")
+  end 
+  
+  it "E amex should charge OK" do
+    result = @service.charge(17.04, "usd", Hps::TestData.valid_amex, Hps::TestData.cert_cardholder_shortzip)
+    expect(result.response_code).to eql("00")
+  end 
+  
+  it "F jcb should charge OK" do
+    result = @service.charge(17.05, "usd", Hps::TestData.valid_jcb, Hps::TestData.cert_cardholder_longzip)
+    expect(result.response_code).to eql("00")
+  end 
+  
+  it "G visa should verify OK" do
+    result = @service.verify(Hps::TestData.valid_visa)
+    expect(result.response_code).to eql("85")
+  end 
+  
+  it "H mastercard should verify OK" do
+    result = @service.verify(Hps::TestData.valid_mastercard)
+    expect(result.response_code).to eql("85")
+  end 
+  
+  it "I discover should verify OK" do
+    result = @service.verify(Hps::TestData.valid_discover)
+    expect(result.response_code).to eql("85")
+  end 
+  
+  it "J amex should avs should be OK" do
+    result = @service.verify(Hps::TestData.valid_amex, Hps::TestData.cert_cardholder_shortzip_no_street)
+    expect(result.response_code).to eql("00")
+  end 
+  
+  it "K mastercard return should be OK" do
+    result = @service.refund(15.15, "usd", Hps::TestData.valid_mastercard, Hps::TestData.cert_cardholder_shortzip)
+    expect(result.response_code).to eql("00")
+  end 
+  
+  it "L visa should reverse OK" do
+    result = @service.reverse(Hps::TestData.valid_visa, 17.01, "usd")
+    expect(result.response_code).to eql("00")
+  end  
+  
+end

data/tests/discover_tests.rb

@@ -0,0 +1,325 @@
+require File.join( File.dirname(__FILE__), "test_helper" )
+
+describe "Discover Tests" do
+
+  it "Discover when card is ok should return valid result" do
+    charge = Hps::TestHelper.charge_valid_discover(50)
+    expect(charge.response_code).to eql("00")  
+  end
+  
+  it "Discover avs result code should equal A" do
+    charge = Hps::TestHelper.charge_valid_discover(91.01)
+    expect(charge.avs_result_code).to eql("A")
+  end
+  
+  it "Discover avs result code should equal N" do
+    charge = Hps::TestHelper.charge_valid_discover(91.02)
+    expect(charge.avs_result_code).to eql("N")
+  end
+  
+  it "Discover avs result code should equal U" do
+    charge = Hps::TestHelper.charge_valid_discover(91.05)
+    expect(charge.avs_result_code).to eql("U")
+  end
+
+  it "Discover avs result code should equal Y" do
+    charge = Hps::TestHelper.charge_valid_discover(91.06)
+    expect(charge.avs_result_code).to eql("Y")
+  end
+
+  it "Discover avs result code should equal Z" do
+    charge = Hps::TestHelper.charge_valid_discover(91.07)
+    expect(charge.avs_result_code).to eql("Z")    
+  end
+  
+  # discover to 2nd visa
+  
+  it "Discover response code should indicate refer card issuer" do
+    expect {
+       Hps::TestHelper.charge_valid_discover(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 "Discover response code should indicate invalid merchant" do
+    expect {
+       Hps::TestHelper.charge_valid_discover(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
+  
+  it "Discover response code should indicate pickup card" do
+    expect {
+       Hps::TestHelper.charge_valid_discover(10.04)
+    }.to raise_error(Hps::CardException) { |error| 
+      expect(error.code).to eql("card_declined")      
+      expect(error.response_code).to eql("44")
+      expect(error.response_text).to eql("HOLD-CALL")
+    }
+  end
+  
+  it "Discover response code should indicate do not honor" do
+    expect {
+       Hps::TestHelper.charge_valid_discover(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
+  
+  it "Discover response code should indicate invalid transaction" do
+    expect {
+       Hps::TestHelper.charge_valid_discover(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 "Discover response code should indicate invalid amount" do
+    expect {
+       Hps::TestHelper.charge_valid_discover(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 "Discover response code should indicate invalid card" do
+    expect {
+       Hps::TestHelper.charge_valid_discover(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
+
+# TODO: Gateway change, used to raise exception but doesn't now  
+#   it "Discover response code should indicate invalid issuer" do
+#     expect {
+#        Hps::TestHelper.charge_valid_discover(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 "Discover response code should indicate system error re-enter" do
+    expect {
+       Hps::TestHelper.charge_valid_discover(10.29)
+    }.to raise_error(Hps::CardException) { |error| 
+      expect(error.code).to eql("processing_error")      
+      expect(error.response_code).to eql("19")
+      expect(error.response_text).to eql("RE ENTER")
+    }
+  end
+  
+  it "Discover response code should indicate message format error" do
+    expect {
+       Hps::TestHelper.charge_valid_discover(10.06)
+    }.to raise_error(Hps::CardException) { |error| 
+      expect(error.code).to eql("processing_error")      
+      expect(error.response_code).to eql("EC")
+      expect(error.response_text).to eql("CID FORMAT ERROR")
+    }
+  end
+  
+  it "Discover response code should indicate lost card" do
+    expect {
+       Hps::TestHelper.charge_valid_discover(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 "Discover response code should indicate insufficient funds" do
+    expect {
+       Hps::TestHelper.charge_valid_discover(10.08)
+    }.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
+  
+  it "Discover response code should indicate no saving account" do
+    expect {
+       Hps::TestHelper.charge_valid_discover(10.17)
+    }.to raise_error(Hps::CardException) { |error| 
+      expect(error.code).to eql("processing_error")      
+      expect(error.response_code).to eql("53")
+      expect(error.response_text).to eql("NO SAVE ACCOUNT")
+    }
+  end
+  
+  it "Discover response code should indicate expired card" do
+    expect {
+       Hps::TestHelper.charge_valid_discover(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 "Discover response code should indicate no card record" do
+    expect {
+       Hps::TestHelper.charge_valid_discover(10.24)
+    }.to raise_error(Hps::CardException) { |error| 
+      expect(error.code).to eql("card_declined")      
+      expect(error.response_code).to eql("56")
+      expect(error.response_text).to eql("INVALID TRANS")
+    }
+  end
+  
+  it "Discover response code should indicate txn not permitted on card" do
+    expect {
+       Hps::TestHelper.charge_valid_discover(10.20)
+    }.to raise_error(Hps::CardException) { |error| 
+      expect(error.code).to eql("processing_error")      
+      expect(error.response_code).to eql("57")
+      expect(error.response_text).to eql("SERV NOT ALLOWED")
+    }
+  end
+  
+  it "Discover response code should indicate invalid aquirer" do
+    expect {
+       Hps::TestHelper.charge_valid_discover(10.30)
+    }.to raise_error(Hps::CardException) { |error| 
+      expect(error.code).to eql("processing_error")      
+      expect(error.response_code).to eql("58")
+      expect(error.response_text).to eql("SERV NOT ALLOWED")
+    }
+  end
+  
+  it "Discover response code should indicate exceeds limit" do
+    expect {
+       Hps::TestHelper.charge_valid_discover(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 "Discover response code should indicate restricted card" do
+    expect {
+       Hps::TestHelper.charge_valid_discover(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 "Discover response code should indicate security violation" do
+    expect {
+       Hps::TestHelper.charge_valid_discover(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 "Discover response code should indicate exceeds freq limit" do
+    expect {
+       Hps::TestHelper.charge_valid_discover(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 "Discover response code should indicate no account" do
+    expect {
+       Hps::TestHelper.charge_valid_discover(10.13)
+    }.to raise_error(Hps::CardException) { |error| 
+      expect(error.code).to eql("card_declined")      
+      expect(error.response_code).to eql("78")
+      expect(error.response_text).to eql("NO ACCOUNT")
+    }
+  end
+  
+  it "Discover response code should indicate invalid account" do
+    expect {
+       Hps::TestHelper.charge_valid_discover(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
+  
+  # TODO: Gateway change, used to throw exception but now it doesn't
+  # it "Discover response code should indicate switch not available" do
+  #   expect {
+  #      Hps::TestHelper.charge_valid_discover(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 "Discover response code should indicate system error" do
+    expect {
+       Hps::TestHelper.charge_valid_discover(10.26)
+    }.to raise_error(Hps::CardException) { |error| 
+      expect(error.code).to eql("processing_error")      
+      # TODO: Gateway change
+      #expect(error.response_code).to eql("96")
+      #expect(error.response_text).to eql("SYSTEM ERROR")      
+      expect(error.response_code).to eql("12")
+      expect(error.response_text).to eql("INVALID TRANS")
+    }
+  end
+  
+  # Verify, Authorize, and Capture
+  
+  it "Discover verify should return OK" do
+    service = Hps::HpsChargeService.new()
+    result = service.verify(Hps::TestData.valid_discover, Hps::TestData.valid_cardholder)
+    expect(result.response_code).to eql("85")  
+  end
+  
+  it "Discover authorize should return OK" do
+    service = Hps::HpsChargeService.new()
+    result = service.authorize(50.00, "usd", Hps::TestData.valid_discover, Hps::TestData.valid_cardholder)
+    expect(result.response_code).to eql("00")  
+  end
+  
+  it "Discover authorize and request token should return OK" do
+    service = Hps::HpsChargeService.new()
+    result = service.authorize(50.00, "usd", Hps::TestData.valid_discover, Hps::TestData.valid_cardholder, true)
+    expect(result.token_data.response_code).to eql("0")
+    expect(result.response_code).to eql("00")  
+  end
+  
+  it "Discover authorize and capture should return OK" do
+    service = Hps::HpsChargeService.new()
+    result = service.authorize(50.00, "usd", Hps::TestData.valid_discover, 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