hps 2.2.5 → 2.3.2

data/lib/hps/version.rb

@@ -1,3 +1,3 @@
 module Hps
-	VERSION = "2.2.5"
+  VERSION = "2.3.2"
 end

data/tests/certification/gift_card_certification_test.rb

@@ -0,0 +1,107 @@
+require File.join( File.dirname(File.dirname(__FILE__)), "test_helper" )
+
+describe "Gift card certification tests" do
+  let(:service) do
+    Hps::TestHelper.valid_multi_use_config
+    Hps::HpsGiftCardService.new
+  end
+
+  # Test #96
+  it "testActivateSVA1" do
+    activation = service.activate( sva1, 6.00 )
+    expect( activation.response_code ).to eql("0")
+  end
+
+  # Test #97
+  it "testActivateSVA2" do
+    activation = service.activate( sva2, 7.00 )
+    expect( activation.response_code ).to eql("0")
+  end
+
+  # Test #98
+  it "testAddValueSVA1" do
+    add_value = service.add_value( sva1, 8.00 )
+    expect( add_value.response_code ).to eql("0")
+  end
+
+  # Test #99
+  it "testAddValueSVA2" do
+    add_value = service.add_value( sva2, 9.00 )
+    expect( add_value.response_code ).to eql("0")
+  end
+
+  # Test #100
+  it "testBalanceSVA1" do
+    balance = service.balance( sva1 )
+    expect( balance.response_code ).to eql("0")
+    expect( balance.balance_amount.to_i ).to eql(10)
+  end
+
+  # Test #101
+  it "testBalanceSVA2" do
+    balance = service.balance( sva2 )
+    expect( balance.response_code ).to eql("0")
+    expect( balance.balance_amount.to_i ).to eql(10)
+  end
+
+  # Test #102
+  it "testReplaceSVA1" do
+    replace = service.replace(sva1, sva2)
+    expect( replace.response_code ).to eql("0")
+  end
+
+  # Test #103
+  it "testReplaceSVA2" do
+    replace = service.replace(sva2, sva1)
+    expect( replace.response_code ).to eql("0")
+  end
+
+  # Test #104
+  it "testSaleSVA1" do
+    sale = service.sale(sva1, 1.00)
+    expect( sale.response_code ).to eql("0")
+  end
+
+  # Test #105
+  it "testSaleSVA2" do
+    sale = service.sale(sva2, 2.00)
+    expect( sale.response_code ).to eql("0")
+  end
+
+  # Test #106 & Test #108
+  it "testSaleAndVoidSVA1" do
+    sale = service.sale(sva1, 3.00)
+    expect( sale.response_code ).to eql("0")
+    void = service.void(sale.transaction_id)
+    expect( void.response_code ).to eql("0")
+  end
+
+  # Test #107 & Test # 109
+  it "testSaleAndReversalSVA2" do
+    sale = service.sale(sva2, 4.00)
+    expect( sale.response_code ).to eql("0")
+    reverse = service.reverse(sale.transaction_id, 4.00)
+    expect( reverse.response_code ).to eql("0")
+  end
+
+  # Test #110
+  it "testDeactivateSVA1" do
+    deactivate = service.deactivate(sva1)
+    expect( deactivate.response_code ).to eql("0")
+  end
+
+  # Test #111
+  it "testDeactivateSVA1" do
+    deactivate = service.deactivate(sva2)
+    expect( deactivate.response_code ).to eql("0")
+  end
+end
+
+# Helper methods
+def sva1
+  Hps::HpsGiftCard.new(5022440000000000098)
+end
+
+def sva2
+  Hps::HpsGiftCard.new(5022440000000000007)
+end

data/tests/certification/gift_card_certification_tests.rb

