public void authInfo()
{
captureGivenAuth capturegivenauth = new captureGivenAuth();
capturegivenauth.amount = 106;
capturegivenauth.orderId = "12344";
authInformation authInfo = new authInformation();
DateTime authDate = new DateTime(2002, 10, 9);
authInfo.authDate = authDate;
authInfo.authCode = "543216";
authInfo.authAmount = 12345;
fraudResult fraudresult = new fraudResult();
fraudresult.avsResult = "12";
fraudresult.cardValidationResult = "123";
fraudresult.authenticationResult = "1";
fraudresult.advancedAVSResult = "123";
authInfo.fraudResult = fraudresult;
capturegivenauth.authInformation = authInfo;
capturegivenauth.orderSource = orderSourceType.ecommerce;
cardType card = new cardType();
card.type = methodOfPaymentTypeEnum.VI;
card.number = "4100000000000000";
card.expDate = "1210";
capturegivenauth.card=card;
captureGivenAuthResponse response = litle.CaptureGivenAuth(capturegivenauth);
Assert.AreEqual("Approved", response.message);
}
public void testAccountUpdate()
{
accountUpdate accountUpdate = new accountUpdate();
accountUpdate.reportGroup = "Planets";
accountUpdate.orderId = "12344";
cardType card = new cardType();
card.type = methodOfPaymentTypeEnum.VI;
card.number = "4100000000000002";
card.expDate = "1210";
accountUpdate.card = card;
var mockLitleResponse = new Mock<litleResponse>();
var mockLitleXmlSerializer = new Mock<litleXmlSerializer>();
mockXmlReader.SetupSequence(XmlReader => XmlReader.ReadOuterXml())
.Returns("<accountUpdateResponse reportGroup=\"Merch01ReportGrp\" xmlns=\"http://www.litle.com/schema\"><litleTxnId>123</litleTxnId><orderId>MERCH01-0002</orderId><response>000</response><responseTime>2010-04-11T15:44:26</responseTime><message>Approved</message></accountUpdateResponse>")
.Returns("<accountUpdateResponse reportGroup=\"Merch01ReportGrp\" xmlns=\"http://www.litle.com/schema\"><litleTxnId>124</litleTxnId><orderId>MERCH01-0002</orderId><response>000</response><responseTime>2010-04-11T15:44:26</responseTime><message>Approved</message></accountUpdateResponse>");
batchResponse mockLitleBatchResponse = new batchResponse();
mockLitleBatchResponse.setAccountUpdateResponseReader(mockXmlReader.Object);
mockLitleResponse.Setup(litleResponse => litleResponse.nextBatchResponse()).Returns(mockLitleBatchResponse);
litleResponse mockedLitleResponse = mockLitleResponse.Object;
mockLitleXmlSerializer.Setup(litleXmlSerializer => litleXmlSerializer.DeserializeObjectFromFile(It.IsAny<String>())).Returns(mockedLitleResponse);
Communications mockedCommunication = mockCommunications.Object;
litle.setCommunication(mockedCommunication);
litleXmlSerializer mockedLitleXmlSerializer = mockLitleXmlSerializer.Object;
litle.setLitleXmlSerializer(mockedLitleXmlSerializer);
litleFile mockedLitleFile = mockLitleFile.Object;
litle.setLitleFile(mockedLitleFile);
litle.setLitleTime(mockLitleTime.Object);
batchRequest litleBatchRequest = new batchRequest();
litleBatchRequest.setLitleFile(mockedLitleFile);
litleBatchRequest.setLitleTime(mockLitleTime.Object);
litleBatchRequest.addAccountUpdate(accountUpdate);
litleBatchRequest.addAccountUpdate(accountUpdate);
litle.addBatch(litleBatchRequest);
string batchFileName = litle.sendToLitle();
litleResponse actualLitleResponse = litle.receiveFromLitle(batchFileName);
batchResponse actualLitleBatchResponse = actualLitleResponse.nextBatchResponse();
accountUpdateResponse actualAccountUpdateResponse1 = actualLitleBatchResponse.nextAccountUpdateResponse();
accountUpdateResponse actualAccountUpdateResponse2 = actualLitleBatchResponse.nextAccountUpdateResponse();
accountUpdateResponse nullAccountUpdateResponse = actualLitleBatchResponse.nextAccountUpdateResponse();
Assert.AreEqual(123, actualAccountUpdateResponse1.litleTxnId);
Assert.AreEqual("000", actualAccountUpdateResponse1.response);
Assert.AreEqual(124, actualAccountUpdateResponse2.litleTxnId);
Assert.AreEqual("000", actualAccountUpdateResponse2.response);
Assert.IsNull(nullAccountUpdateResponse);
mockCommunications.Verify(Communications => Communications.FtpDropOff(It.IsAny<String>(), mockFileName, It.IsAny<Dictionary<String, String>>()));
mockCommunications.Verify(Communications => Communications.FtpPickUp(It.IsAny<String>(), It.IsAny<Dictionary<String, String>>(), mockFileName));
}
public void posWithoutCapabilityAndEntryMode()
{
authorization authorization = new authorization();
authorization.reportGroup = "Planets";
authorization.orderId = "12344";
authorization.amount = 106;
authorization.orderSource = orderSourceType.ecommerce;
pos pos = new pos();
pos.cardholderId = posCardholderIdTypeEnum.pin;
authorization.pos = pos;
cardType card = new cardType();
card.type = methodOfPaymentTypeEnum.VI;
card.number = "4100000000000002";
card.expDate = "1210";
authorization.card = card; //This needs to compile
customBilling cb = new customBilling();
cb.phone = "1112223333"; //This needs to compile too
try
{
litle.Authorize(authorization);
//expected exception;
}
catch (LitleOnlineException e)
{
Assert.True(e.Message.StartsWith("Error validating xml data against the schema"));
}
}
public void complexCaptureGivenAuth()
{
captureGivenAuth capturegivenauth = new captureGivenAuth();
capturegivenauth.amount = 106;
capturegivenauth.orderId = "12344";
authInformation authInfo = new authInformation();
DateTime authDate = new DateTime(2002, 10, 9);
authInfo.authDate = authDate;
authInfo.authCode = "543216";
authInfo.authAmount = 12345;
capturegivenauth.authInformation = authInfo;
contact contact = new contact();
contact.name = "Bob";
contact.city = "lowell";
contact.state = "MA";
contact.email ="litle.com";
capturegivenauth.billToAddress = contact;
processingInstructions processinginstructions = new processingInstructions();
processinginstructions.bypassVelocityCheck = true;
capturegivenauth.processingInstructions = processinginstructions;
capturegivenauth.orderSource = orderSourceType.ecommerce;
cardType card = new cardType();
card.type = methodOfPaymentTypeEnum.VI;
card.number = "4100000000000000";
card.expDate = "1210";
capturegivenauth.card = card;
captureGivenAuthResponse response = litle.CaptureGivenAuth(capturegivenauth);
Assert.AreEqual("Approved", response.message);
}
public void TestSimple()
{
updateSubscription update = new updateSubscription();
update.billingDate = new DateTime(2002, 10, 9);
contact billToAddress = new contact();
billToAddress.name = "Greg Dake";
billToAddress.city = "Lowell";
billToAddress.state = "MA";
billToAddress.email = "*****@*****.**";
update.billToAddress = billToAddress;
cardType card = new cardType();
card.number = "4100000000000001";
card.expDate = "1215";
card.type = methodOfPaymentTypeEnum.VI;
update.card = card;
update.planCode = "abcdefg";
update.subscriptionId = 12345;
var mock = new Mock<Communications>();
mock.Setup(Communications => Communications.HttpPost(It.IsRegex(".*<litleOnlineRequest.*?<updateSubscription>\r\n<subscriptionId>12345</subscriptionId>\r\n<planCode>abcdefg</planCode>\r\n<billToAddress>\r\n<name>Greg Dake</name>.*?</billToAddress>\r\n<card>\r\n<type>VI</type>.*?</card>\r\n<billingDate>2002-10-09</billingDate>\r\n</updateSubscription>\r\n</litleOnlineRequest>.*?.*", RegexOptions.Singleline), It.IsAny<Dictionary<String, String>>()))
.Returns("<litleOnlineResponse version='8.20' response='0' message='Valid Format' xmlns='http://www.litle.com/schema'><updateSubscriptionResponse ><litleTxnId>456</litleTxnId><response>000</response><message>Approved</message><responseTime>2013-09-04</responseTime><subscriptionId>12345</subscriptionId></updateSubscriptionResponse></litleOnlineResponse>");
Communications mockedCommunication = mock.Object;
litle.setCommunication(mockedCommunication);
updateSubscriptionResponse response = litle.UpdateSubscription(update);
Assert.AreEqual("12345", response.subscriptionId);
Assert.AreEqual("456", response.litleTxnId);
Assert.AreEqual("000", response.response);
Assert.NotNull(response.responseTime);
}
public void simpleForceCaptureWithCard()
{
forceCapture forcecapture = new forceCapture();
forcecapture.amount = 106;
forcecapture.orderId = "12344";
forcecapture.orderSource = orderSourceType.ecommerce;
cardType card = new cardType();
card.type = methodOfPaymentTypeEnum.VI;
card.number = "4100000000000001";
card.expDate = "1210";
forcecapture.card = card;
forceCaptureResponse response = litle.ForceCapture(forcecapture);
Assert.AreEqual("Approved", response.message);
}
public void SimpleSaleWithCard()
{
sale saleObj = new sale();
saleObj.amount = 106;
saleObj.litleTxnId = 123456;
saleObj.orderId = "12344";
saleObj.orderSource = orderSourceType.ecommerce;
cardType cardObj = new cardType();
cardObj.type = methodOfPaymentTypeEnum.VI;
cardObj.number = "4100000000000000";
cardObj.expDate = "1210";
saleObj.card = cardObj;
saleResponse responseObj = litle.Sale(saleObj);
StringAssert.AreEqualIgnoringCase("Approved", responseObj.message);
}
public void SimpleCreditWithCard()
{
credit creditObj = new credit();
creditObj.amount = 106;
creditObj.orderId = "2111";
creditObj.orderSource = orderSourceType.ecommerce;
cardType card = new cardType();
card.type = methodOfPaymentTypeEnum.VI;
card.number = "4100000000000001";
card.expDate = "1210";
creditObj.card = card;
creditResponse response = litle.Credit(creditObj);
Assert.AreEqual("Approved", response.message);
}
public void testAddAccountUpdate()
{
accountUpdate accountUpdate = new accountUpdate();
accountUpdate.reportGroup = "Planets";
accountUpdate.orderId = "12344";
cardType card = new cardType();
card.type = methodOfPaymentTypeEnum.VI;
card.number = "4100000000000002";
card.expDate = "1210";
accountUpdate.card = card;
batchRequest.addAccountUpdate(accountUpdate);
Assert.AreEqual(1, batchRequest.getNumAccountUpdates());
mockLitleFile.Verify(litleFile => litleFile.createRandomFile(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<String>(), mockLitleTime.Object));
mockLitleFile.Verify(litleFile => litleFile.AppendLineToFile(mockFilePath, accountUpdate.Serialize()));
}
public void test11()
{
authorization authorization = new authorization();
authorization.orderId = "11";
authorization.amount = 60000;
authorization.orderSource = orderSourceType.ecommerce;
cardType card = new cardType();
card.type = methodOfPaymentTypeEnum.MC;
card.number = "5112010140000004";
card.expDate = "1111";
authorization.card = card;
authorization.allowPartialAuth = true;
authorizationResponse response = litle.Authorize(authorization);
Assert.AreEqual("010", response.response);
Assert.AreEqual("Partially Approved", response.message);
Assert.AreEqual("48000", response.approvedAmount);
}
public void accountUpdateBatch()
{
batchRequest litleBatchRequest = new batchRequest();
accountUpdate accountUpdate1 = new accountUpdate();
accountUpdate1.orderId = "1111";
cardType card = new cardType();
card.type = methodOfPaymentTypeEnum.VI;
card.number = "414100000000000000";
card.expDate = "1210";
accountUpdate1.card = card;
litleBatchRequest.addAccountUpdate(accountUpdate1);
accountUpdate accountUpdate2 = new accountUpdate();
accountUpdate2.orderId = "1112";
accountUpdate2.card = card;
litleBatchRequest.addAccountUpdate(accountUpdate2);
litle.addBatch(litleBatchRequest);
string batchName = litle.sendToLitle();
litle.blockAndWaitForResponse(batchName, estimatedResponseTime(0, 1 * 2));
litleResponse litleResponse = litle.receiveFromLitle(batchName);
Assert.NotNull(litleResponse);
Assert.AreEqual("0", litleResponse.response);
Assert.AreEqual("Valid Format", litleResponse.message);
batchResponse litleBatchResponse = litleResponse.nextBatchResponse();
while (litleBatchResponse != null)
{
accountUpdateResponse accountUpdateResponse = litleBatchResponse.nextAccountUpdateResponse();
while (accountUpdateResponse != null)
{
Assert.AreEqual("301", accountUpdateResponse.response);
accountUpdateResponse = litleBatchResponse.nextAccountUpdateResponse();
}
litleBatchResponse = litleResponse.nextBatchResponse();
}
}
public void SimpleAuthWithCard()
{
authorization authorization = new authorization();
authorization.reportGroup = "Planets";
authorization.orderId = "12344";
authorization.amount = 106;
authorization.orderSource = orderSourceType.ecommerce;
cardType card = new cardType();
card.type = methodOfPaymentTypeEnum.VI;
card.number = "414100000000000000";
card.expDate = "1210";
authorization.card = card; //This needs to compile
customBilling cb = new customBilling();
cb.phone = "1112223333"; //This needs to compile too
authorizationResponse response = litle.Authorize(authorization);
Assert.AreEqual("000", response.response);
}
public void test15()
{
authorization authorization = new authorization();
authorization.orderId = "15";
authorization.amount = 3000;
authorization.orderSource = orderSourceType.ecommerce;
cardType card = new cardType();
card.type = methodOfPaymentTypeEnum.MC;
card.number = "5500000254444445";
card.expDate = "0312";
authorization.card = card;
authorizationResponse response = litle.Authorize(authorization);
Assert.AreEqual("000", response.response);
Assert.AreEqual("Approved", response.message);
Assert.AreEqual(fundingSourceTypeEnum.PREPAID, response.enhancedAuthResponse.fundingSource.type);
Assert.AreEqual("2000", response.enhancedAuthResponse.fundingSource.availableBalance);
Assert.AreEqual("YES", response.enhancedAuthResponse.fundingSource.reloadable);
Assert.AreEqual("PAYROLL", response.enhancedAuthResponse.fundingSource.prepaidCardType);
}
public void test32()
{
authorization auth = new authorization();
auth.orderId = "32";
auth.amount = 10010;
auth.orderSource = orderSourceType.ecommerce;
contact billToAddress = new contact();
billToAddress.name = "John Smith";
billToAddress.addressLine1 = "1 Main St.";
billToAddress.city = "Burlington";
billToAddress.state = "MA";
billToAddress.zip = "01803-3747";
billToAddress.country = countryTypeEnum.US;
auth.billToAddress = billToAddress;
cardType card = new cardType();
card.number = "4457010000000009";
card.expDate = "0112";
card.cardValidationNum = "349";
card.type = methodOfPaymentTypeEnum.VI;
auth.card = card;
authorizationResponse authorizeResponse = litle.Authorize(auth);
Assert.AreEqual("000", authorizeResponse.response);
Assert.AreEqual("Approved", authorizeResponse.message);
Assert.AreEqual("11111 ", authorizeResponse.authCode);
Assert.AreEqual("01", authorizeResponse.fraudResult.avsResult);
Assert.AreEqual("M", authorizeResponse.fraudResult.cardValidationResult);
capture capture = new capture();
capture.litleTxnId = authorizeResponse.litleTxnId;
capture.amount = 5005;
captureResponse captureResponse = litle.Capture(capture);
Assert.AreEqual("000", captureResponse.response);
Assert.AreEqual("Approved", captureResponse.message);
authReversal reversal = new authReversal();
reversal.litleTxnId = authorizeResponse.litleTxnId;
authReversalResponse reversalResponse = litle.AuthReversal(reversal);
Assert.AreEqual("111", reversalResponse.response);
Assert.AreEqual("Authorization amount has already been depleted", reversalResponse.message);
}
public void testAddAuthorization()
{
authorization authorization = new authorization();
authorization.reportGroup = "Planets";
authorization.orderId = "12344";
authorization.amount = 106;
authorization.orderSource = orderSourceType.ecommerce;
cardType card = new cardType();
card.type = methodOfPaymentTypeEnum.VI;
card.number = "4100000000000002";
card.expDate = "1210";
authorization.card = card;
batchRequest.addAuthorization(authorization);
Assert.AreEqual(1, batchRequest.getNumAuthorization());
Assert.AreEqual(authorization.amount, batchRequest.getSumOfAuthorization());
mockLitleFile.Verify(litleFile => litleFile.createRandomFile(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<String>(), mockLitleTime.Object));
mockLitleFile.Verify(litleFile => litleFile.AppendLineToFile(mockFilePath, authorization.Serialize()));
}
public void ProcessingInstructionAndAmexData()
{
credit creditObj = new credit();
creditObj.amount = 2000;
creditObj.orderId = "12344";
creditObj.orderSource = orderSourceType.ecommerce;
processingInstructions processingInstructionsObj = new processingInstructions();
processingInstructionsObj.bypassVelocityCheck = true;
creditObj.processingInstructions = processingInstructionsObj;
cardType card = new cardType();
card.type = methodOfPaymentTypeEnum.VI;
card.number = "4100000000000001";
card.expDate = "1210";
creditObj.card = card;
creditResponse response = litle.Credit(creditObj);
Assert.AreEqual("Approved", response.message);
}
public void AuthWithAmpersand()
{
authorization authorization = new authorization();
authorization.orderId = "1";
authorization.amount = 10010;
authorization.orderSource = orderSourceType.ecommerce;
contact contact = new contact();
contact.name = "John & Jane Smith";
contact.addressLine1 = "1 Main St.";
contact.city = "Burlington";
contact.state = "MA";
contact.zip = "01803-3747";
contact.country = countryTypeEnum.US;
authorization.billToAddress = contact;
cardType card = new cardType();
card.type = methodOfPaymentTypeEnum.VI;
card.number = "4457010000000009";
card.expDate = "0112";
card.cardValidationNum = "349";
authorization.card = card;
authorizationResponse response = litle.Authorize(authorization);
Assert.AreEqual("000", response.response);
}
public void TestAuth()
{
authorization authorization = new authorization();
authorization.reportGroup = "Planets";
authorization.orderId = "12344";
authorization.amount = 106;
authorization.orderSource = orderSourceType.ecommerce;
cardType card = new cardType();
card.type = methodOfPaymentTypeEnum.VI;
card.number = "4100000000000002";
card.expDate = "1210";
authorization.card = card;
var mock = new Mock<Communications>();
mock.Setup(Communications => Communications.HttpPost(It.IsRegex(".*<litleOnlineRequest.*<authorization.*<card>.*<number>4100000000000002</number>.*</card>.*</authorization>.*", RegexOptions.Singleline), It.IsAny<Dictionary<String, String>>()))
.Returns("<litleOnlineResponse version='8.10' response='0' message='Valid Format' xmlns='http://www.litle.com/schema'><authorizationResponse><litleTxnId>123</litleTxnId></authorizationResponse></litleOnlineResponse>");
Communications mockedCommunication = mock.Object;
litle.setCommunication(mockedCommunication);
authorizationResponse authorize = litle.Authorize(authorization);
Assert.AreEqual(123, authorize.litleTxnId);
}
public void testUpdateSubscription()
{
updateSubscription update = new updateSubscription();
update.billingDate = new DateTime(2002, 10, 9);
contact billToAddress = new contact();
billToAddress.name = "Greg Dake";
billToAddress.city = "Lowell";
billToAddress.state = "MA";
billToAddress.email = "*****@*****.**";
update.billToAddress = billToAddress;
cardType card = new cardType();
card.number = "4100000000000001";
card.expDate = "1215";
card.type = methodOfPaymentTypeEnum.VI;
update.card = card;
update.planCode = "abcdefg";
update.subscriptionId = 12345;
var mockLitleResponse = new Mock<litleResponse>();
var mockLitleXmlSerializer = new Mock<litleXmlSerializer>();
mockXmlReader.SetupSequence(XmlReader => XmlReader.ReadOuterXml())
.Returns("<updateSubscriptionResponse xmlns=\"http://www.litle.com/schema\"><litleTxnId>54321</litleTxnId><response>000</response><message>Approved</message><responseTime>2013-09-04T21:55:14</responseTime><subscriptionId>12345</subscriptionId></updateSubscriptionResponse>")
.Returns("<updateSubscriptionResponse xmlns=\"http://www.litle.com/schema\"><litleTxnId>12345</litleTxnId><response>000</response><message>Approved</message><responseTime>2013-09-04T21:55:14</responseTime><subscriptionId>54321</subscriptionId></updateSubscriptionResponse>");
batchResponse mockLitleBatchResponse = new batchResponse();
mockLitleBatchResponse.setUpdateSubscriptionResponseReader(mockXmlReader.Object);
mockLitleResponse.Setup(litleResponse => litleResponse.nextBatchResponse()).Returns(mockLitleBatchResponse);
litleResponse mockedLitleResponse = mockLitleResponse.Object;
mockLitleXmlSerializer.Setup(litleXmlSerializer => litleXmlSerializer.DeserializeObjectFromFile(It.IsAny<String>())).Returns(mockedLitleResponse);
Communications mockedCommunication = mockCommunications.Object;
litle.setCommunication(mockedCommunication);
litleXmlSerializer mockedLitleXmlSerializer = mockLitleXmlSerializer.Object;
litle.setLitleXmlSerializer(mockedLitleXmlSerializer);
litleFile mockedLitleFile = mockLitleFile.Object;
litle.setLitleFile(mockedLitleFile);
litle.setLitleTime(mockLitleTime.Object);
batchRequest litleBatchRequest = new batchRequest();
litleBatchRequest.setLitleFile(mockedLitleFile);
litleBatchRequest.setLitleTime(mockLitleTime.Object);
litleBatchRequest.addUpdateSubscription(update);
litle.addBatch(litleBatchRequest);
string batchFileName = litle.sendToLitle();
litleResponse actualLitleResponse = litle.receiveFromLitle(batchFileName);
batchResponse actualLitleBatchResponse = actualLitleResponse.nextBatchResponse();
Assert.AreSame(mockLitleBatchResponse, actualLitleBatchResponse);
Assert.AreEqual("12345", actualLitleBatchResponse.nextUpdateSubscriptionResponse().subscriptionId);
Assert.AreEqual("54321", actualLitleBatchResponse.nextUpdateSubscriptionResponse().subscriptionId);
Assert.IsNull(actualLitleBatchResponse.nextUpdateSubscriptionResponse());
mockCommunications.Verify(Communications => Communications.FtpDropOff(It.IsAny<String>(), mockFileName, It.IsAny<Dictionary<String, String>>()));
mockCommunications.Verify(Communications => Communications.FtpPickUp(It.IsAny<String>(), It.IsAny<Dictionary<String, String>>(), mockFileName));
}
public void test33()
{
authorization auth = new authorization();
auth.orderId = "33";
auth.amount = 20020;
auth.orderSource = orderSourceType.ecommerce;
contact billToAddress = new contact();
billToAddress.name = "Mike J. Hammer";
billToAddress.addressLine1 = "2 Main St.";
billToAddress.addressLine2 = "Apt. 222";
billToAddress.city = "Riverside";
billToAddress.state = "RI";
billToAddress.zip = "02915";
billToAddress.country = countryTypeEnum.US;
auth.billToAddress = billToAddress;
cardType card = new cardType();
card.number = "5112010000000003";
card.expDate = "0212";
card.cardValidationNum = "261";
card.type = methodOfPaymentTypeEnum.MC;
auth.card = card;
fraudCheckType fraud = new fraudCheckType();
fraud.authenticationValue = "BwABBJQ1AgAAAAAgJDUCAAAAAAA=";
auth.cardholderAuthentication = fraud;
authorizationResponse authorizeResponse = litle.Authorize(auth);
Assert.AreEqual("000", authorizeResponse.response);
Assert.AreEqual("Approved", authorizeResponse.message);
Assert.AreEqual("22222", authorizeResponse.authCode);
Assert.AreEqual("10", authorizeResponse.fraudResult.avsResult);
Assert.AreEqual("M", authorizeResponse.fraudResult.cardValidationResult);
authReversal reversal = new authReversal();
reversal.litleTxnId = authorizeResponse.litleTxnId;
authReversalResponse reversalResponse = litle.AuthReversal(reversal);
Assert.AreEqual("000", reversalResponse.response);
Assert.AreEqual("Approved", reversalResponse.message);
}
public void test36()
{
authorization auth = new authorization();
auth.orderId = "36";
auth.amount = 20500;
auth.orderSource = orderSourceType.ecommerce;
cardType card = new cardType();
card.number = "375000026600004";
card.expDate = "0512";
card.type = methodOfPaymentTypeEnum.AX;
auth.card = card;
authorizationResponse authorizeResponse = litle.Authorize(auth);
Assert.AreEqual("000", authorizeResponse.response);
Assert.AreEqual("Approved", authorizeResponse.message);
authReversal reversal = new authReversal();
reversal.litleTxnId = authorizeResponse.litleTxnId;
reversal.amount = 10000;
authReversalResponse reversalResponse = litle.AuthReversal(reversal);
Assert.AreEqual("336", reversalResponse.response);
Assert.AreEqual("Reversal Amount does not match Authorization amount", reversalResponse.message);
}
public void test35()
{
authorization auth = new authorization();
auth.orderId = "35";
auth.amount = 40040;
auth.orderSource = orderSourceType.ecommerce;
contact billToAddress = new contact();
billToAddress.name = "Bob Black";
billToAddress.addressLine1 = "4 Main St.";
billToAddress.city = "Laurel";
billToAddress.state = "MD";
billToAddress.zip = "20708";
billToAddress.country = countryTypeEnum.US;
auth.billToAddress = billToAddress;
cardType card = new cardType();
card.number = "375001000000005";
card.expDate = "0412";
card.type = methodOfPaymentTypeEnum.AX;
auth.card = card;
authorizationResponse authorizeResponse = litle.Authorize(auth);
Assert.AreEqual("000", authorizeResponse.response);
Assert.AreEqual("Approved", authorizeResponse.message);
Assert.AreEqual("44444", authorizeResponse.authCode);
Assert.AreEqual("12", authorizeResponse.fraudResult.avsResult);
capture capture = new capture();
capture.litleTxnId = authorizeResponse.litleTxnId;
capture.amount = 20020;
captureResponse captureResponse = litle.Capture(capture);
Assert.AreEqual("000", captureResponse.response);
Assert.AreEqual("Approved", captureResponse.message);
authReversal reversal = new authReversal();
reversal.litleTxnId = authorizeResponse.litleTxnId;
reversal.amount = 20020;
authReversalResponse reversalResponse = litle.AuthReversal(reversal);
Assert.AreEqual("000", reversalResponse.response);
Assert.AreEqual("Approved", reversalResponse.message);
}
public void test34()
{
authorization auth = new authorization();
auth.orderId = "34";
auth.amount = 30030;
auth.orderSource = orderSourceType.ecommerce;
contact billToAddress = new contact();
billToAddress.name = "Eileen Jones";
billToAddress.addressLine1 = "3 Main St.";
billToAddress.city = "Bloomfield";
billToAddress.state = "CT";
billToAddress.zip = "06002";
billToAddress.country = countryTypeEnum.US;
auth.billToAddress = billToAddress;
cardType card = new cardType();
card.number = "6011010000000003";
card.expDate = "0312";
card.cardValidationNum = "758";
card.type = methodOfPaymentTypeEnum.DI;
auth.card = card;
authorizationResponse authorizeResponse = litle.Authorize(auth);
Assert.AreEqual("000", authorizeResponse.response);
Assert.AreEqual("Approved", authorizeResponse.message);
Assert.AreEqual("33333", authorizeResponse.authCode);
Assert.AreEqual("10", authorizeResponse.fraudResult.avsResult);
Assert.AreEqual("M", authorizeResponse.fraudResult.cardValidationResult);
authReversal reversal = new authReversal();
reversal.litleTxnId = authorizeResponse.litleTxnId;
authReversalResponse reversalResponse = litle.AuthReversal(reversal);
Assert.AreEqual("000", reversalResponse.response);
Assert.AreEqual("Approved", reversalResponse.message);
}
public void SimpleSaleWithInvalidFraudCheck()
{
sale saleObj = new sale();
saleObj.amount = 106;
saleObj.litleTxnId = 123456;
saleObj.orderId = "12344";
saleObj.orderSource = orderSourceType.ecommerce;
cardType cardObj = new cardType();
cardObj.type = methodOfPaymentTypeEnum.VI;
cardObj.number = "4100000000000000";
cardObj.expDate = "1210";
saleObj.card = cardObj;
fraudCheckType cardholderAuthentication = new fraudCheckType();
cardholderAuthentication.authenticationValue = "123456789012345678901234567890123456789012345678901234567890";
saleObj.cardholderAuthentication = cardholderAuthentication;
try
{
saleResponse responseObj = litle.Sale(saleObj);
}
catch (LitleOnlineException e)
{
Assert.True(e.Message.StartsWith("Error validating xml data against the schema"));
}
}
public void testForceCapture()
{
forceCapture forcecapture = new forceCapture();
forcecapture.orderId = "12344";
forcecapture.amount = 106;
forcecapture.orderSource = orderSourceType.ecommerce;
cardType card = new cardType();
card.type = methodOfPaymentTypeEnum.VI;
card.number = "4100000000000001";
card.expDate = "1210";
forcecapture.card = card;
var mockLitleResponse = new Mock<litleResponse>();
var mockLitleXmlSerializer = new Mock<litleXmlSerializer>();
mockXmlReader.SetupSequence(XmlReader => XmlReader.ReadOuterXml())
.Returns("<forceCaptureResponse xmlns='http://www.litle.com/schema'><litleTxnId>123</litleTxnId></forceCaptureResponse>")
.Returns("<forceCaptureResponse xmlns='http://www.litle.com/schema'><litleTxnId>124</litleTxnId></forceCaptureResponse>");
batchResponse mockedLitleBatchResponse = new batchResponse();
mockedLitleBatchResponse.setForceCaptureResponseReader(mockXmlReader.Object);
mockLitleResponse.Setup(litleResponse => litleResponse.nextBatchResponse()).Returns(mockedLitleBatchResponse);
litleResponse mockedLitleResponse = mockLitleResponse.Object;
Communications mockedCommunications = mockCommunications.Object;
mockLitleXmlSerializer.Setup(litleXmlSerializer => litleXmlSerializer.DeserializeObjectFromFile(It.IsAny<String>())).Returns(mockedLitleResponse);
litleXmlSerializer mockedLitleXmlSerializer = mockLitleXmlSerializer.Object;
litleFile mockedLitleFile = mockLitleFile.Object;
litle.setCommunication(mockedCommunications);
litle.setLitleXmlSerializer(mockedLitleXmlSerializer);
litle.setLitleFile(mockedLitleFile);
litle.setLitleTime(mockLitleTime.Object);
batchRequest litleBatchRequest = new batchRequest();
litleBatchRequest.setLitleFile(mockedLitleFile);
litleBatchRequest.setLitleTime(mockLitleTime.Object);
litleBatchRequest.addForceCapture(forcecapture);
litleBatchRequest.addForceCapture(forcecapture);
litle.addBatch(litleBatchRequest);
string batchFileName = litle.sendToLitle();
litleResponse actualLitleResponse = litle.receiveFromLitle(batchFileName);
batchResponse actualLitleBatchResponse = actualLitleResponse.nextBatchResponse();
forceCaptureResponse actualForceCaptureResponse1 = actualLitleBatchResponse.nextForceCaptureResponse();
forceCaptureResponse actualForceCaptureResponse2 = actualLitleBatchResponse.nextForceCaptureResponse();
forceCaptureResponse nullForceCaptureResponse = actualLitleBatchResponse.nextForceCaptureResponse();
Assert.AreEqual(123, actualForceCaptureResponse1.litleTxnId);
Assert.AreEqual(124, actualForceCaptureResponse2.litleTxnId);
Assert.IsNull(nullForceCaptureResponse);
mockCommunications.Verify(Communications => Communications.FtpDropOff(It.IsAny<String>(), mockFileName, It.IsAny<Dictionary<String, String>>()));
mockCommunications.Verify(Communications => Communications.FtpPickUp(It.IsAny<String>(), It.IsAny<Dictionary<String, String>>(), mockFileName));
}
public void testDefaultReportGroup()
{
authorization authorization = new authorization();
authorization.orderId = "12344";
authorization.amount = 106;
authorization.orderSource = orderSourceType.ecommerce;
cardType card = new cardType();
card.type = methodOfPaymentTypeEnum.VI;
card.number = "4100000000000002";
card.expDate = "1210";
authorization.card = card;
var mockLitleResponse = new Mock<litleResponse>();
var mockLitleXmlSerializer = new Mock<litleXmlSerializer>();
mockXmlReader.SetupSequence(XmlReader => XmlReader.ReadOuterXml())
.Returns("<authorizationResponse reportGroup=\"Default Report Group\" xmlns='http://www.litle.com/schema'><litleTxnId>123</litleTxnId></authorizationResponse>")
.Returns("<authorizationResponse reportGroup=\"Default Report Group\" xmlns='http://www.litle.com/schema'><litleTxnId>124</litleTxnId></authorizationResponse>");
batchResponse mockedLitleBatchResponse = new batchResponse();
mockedLitleBatchResponse.setAuthorizationResponseReader(mockXmlReader.Object);
mockLitleResponse.Setup(litleResponse => litleResponse.nextBatchResponse()).Returns(mockedLitleBatchResponse);
litleResponse mockedLitleResponse = mockLitleResponse.Object;
Communications mockedCommunications = mockCommunications.Object;
mockLitleXmlSerializer.Setup(litleXmlSerializer => litleXmlSerializer.DeserializeObjectFromFile(It.IsAny<String>())).Returns(mockedLitleResponse);
litleXmlSerializer mockedLitleXmlSerializer = mockLitleXmlSerializer.Object;
litleFile mockedLitleFile = mockLitleFile.Object;
litle.setCommunication(mockedCommunications);
litle.setLitleXmlSerializer(mockedLitleXmlSerializer);
litle.setLitleFile(mockedLitleFile);
litle.setLitleTime(mockLitleTime.Object);
batchRequest litleBatchRequest = new batchRequest();
litleBatchRequest.setLitleFile(mockedLitleFile);
litleBatchRequest.setLitleTime(mockLitleTime.Object);
litleBatchRequest.addAuthorization(authorization);
litleBatchRequest.addAuthorization(authorization);
litle.addBatch(litleBatchRequest);
string batchFileName = litle.sendToLitle();
litleResponse actualLitleResponse = litle.receiveFromLitle(batchFileName);
batchResponse actualLitleBatchResponse = actualLitleResponse.nextBatchResponse();
authorizationResponse actualAuthorizationResponse1 = actualLitleBatchResponse.nextAuthorizationResponse();
authorizationResponse actualAuthorizationResponse2 = actualLitleBatchResponse.nextAuthorizationResponse();
authorizationResponse nullAuthorizationResponse = actualLitleBatchResponse.nextAuthorizationResponse();
Assert.AreEqual(123, actualAuthorizationResponse1.litleTxnId);
Assert.AreEqual("Default Report Group", actualAuthorizationResponse1.reportGroup);
Assert.AreEqual(124, actualAuthorizationResponse2.litleTxnId);
Assert.AreEqual("Default Report Group", actualAuthorizationResponse2.reportGroup);
Assert.IsNull(nullAuthorizationResponse);
mockLitleFile.Verify(litleFile => litleFile.AppendLineToFile(mockFilePath, It.IsRegex(".*reportGroup=\"Default Report Group\".*", RegexOptions.Singleline)));
mockCommunications.Verify(Communications => Communications.FtpDropOff(It.IsAny<String>(), mockFileName, It.IsAny<Dictionary<String, String>>()));
mockCommunications.Verify(Communications => Communications.FtpPickUp(It.IsAny<String>(), It.IsAny<Dictionary<String, String>>(), mockFileName));
}
public void test56()
{
authorization auth = new authorization();
auth.orderId = "56";
auth.amount = 15000;
auth.orderSource = orderSourceType.ecommerce;
cardType card = new cardType();
card.number = "5435109999999999";
card.expDate = "1112";
card.cardValidationNum = "987";
card.type = methodOfPaymentTypeEnum.MC;
auth.card = card;
authorizationResponse response = litle.Authorize(auth);
Assert.AreEqual("301", response.response);
Assert.AreEqual("Invalid account number", response.message);
}
public void testSerialize()
{
authorization authorization = new authorization();
authorization.orderId = "12344";
authorization.amount = 106;
authorization.orderSource = orderSourceType.ecommerce;
cardType card = new cardType();
card.type = methodOfPaymentTypeEnum.VI;
card.number = "4100000000000002";
card.expDate = "1210";
authorization.card = card;
litleFile mockedLitleFile = mockLitleFile.Object;
litleTime mockedLitleTime = mockLitleTime.Object;
litle.setLitleTime(mockedLitleTime);
litle.setLitleFile(mockedLitleFile);
batchRequest litleBatchRequest = new batchRequest();
litleBatchRequest.setLitleFile(mockedLitleFile);
litleBatchRequest.addAuthorization(authorization);
litle.addBatch(litleBatchRequest);
string resultFile = litle.Serialize();
Assert.IsTrue(resultFile.Equals(mockFilePath));
mockLitleFile.Verify(litleFile => litleFile.AppendFileToFile(mockFilePath, It.IsAny<String>()));
}
public void test57()
{
authorization auth = new authorization();
auth.orderId = "57";
auth.amount = 15000;
auth.orderSource = orderSourceType.ecommerce;
cardType card = new cardType();
card.number = "5435101234510196";
card.expDate = "1112";
card.cardValidationNum = "987";
card.type = methodOfPaymentTypeEnum.MC;
auth.card = card;
authorizationResponse response = litle.Authorize(auth);
Assert.AreEqual("000", response.response);
Assert.AreEqual("Approved", response.message);
Assert.AreEqual("802", response.tokenResponse.tokenResponseCode);
Assert.AreEqual("Account number was previously registered", response.tokenResponse.tokenMessage);
Assert.AreEqual(methodOfPaymentTypeEnum.MC, response.tokenResponse.type);
Assert.AreEqual("543510", response.tokenResponse.bin);
}
public void testAuth()
{
authorization authorization = new authorization();
authorization.reportGroup = "Planets";
authorization.orderId = "12344";
authorization.amount = 106;
authorization.orderSource = orderSourceType.ecommerce;
cardType card = new cardType();
card.type = methodOfPaymentTypeEnum.VI;
card.number = "4100000000000002";
card.expDate = "1210";
authorization.card = card;
var mockLitleResponse = new Mock<litleResponse>();
var mockLitleXmlSerializer = new Mock<litleXmlSerializer>();
mockXmlReader.SetupSequence(XmlReader => XmlReader.ReadOuterXml())
.Returns("<authorizationResponse id=\"\" reportGroup=\"Planets\" xmlns=\"http://www.litle.com/schema\"><litleTxnId>123</litleTxnId><orderId>123</orderId><response>000</response><responseTime>2013-06-19T19:54:42</responseTime><message>Approved</message><authCode>123457</authCode><fraudResult><avsResult>00</avsResult></fraudResult><tokenResponse><litleToken>1711000103054242</litleToken><tokenResponseCode>802</tokenResponseCode><tokenMessage>Account number was previously registered</tokenMessage><type>VI</type><bin>424242</bin></tokenResponse></authorizationResponse>")
.Returns("<authorizationResponse id=\"\" reportGroup=\"Planets\" xmlns=\"http://www.litle.com/schema\"><litleTxnId>124</litleTxnId><orderId>124</orderId><response>000</response><responseTime>2013-06-19T19:54:42</responseTime><message>Approved</message><authCode>123457</authCode><fraudResult><avsResult>00</avsResult></fraudResult><tokenResponse><litleToken>1711000103054242</litleToken><tokenResponseCode>802</tokenResponseCode><tokenMessage>Account number was previously registered</tokenMessage><type>VI</type><bin>424242</bin></tokenResponse></authorizationResponse>");
batchResponse mockLitleBatchResponse = new batchResponse();
mockLitleBatchResponse.setAuthorizationResponseReader(mockXmlReader.Object);
mockLitleResponse.Setup(litleResponse => litleResponse.nextBatchResponse()).Returns(mockLitleBatchResponse);
litleResponse mockedLitleResponse = mockLitleResponse.Object;
mockLitleXmlSerializer.Setup(litleXmlSerializer => litleXmlSerializer.DeserializeObjectFromFile(It.IsAny<String>())).Returns(mockedLitleResponse);
Communications mockedCommunication = mockCommunications.Object;
litle.setCommunication(mockedCommunication);
litleXmlSerializer mockedLitleXmlSerializer = mockLitleXmlSerializer.Object;
litle.setLitleXmlSerializer(mockedLitleXmlSerializer);
litleFile mockedLitleFile = mockLitleFile.Object;
litle.setLitleFile(mockedLitleFile);
litle.setLitleTime(mockLitleTime.Object);
batchRequest litleBatchRequest = new batchRequest();
litleBatchRequest.setLitleFile(mockedLitleFile);
litleBatchRequest.setLitleTime(mockLitleTime.Object);
litleBatchRequest.addAuthorization(authorization);
litleBatchRequest.addAuthorization(authorization);
litle.addBatch(litleBatchRequest);
string batchFileName = litle.sendToLitle();
litleResponse actualLitleResponse = litle.receiveFromLitle(batchFileName);
batchResponse actualLitleBatchResponse = actualLitleResponse.nextBatchResponse();
Assert.AreSame(mockLitleBatchResponse, actualLitleBatchResponse);
Assert.AreEqual(123, actualLitleBatchResponse.nextAuthorizationResponse().litleTxnId);
Assert.AreEqual(124, actualLitleBatchResponse.nextAuthorizationResponse().litleTxnId);
Assert.IsNull(actualLitleBatchResponse.nextAuthorizationResponse());
mockCommunications.Verify(Communications => Communications.FtpDropOff(It.IsAny<String>(), mockFileName, It.IsAny<Dictionary<String, String>>()));
mockCommunications.Verify(Communications => Communications.FtpPickUp(It.IsAny<String>(), It.IsAny<Dictionary<String, String>>(), mockFileName));
}