@@ -0,0 +1,107 @@
+require File.join( File.dirname(File.dirname(__FILE__)), "test_helper" )
+
+describe "Gift card certification tests" do
+  let(:service) do
+    Hps::TestHelper.valid_multi_use_config
+    Hps::HpsGiftCardService.new
+  end
+
+  # Test #96
+  it "testActivateSVA1" do
+    activation = service.activate( sva1, 6.00 )
+    expect( activation.response_code ).to eql("0")
+  end
+
+  # Test #97
+  it "testActivateSVA2" do
+    activation = service.activate( sva2, 7.00 )
+    expect( activation.response_code ).to eql("0")
+  end
+
+  # Test #98
+  it "testAddValueSVA1" do
+    add_value = service.add_value( sva1, 8.00 )
+    expect( add_value.response_code ).to eql("0")
+  end
+
+  # Test #99
+  it "testAddValueSVA2" do
+    add_value = service.add_value( sva2, 9.00 )
+    expect( add_value.response_code ).to eql("0")
+  end
+
+  # Test #100
+  it "testBalanceSVA1" do
+    balance = service.balance( sva1 )
+    expect( balance.response_code ).to eql("0")
+    expect( balance.balance_amount.to_i ).to eql(10)
+  end
+
+  # Test #101
+  it "testBalanceSVA2" do
+    balance = service.balance( sva2 )
+    expect( balance.response_code ).to eql("0")
+    expect( balance.balance_amount.to_i ).to eql(10)
+  end
+
+  # Test #102
+  it "testReplaceSVA1" do
+    replace = service.replace(sva1, sva2)
+    expect( replace.response_code ).to eql("0")
+  end
+
+  # Test #103
+  it "testReplaceSVA2" do
+    replace = service.replace(sva2, sva1)
+    expect( replace.response_code ).to eql("0")
+  end
+
+  # Test #104
+  it "testSaleSVA1" do
+    sale = service.sale(sva1, 1.00)
+    expect( sale.response_code ).to eql("0")
+  end
+
+  # Test #105
+  it "testSaleSVA2" do
+    sale = service.sale(sva2, 2.00)
+    expect( sale.response_code ).to eql("0")
+  end
+
+  # Test #106 & Test #108
+  it "testSaleAndVoidSVA1" do
+    sale = service.sale(sva1, 3.00)
+    expect( sale.response_code ).to eql("0")
+    void = service.void(sale.transaction_id)
+    expect( void.response_code ).to eql("0")
+  end
+
+  # Test #107 & Test # 109
+  it "testSaleAndReversalSVA2" do
+    sale = service.sale(sva2, 4.00)
+    expect( sale.response_code ).to eql("0")
+    reverse = service.reverse(sale.transaction_id, 4.00)
+    expect( reverse.response_code ).to eql("0")
+  end
+
+  # Test #110
+  it "testDeactivateSVA1" do
+    deactivate = service.deactivate(sva1)
+    expect( deactivate.response_code ).to eql("0")
+  end
+
+  # Test #111
+  it "testDeactivateSVA1" do
+    deactivate = service.deactivate(sva2)
+    expect( deactivate.response_code ).to eql("0")
+  end
+end
+
+# Helper methods
+def sva1
+  Hps::HpsGiftCard.new(5022440000000000098)
+end
+
+def sva2
+  Hps::HpsGiftCard.new(5022440000000000007)
+end

data/tests/exception_mapper_tests.rb

@@ -9,14 +9,14 @@ describe "ExceptionMapper Tests" do
 
 
 	it "mapping version number accessible" do
-		expect(@mapper.version_number).to eq("1.0.0")
-	end	
+		expect(@mapper.version_number).to eq("1.0.1")
+	end
 
 	# Issuer Exceptions
 
 	it "issuer card declined test codes" do
 
-		[ "02", "03", "04", "05", "41", "43", "44", "51", "56", "61", "62", "63", "65", "78" ].each { |code| 
+		[ "02", "03", "04", "05", "41", "43", "44", "51", "56", "61", "62", "63", "65", "78" ].each { |code|
 
 			result = @mapper.map_issuer_exception(1, code, "")
 			expect(result.transaction_id).to eq(1)
@@ -28,7 +28,7 @@ describe "ExceptionMapper Tests" do
 
 	it "issuer processing error test codes" do
 
-		[ "06", "07", "12", "15", "19", "12", "52", "53", "57", "58", "76", "77", "91", "96", "EC" ].each { |code| 
+		[ "06", "07", "12", "15", "19", "12", "52", "53", "57", "58", "76", "77", "91", "96", "EC" ].each { |code|
 
 			result = @mapper.map_issuer_exception(2, code, "")
 			expect(result.transaction_id).to eq(2)
@@ -42,72 +42,72 @@ describe "ExceptionMapper Tests" do
 		result = @mapper.map_issuer_exception(3, "13", "")
 		expect(result.transaction_id).to eq(3)
 		expect(result.code).to eq("invalid_amount")
-		expect(result.message).to eq(message_for_code("Exception_Message_ChargeAmount"))			
+		expect(result.message).to eq(message_for_code("Exception_Message_ChargeAmount"))
 	end
 
 	it "issuer incorrect number test" do
 		result = @mapper.map_issuer_exception(4, "14", "")
 		expect(result.transaction_id).to eq(4)
 		expect(result.code).to eq("incorrect_number")
-		expect(result.message).to eq(message_for_code("Exception_Message_IncorrectNumber"))			
+		expect(result.message).to eq(message_for_code("Exception_Message_IncorrectNumber"))
 	end
 
 	it "issuer expired card test" do
 		result = @mapper.map_issuer_exception(5, "54", "")
 		expect(result.transaction_id).to eq(5)
 		expect(result.code).to eq("expired_card")
-		expect(result.message).to eq(message_for_code("Exception_Message_CardExpired"))			
+		expect(result.message).to eq(message_for_code("Exception_Message_CardExpired"))
 	end
 
 	it "issuer invalid pin test" do
 		result = @mapper.map_issuer_exception(6, "55", "")
 		expect(result.transaction_id).to eq(6)
 		expect(result.code).to eq("invalid_pin")
-		expect(result.message).to eq(message_for_code("Exception_Message_InvalidPin"))			
+		expect(result.message).to eq(message_for_code("Exception_Message_InvalidPin"))
 	end
 
 	it "issuer pin retries exceeded test" do
 		result = @mapper.map_issuer_exception(7, "75", "")
 		expect(result.transaction_id).to eq(7)
 		expect(result.code).to eq("pin_retries_exceeded")
-		expect(result.message).to eq(message_for_code("Exception_Message_PinExceeded"))			
+		expect(result.message).to eq(message_for_code("Exception_Message_PinExceeded"))
 	end
 
 	it "issuer invalid expiry test" do
 		result = @mapper.map_issuer_exception(8, "80", "")
 		expect(result.transaction_id).to eq(8)
 		expect(result.code).to eq("invalid_expiry")
-		expect(result.message).to eq(message_for_code("Exception_Message_InvalidExpiry"))			
+		expect(result.message).to eq(message_for_code("Exception_Message_InvalidExpiry"))
 	end
 
 	it "issuer pin verification test" do
 		result = @mapper.map_issuer_exception(9, "86", "")
 		expect(result.transaction_id).to eq(9)
 		expect(result.code).to eq("pin_verification")
-		expect(result.message).to eq(message_for_code("Exception_Message_PinVerification"))			
+		expect(result.message).to eq(message_for_code("Exception_Message_PinVerification"))
 	end
 
 	it "issuer incorrect cvc test" do
-		[ "EB", "N7" ].each { |code| 
+		[ "EB", "N7" ].each { |code|
 			result = @mapper.map_issuer_exception(10, code, "")
 			expect(result.transaction_id).to eq(10)
 			expect(result.code).to eq("incorrect_cvc")
 			expect(result.message).to eq(message_for_code("Exception_Message_IncorrectCvc"))
-		}	
+		}
 	end
 
 	it "issuer unknown test" do
 		result = @mapper.map_issuer_exception(11, "Foo", "Foo")
 		expect(result.transaction_id).to eq(11)
 		expect(result.code).to eq("unknown_card_exception")
-		expect(result.message).to eq("Foo")			
+		expect(result.message).to eq("Foo")
 	end
 
 	it "issuer nil test" do
 		result = @mapper.map_issuer_exception(0, nil, nil)
 		expect(result.transaction_id).to eq(0)
 		expect(result.code).to eq("unknown_card_exception")
-		expect(result.message).to eq("Hps::CardException")			
+		expect(result.message).to eq("Hps::CardException")
 	end
 
 	# Gateway exceptions
@@ -115,57 +115,57 @@ describe "ExceptionMapper Tests" do
 	it "gateway authentication exception test" do
 		result = @mapper.map_gateway_exception(0, "-2", nil)
 		expect(result.code).to eq("unknown")
-		expect(result.message).to eq(message_for_code("Exception_Message_AuthenticationError"))			
+		expect(result.message).to eq(message_for_code("Exception_Message_AuthenticationError"))
 	end
 
 	it "gateway invalid request exception cpc test" do
 		result = @mapper.map_gateway_exception(0, "12", nil)
 		expect(result.param).to eq("card")
 		expect(result.code).to eq("invalid_cpc_data")
-		expect(result.message).to eq(message_for_code("Exception_Message_InvalidCpcData"))			
+		expect(result.message).to eq(message_for_code("Exception_Message_InvalidCpcData"))
 	end
 
 	it "gateway invalid request exception card data test" do
 		result = @mapper.map_gateway_exception(0, "13", nil)
 		expect(result.param).to eq("card")
 		expect(result.code).to eq("invalid_card_data")
-		expect(result.message).to eq(message_for_code("Exception_Message_InvalidCardData"))			
+		expect(result.message).to eq(message_for_code("Exception_Message_InvalidCardData"))
 	end
 
 	it "gateway card exception test" do
 		result = @mapper.map_gateway_exception(0, "14", nil)
 		expect(result.code).to eq("invalid_number")
-		expect(result.message).to eq(message_for_code("Exception_Message_InvalidNumber"))			
+		expect(result.message).to eq(message_for_code("Exception_Message_InvalidNumber"))
 	end
 
 	it "gateway message passthrough test" do
 		result = @mapper.map_gateway_exception(0, "1", "Foo")
 		expect(result.code).to eq("unknown")
-		expect(result.message).to eq("Foo")			
+		expect(result.message).to eq("Foo")
 	end
 
 	it "gateway invalid original transaction test" do
 		result = @mapper.map_gateway_exception(0, "3", "Foo")
 		expect(result.code).to eq("invalid_original_transaction")
-		expect(result.message).to eq("Foo")			
+		expect(result.message).to eq("Foo")
 	end
 
 	it "gateway no open batch test" do
 		result = @mapper.map_gateway_exception(0, "5", "Foo")
 		expect(result.code).to eq("no_open_batch")
-		expect(result.message).to eq("Foo")			
+		expect(result.message).to eq("Foo")
 	end
 
 	it "gateway timeout test" do
 		result = @mapper.map_gateway_exception(0, "30", nil)
 		expect(result.code).to eq("unknown")
-		expect(result.message).to eq(message_for_code("Exception_Message_GatewayTimedOut"))			
+		expect(result.message).to eq(message_for_code("Exception_Message_GatewayTimedOut"))
 	end
 
 	it "gateway unknown test" do
 		result = @mapper.map_gateway_exception(0, "Foo", "Foo")
 		expect(result.code).to eq("unknown")
-		expect(result.message).to eq("Foo")			
+		expect(result.message).to eq("Foo")
 	end
 
 	# Sdk Exceptions
@@ -174,67 +174,134 @@ describe "ExceptionMapper Tests" do
 		result = @mapper.map_sdk_exception(Hps::SdkCodes.invalid_transaction_id, nil)
 		expect(result.param).to eq("gatewayTransactionId")
 		expect(result.code).to eq("invalid_transaction_id")
-		expect(result.message).to eq(message_for_code("Exception_Message_TransactionIdLessThanEqualZero"))			
-	end	
+		expect(result.message).to eq(message_for_code("Exception_Message_TransactionIdLessThanEqualZero"))
+	end
 
 	it "sdk invalid gateway url test" do
 		result = @mapper.map_sdk_exception(Hps::SdkCodes.invalid_gateway_url, nil)
 		expect(result.param).to eq("HpsServiceUri")
 		expect(result.code).to eq("sdk_exception")
-		expect(result.message).to eq(message_for_code("Exception_Message_InvalidGatewayUrl"))			
-	end	
+		expect(result.message).to eq(message_for_code("Exception_Message_InvalidGatewayUrl"))
+	end
 
 	it "sdk unable to process transaction test" do
 		result = @mapper.map_sdk_exception(Hps::SdkCodes.invalid_gateway_url, nil)
 		expect(result.param).to eq("HpsServiceUri")
 		expect(result.code).to eq("sdk_exception")
-		expect(result.message).to eq(message_for_code("Exception_Message_InvalidGatewayUrl"))			
+		expect(result.message).to eq(message_for_code("Exception_Message_InvalidGatewayUrl"))
 	end
 
 	it "sdk missing currency" do
 		result = @mapper.map_sdk_exception(Hps::SdkCodes.missing_currency, nil)
 		expect(result.param).to eq("currency")
 		expect(result.code).to eq("missing_currency")
-		expect(result.message).to eq(message_for_code("Exception_Message_ArgumentNull"))			
-	end	
+		expect(result.message).to eq(message_for_code("Exception_Message_ArgumentNull"))
+	end
 
 	it "sdk invalid currency" do
 		result = @mapper.map_sdk_exception(Hps::SdkCodes.invalid_currency, nil)
 		expect(result.param).to eq("currency")
 		expect(result.code).to eq("invalid_currency")
-		expect(result.message).to eq(message_for_code("Exception_Message_InvalidCurrency"))			
+		expect(result.message).to eq(message_for_code("Exception_Message_InvalidCurrency"))
 	end
 
 	it "sdk invalid amount" do
 		result = @mapper.map_sdk_exception(Hps::SdkCodes.invalid_amount, nil)
 		expect(result.param).to eq("amount")
 		expect(result.code).to eq("invalid_amount")
-		expect(result.message).to eq(message_for_code("Exception_Message_ChargeAmount"))			
+		expect(result.message).to eq(message_for_code("Exception_Message_ChargeAmount"))
 	end
 
 	it "sdk reversal error after gateway timeout" do
 		result = @mapper.map_sdk_exception(Hps::SdkCodes.reversal_error_after_gateway_timeout, nil)
 		expect(result.code).to eq("gateway_timeout")
-		expect(result.message).to eq(message_for_code("Exception_Message_UnableToReverseTransactionAfterGatewayTimeout"))			
+		expect(result.message).to eq(message_for_code("Exception_Message_UnableToReverseTransactionAfterGatewayTimeout"))
 	end
 
 	it "sdk reversal error after issuer timeout" do
 		result = @mapper.map_sdk_exception(Hps::SdkCodes.reversal_error_after_issuer_timeout, nil)
 		expect(result.code).to eq("issuer_timeout")
-		expect(result.message).to eq(message_for_code("Exception_Message_UnableToReverseTransactionAfterIssuerTimeout"))			
+		expect(result.message).to eq(message_for_code("Exception_Message_UnableToReverseTransactionAfterIssuerTimeout"))
 	end
 
 	it "sdk processing error" do
 		result = @mapper.map_sdk_exception(Hps::SdkCodes.processing_error, nil)
 		expect(result.code).to eq("processing_error")
-		expect(result.message).to eq(message_for_code("Exception_Message_ProcessingError"))			
-	end	
+		expect(result.message).to eq(message_for_code("Exception_Message_ProcessingError"))
+	end
+
+	# GiftCards
+ 	context "Gift card exception mapper" do
+		it "unknown gift card error" do
+		 	%w(1 2 11).each do |n|
+				result = @mapper.map_gift_card_exception(12345, n, "Response Text")
+				expect( result.code ).to eql("unknown_card_exception")
+				expect( result.message ).to eql("Response Text")
+		 	end
+	 	end
+
+		it "invalid card data" do
+			%w(3 8).each do |n|
+				result = @mapper.map_gift_card_exception(12345, n, "Response Text")
+				expect( result.code ).to eql("invalid_card_data")
+				expect( result.message ).to eql(message_for_code("Exception_Message_InvalidCardData"))
+		 	end
+	 	end
+
+		it "expired card error" do
+			%w(4).each do |n|
+				result = @mapper.map_gift_card_exception(12345, n, "Response Text")
+				expect( result.code ).to eql("expired_card")
+				expect( result.message ).to eql(message_for_code("Exception_Message_CardExpired"))
+			end
+		end
+
+		it "declined card error" do
+			%w(5 12).each do |n|
+				result = @mapper.map_gift_card_exception(12345, n, "Response Text")
+				expect( result.code ).to eql("card_declined")
+				expect( result.message ).to eql(message_for_code("Exception_Message_CardDeclined"))
+			end
+		end
+
+		it "processing error" do
+			%w(6 7 10).each do |n|
+				result = @mapper.map_gift_card_exception(12345, n, "Response Text")
+				expect( result.code ).to eql("processing_error")
+				expect( result.message ).to eql(message_for_code("Exception_Message_ProcessingError"))
+			end
+		end
+
+		it "invalid amount error" do
+			%w(9).each do |n|
+				result = @mapper.map_gift_card_exception(12345, n, "Response Text")
+				expect( result.code ).to eql("invalid_amount")
+				expect( result.message ).to eql(message_for_code("Exception_Message_ChargeAmount"))
+			end
+		end
+
+		it "partial approval error" do
+			%w(13).each do |n|
+				result = @mapper.map_gift_card_exception(12345, n, "Response Text")
+				expect( result.code ).to eql("partial_approval")
+				expect( result.message ).to eql(message_for_code("Exception_Message_PartialApproval"))
+			end
+		end
+
+		it "invalid pin error" do
+			%w(14).each do |n|
+				result = @mapper.map_gift_card_exception(12345, n, "Response Text")
+				expect( result.code ).to eql("invalid_pin")
+				expect( result.message ).to eql(message_for_code("Exception_Message_InvalidPin"))
+			end
+		end
+	end
 
 	# Helper methods
 
 	def message_for_code(code)
 
-		mapping = @mapper.exceptions["exception_messages"].detect { |message| 
+		mapping = @mapper.exceptions["exception_messages"].detect { |message|
 			message["code"] == code
 		}