globalpayments-api 3.12.0 → 3.13.0

package/lib/test/Unit/Terminals/UPA/UpaCredit.test.js

@@ -11,6 +11,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 const src_1 = require("../../../../src");
 const UpaHelpertest_1 = require("./UpaHelpertest");
+const AcquisitionType_1 = require("../../../../src/Entities/Enums/AcquisitionType");
 jest.setTimeout(240000);
 function sleep(delayMs) {
     return new Promise((resolve) => setTimeout(resolve, delayMs));
@@ -429,6 +430,302 @@ afterEach(async () => {
         console.warn(`updateLodginDetail() ERR010 scenario not reproduced: device accepted the malformed amount with status="${response?.status}" code="${response?.deviceResponseCode}". Per UPA doc an amount missing the leading zero SHOULD be rejected — the current firmware may be tolerating the drift.`);
     });
 });
+(0, UpaHelpertest_1.describeUpaLive)("UPA void test case void support and response parsing ", () => {
+    let device;
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    test("void support ", async () => {
+        const saleResponse = (await device
+            .sale(75.0)
+            .withEcrId(12)
+            .withClerkId(789)
+            .execute());
+        expect(saleResponse.status).toBe("Success");
+        const voidResponse = (await device
+            .void()
+            .withEcrId(12)
+            .withTerminalRefNumber(saleResponse.terminalRefNumber)
+            .withTransactionId(saleResponse.transactionId)
+            .withAmount(saleResponse.transactionAmount)
+            .execute());
+        expect(voidResponse).not.toBeNull();
+        expect(voidResponse.status).toBe("Success");
+    });
+});
+(0, UpaHelpertest_1.describeUpaLive)("UPA test for capture/Authcompletion ", () => {
+    let device;
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    /**
+     * Test 1: Basic Capture
+     * Per UPA Spec §12.4.16 - AuthCompletion with mandatory fields
+     * Mandatory: referenceNumber, amount
+     */
+    test("UPA Capture - Basic (Auth → Capture)", async () => {
+        const authAmount = 10.0;
+        const captureAmount = 10.0;
+        const ecrId = "1";
+        // Step 1: Authorize to get transaction ID
+        const authResponse = await device
+            .authorize(authAmount)
+            .withEcrId(ecrId)
+            .execute();
+        expect(authResponse).toBeDefined();
+        expect(authResponse.status).toBe("Success");
+        expect(authResponse.transactionId).toBeTruthy();
+        await settleDevice();
+        // Step 2: Capture the authorized amount
+        const captureResponse = (await device
+            .capture(captureAmount)
+            .withEcrId(ecrId)
+            .withTransactionId(authResponse.transactionId)
+            .execute());
+        expect(captureResponse).toBeDefined();
+        expect(captureResponse.status).toBe("Success");
+        expect(captureResponse.deviceResponseCode).toBe("00");
+        expect(captureResponse.cardType).toBeDefined();
+        expect(captureResponse.transactionId).toBeTruthy();
+        // Note: transactionAmount may include device surcharges
+        expect(captureResponse.transactionAmount).toBeGreaterThanOrEqual(captureAmount);
+        console.log(`[Capture Basic] TransId: ${captureResponse.transactionId}, Amount: ${captureResponse.transactionAmount}`);
+    });
+    /**
+     * Test 2: Capture with Tax and Tip
+     * Per UPA Spec §12.4.16 - Optional fields: taxAmount, tipAmount
+     * Verifies proper amount aggregation
+     */
+    test("UPA Capture - with Tax and Tip", async () => {
+        const authAmount = 50.0;
+        const taxAmount = 5.0;
+        const tipAmount = 10.0;
+        const ecrId = "1";
+        // Step 1: Authorize
+        const authResponse = await device
+            .authorize(authAmount)
+            .withEcrId(ecrId)
+            .execute();
+        expect(authResponse).toBeDefined();
+        expect(authResponse.status).toBe("Success");
+        expect(authResponse.transactionId).toBeTruthy();
+        await settleDevice();
+        // Step 2: Capture with tax and tip
+        const captureResponse = (await device
+            .capture(authAmount)
+            .withEcrId(ecrId)
+            .withTransactionId(authResponse.transactionId)
+            .withTaxAmount(taxAmount)
+            .withGratuity(tipAmount)
+            .execute());
+        expect(captureResponse).toBeDefined();
+        expect(captureResponse.status).toBe("Success");
+        expect(captureResponse.deviceResponseCode).toBe("00");
+        // Verify amounts
+        // Note: Device may or may not aggregate tax and tip into total amount
+        // At minimum, should have at least the base authorized amount
+        expect(captureResponse.transactionAmount).toBeGreaterThanOrEqual(authAmount);
+        // Log actual values received for debugging
+        console.log(`[Capture Tax+Tip] Amount: ${captureResponse.transactionAmount}, Tax: ${captureResponse.taxAmount}, Tip: ${captureResponse.tipAmount}`);
+        // Verify tax and tip if populated (may be undefined depending on device response format)
+        if (captureResponse.taxAmount !== undefined) {
+            expect(captureResponse.taxAmount).toBeCloseTo(taxAmount, 2);
+        }
+        if (captureResponse.tipAmount !== undefined) {
+            expect(captureResponse.tipAmount).toBeCloseTo(tipAmount, 2);
+        }
+    });
+    /**
+     * Test 3: Capture with Tax Indicator (Tax Exempt)
+     * Per UPA Spec §12.4.16 - taxIndicator: 0 or 1
+     * 0 = tax applicable, 1 = tax exempt
+     */
+    test("UPA Capture - with Tax Indicator (Tax Exempt)", async () => {
+        const authAmount = 30.0;
+        const ecrId = "1";
+        const taxIndicator = 1; // 1 = tax exempt
+        // Step 1: Authorize
+        const authResponse = await device
+            .authorize(authAmount)
+            .withEcrId(ecrId)
+            .execute();
+        expect(authResponse).toBeDefined();
+        expect(authResponse.status).toBe("Success");
+        await settleDevice();
+        // Step 2: Capture with tax exempt indicator
+        const captureResponse = (await device
+            .capture(authAmount)
+            .withEcrId(ecrId)
+            .withTransactionId(authResponse.transactionId)
+            .withTaxIndicator(taxIndicator)
+            .execute());
+        expect(captureResponse).toBeDefined();
+        expect(captureResponse.status).toBe("Success");
+        // Note: Device may add surcharges, so check for >= base amount
+        expect(captureResponse.transactionAmount).toBeGreaterThanOrEqual(authAmount);
+        console.log(`[Capture TaxExempt] Amount: ${captureResponse.transactionAmount}, TaxIndicator: ${taxIndicator}`);
+    });
+    /**
+     * Test 4: Capture with Invoice Number
+     * Per UPA Spec §12.4.16 - invoiceNbr: AN(1-16)
+     */
+    test("UPA Capture - with Invoice Number", async () => {
+        const authAmount = 25.0;
+        const ecrId = "1";
+        const invoiceNum = "INV-" + Date.now().toString().slice(-8);
+        // Step 1: Authorize
+        const authResponse = await device
+            .authorize(authAmount)
+            .withEcrId(ecrId)
+            .execute();
+        expect(authResponse).toBeDefined();
+        expect(authResponse.status).toBe("Success");
+        await settleDevice();
+        // Step 2: Capture with invoice number
+        const captureResponse = (await device
+            .capture(authAmount)
+            .withEcrId(ecrId)
+            .withTransactionId(authResponse.transactionId)
+            .withInvoiceNumber(invoiceNum)
+            .execute());
+        expect(captureResponse).toBeDefined();
+        expect(captureResponse.status).toBe("Success");
+        // Invoice number may not be returned in response - if it is, verify it matches
+        if (captureResponse.invoiceNumber !== undefined &&
+            captureResponse.invoiceNumber !== "") {
+            expect(captureResponse.invoiceNumber).toBe(invoiceNum);
+        }
+        // Amount check (with device surcharges allowance)
+        expect(captureResponse.transactionAmount).toBeGreaterThanOrEqual(authAmount);
+        console.log(`[Capture Invoice] Invoice: ${captureResponse.invoiceNumber}, Amount: ${captureResponse.transactionAmount}`);
+    });
+    /**
+     * Test 5: Capture with Processing CPC (Commercial Card Processing)
+     * Per UPA Spec §12.4.16 - processCPC: 0 or 1
+     * 0 = No, 1 = Yes
+     */
+    test("UPA Capture - with Processing CPC", async () => {
+        const authAmount = 100.0;
+        const ecrId = "1";
+        // Step 1: Authorize
+        const authResponse = await device
+            .authorize(authAmount)
+            .withEcrId(ecrId)
+            .execute();
+        expect(authResponse).toBeDefined();
+        expect(authResponse.status).toBe("Success");
+        await settleDevice();
+        // Step 2: Capture with CPC processing
+        const captureResponse = (await device
+            .capture(authAmount)
+            .withEcrId(ecrId)
+            .withTransactionId(authResponse.transactionId)
+            .withProcessCPC(true)
+            .execute());
+        expect(captureResponse).toBeDefined();
+        expect(captureResponse.status).toBe("Success");
+        // Device may add surcharges, so check for >= base amount
+        expect(captureResponse.transactionAmount).toBeGreaterThanOrEqual(authAmount);
+        console.log(`[Capture CPC] Amount: ${captureResponse.transactionAmount}, ProcessCPC: true`);
+    });
+    /**
+     * Test 6: Capture with All Fields
+     * Per UPA Spec §12.4.16 - Comprehensive test with all optional fields
+     * Fields: amount, preAuthAmount, taxAmount, tipAmount, taxIndicator, processCPC
+     */
+    test("UPA Capture - with All Fields", async () => {
+        const authAmount = 75.0;
+        const taxAmount = 7.5;
+        const tipAmount = 15.0;
+        const ecrId = "1";
+        const invoiceNum = "FULL-" + Date.now().toString().slice(-6);
+        const taxIndicator = 0; // 0 = tax applicable
+        // Step 1: Authorize
+        const authResponse = await device
+            .authorize(authAmount)
+            .withEcrId(ecrId)
+            .execute();
+        expect(authResponse).toBeDefined();
+        expect(authResponse.status).toBe("Success");
+        await settleDevice();
+        // Step 2: Capture with all fields
+        const captureResponse = (await device
+            .capture(authAmount)
+            .withEcrId(ecrId)
+            .withTransactionId(authResponse.transactionId)
+            .withTaxAmount(taxAmount)
+            .withGratuity(tipAmount)
+            .withTaxIndicator(taxIndicator)
+            .withInvoiceNumber(invoiceNum)
+            .withProcessCPC(true)
+            .execute());
+        expect(captureResponse).toBeDefined();
+        expect(captureResponse.status).toBe("Success");
+        expect(captureResponse.deviceResponseCode).toBe("00");
+        // Verify all fields
+        expect(captureResponse.transactionId).toBeTruthy();
+        // Device may not aggregate all tax/tip components into total - at minimum check base amount
+        expect(captureResponse.transactionAmount).toBeGreaterThanOrEqual(authAmount);
+        // Tax and tip may be undefined or may be populated
+        if (captureResponse.taxAmount !== undefined &&
+            captureResponse.taxAmount > 0) {
+            expect(captureResponse.taxAmount).toBeGreaterThanOrEqual(0);
+        }
+        if (captureResponse.tipAmount !== undefined &&
+            captureResponse.tipAmount > 0) {
+            expect(captureResponse.tipAmount).toBeGreaterThanOrEqual(0);
+        }
+        expect(captureResponse.cardType).toBeDefined();
+        expect(captureResponse.maskedCardNumber).toBeDefined();
+        console.log(`[Capture AllFields] Amount: ${captureResponse.transactionAmount}, Tax: ${captureResponse.taxAmount}, Tip: ${captureResponse.tipAmount}, Invoice: ${captureResponse.invoiceNumber}, ClerkId: ${captureResponse.clerkId}`);
+    });
+    /**
+     * Test 7: Capture Response Field Parsing
+     * Per UPA Spec §12.4.16.5 - Validates all output parameters
+     * Verifies proper response parsing from device
+     */
+    test("UPA Capture - Response Field Parsing", async () => {
+        const authAmount = 40.0;
+        const ecrId = "1";
+        // Step 1: Authorize
+        const authResponse = await device
+            .authorize(authAmount)
+            .withEcrId(ecrId)
+            .execute();
+        expect(authResponse).toBeDefined();
+        expect(authResponse.status).toBe("Success");
+        await settleDevice();
+        // Step 2: Capture to validate response parsing
+        const captureResponse = (await device
+            .capture(authAmount)
+            .withEcrId(ecrId)
+            .withTransactionId(authResponse.transactionId)
+            .execute());
+        // Core transaction identifiers (per §12.4.16.5)
+        expect(captureResponse.transactionId).toBeTruthy(); // responseId: N16
+        expect(captureResponse.terminalRefNumber).toBeTruthy(); // tranNo: N4
+        expect(captureResponse.approvalCode).toBeTruthy(); // approvalCode: AN6
+        // Response codes (per §12.4.16.5)
+        expect(typeof captureResponse.responseCode).toBe("string");
+        expect(typeof captureResponse.responseText).toBe("string");
+        expect(typeof captureResponse.deviceResponseCode).toBe("string");
+        expect(typeof captureResponse.deviceResponseText).toBe("string");
+        // Card information (per §12.4.16.5)
+        expect(typeof captureResponse.cardType).toBe("string");
+        expect(typeof captureResponse.maskedCardNumber).toBe("string");
+        expect(captureResponse.maskedCardNumber).toMatch(/^\d{0,25}$/);
+        // Status validation
+        expect(captureResponse.status).toBe("Success");
+        expect(captureResponse.deviceResponseCode).toBe("00"); // "00" = Success
+        // Amount validation
+        expect(captureResponse.transactionAmount).toBeCloseTo(authAmount, 2);
+        expect(typeof captureResponse.transactionAmount).toBe("number");
+        // Gateway response info (per §12.4.16.5)
+        expect(typeof captureResponse.gatewayResponseCode).toBe("string");
+        expect(typeof captureResponse.gatewayResponseMessage).toBe("string");
+        console.log(`[Capture ResponseParsing] TransId: ${captureResponse.transactionId}, RefNum: ${captureResponse.terminalRefNumber}, ApprovalCode: ${captureResponse.approvalCode}, CardType: ${captureResponse.cardType}`);
+    });
+});
 // ===========================================================================
 // COMPREHENSIVE INTEGRATED TEST SCENARIOS FROM SPEC
 // ===========================================================================
@@ -530,7 +827,6 @@ afterEach(async () => {
             .withPrescriptionAmount(25.5)
             .withClinicAmount(35.75)
             .withDentalAmount(40.25);
-        //
         const request = controller
             .buildProcessTransaction(builder)
             .getJsonRequest();
@@ -544,6 +840,7 @@ afterEach(async () => {
         expect(request.data.data.transaction.dentalAmount).toBe("40.25");
     });
 });
+// ===========================================================================
 // sale() with enhanced field support
 // ===========================================================================
 (0, UpaHelpertest_1.describeUpaLive)("UPA Credit – sale() with enhanced fields", () => {
@@ -615,6 +912,212 @@ afterEach(async () => {
     });
 });
 // ===========================================================================
+// JIRA Story Requirements – Field Validation
+// ===========================================================================
+describe("JIRA Story: UPA Transaction Processing – Field Validation", () => {
+    let device;
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    /**
+     * Requirement: clerkId
+     * Status: withClerkId() method should be available on builder
+     */
+    test("[Requirement:clerkId] Builder has withClerkId method", async () => {
+        const builder = device.sale(10.0);
+        expect(builder).toHaveProperty("withClerkId");
+        expect(typeof builder.withClerkId).toBe("function");
+        // Should be chainable
+        const chained = builder.withClerkId(123);
+        const result = await chained.withEcrId("13").execute();
+        expect(result.status).toBe("Success");
+        expect(chained).toBeDefined();
+        expect(chained).toEqual(builder); // Returns self for chaining
+    });
+    /**
+     * Requirement: cardBrandTransId
+     * Status: withCardBrandTransId() method should exist and work
+     */
+    test("[Requirement:cardBrandTransId] Builder has withCardBrandTransId method", async () => {
+        const builder = device.sale(10.0).withEcrId("13");
+        const transId = "ABC123XYZ";
+        expect(builder).toHaveProperty("withCardBrandTransId");
+        expect(typeof builder.withCardBrandTransId).toBe("function");
+        // Should be chainable and store value
+        const chained = builder.withCardBrandTransId(transId);
+        const response = await chained.execute();
+        expect(response.status).toBe("Success");
+        expect(chained).toBeDefined();
+        expect(chained).toEqual(builder);
+        expect(builder.cardBrandTransId).toBe(transId);
+    });
+    /**
+     * Requirement: cardOnFileIndicator
+     * Status: Should support CardHolder ('C'), Merchant ('M')
+     * Note: R (Recurring) and I (Installment) may require additional enum values
+     */
+    test("[Requirement:cardOnFileIndicator] Builder supports CardHolder and Merchant indicators", async () => {
+        const builderCH = device
+            .sale(10.0)
+            .withCardOnFileIndicator(src_1.StoredCredentialInitiator.CardHolder);
+        const builderM = device
+            .sale(10.0)
+            .withCardOnFileIndicator(src_1.StoredCredentialInitiator.Merchant);
+        expect(builderCH.cardOnFileIndicator).toBe(src_1.StoredCredentialInitiator.CardHolder);
+        expect(builderM.cardOnFileIndicator).toBe(src_1.StoredCredentialInitiator.Merchant);
+        const responseCH = await builderCH.withEcrId("13").execute();
+        const responseM = await builderM.withEcrId("13").execute();
+        expect(responseCH.status).toBe("Success");
+        expect(responseM.status).toBe("Success");
+    });
+    /**
+     * Requirement: preAuthAmount
+     * Status: withPreAuthAmount() should exist and use proper formatting
+     */
+    test("[Requirement:preAuthAmount] Builder has withPreAuthAmount with proper formatting", async () => {
+        const builder = device.authorize(15.0);
+        const preAuthAmt = 25.99;
+        expect(builder).toHaveProperty("withPreAuthAmount");
+        expect(typeof builder.withPreAuthAmount).toBe("function");
+        builder.withPreAuthAmount(preAuthAmt);
+        expect(builder.preAuthAmount).toBe(preAuthAmt);
+        const response = await builder.withEcrId("13").execute();
+        expect(response.status).toBe("Success");
+    });
+    /**
+     * Requirement: Processing Indicators
+     * Status: Builder should support quickChip, checkLuhn, securityCode
+     */
+    test("[Requirement:processingIndicators] Builder supports processing indicator flags", async () => {
+        const builder = device.sale(10.0);
+        // These should be properties on the builder
+        expect(builder).toHaveProperty("isQuickChip");
+        expect(builder).toHaveProperty("hasCheckLuhn");
+        expect(builder).toHaveProperty("hasSecurityCode");
+        const response = await builder.withEcrId("13").execute();
+        expect(response.status).toBe("Success");
+    });
+});
+// ===========================================================================
+// JIRA Story Requirements – Method Chaining
+// ===========================================================================
+describe("JIRA Story: UPA Transaction Processing – Method Chaining", () => {
+    let device;
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    /**
+     * All required methods should be chainable
+     */
+    test("[MethodChaining] All required methods are chainable", () => {
+        const result = device
+            .sale(25.0)
+            .withClerkId(101)
+            .withCardOnFileIndicator(src_1.StoredCredentialInitiator.CardHolder)
+            .withCardBrandTransId("TransID123")
+            .withLineItemLeft("Item Description")
+            .withLineItemRight("$25.00")
+            .withLanguage("en")
+            .withMerchantDecision("Approve")
+            .withAcquisitionTypes([AcquisitionType_1.AcquisitionType.Contact])
+            .withPreAuthAmount(50.0);
+        // Verify all values are set
+        expect(result.amount).toBe(25.0);
+        expect(result.clerkId).toBe(101);
+        expect(result.cardOnFileIndicator).toBe(src_1.StoredCredentialInitiator.CardHolder);
+        expect(result.cardBrandTransId).toBe("TransID123");
+        expect(result.lineItemLeft).toBe("Item Description");
+        expect(result.lineItemRight).toBe("$25.00");
+        expect(result.language).toBe("en");
+        expect(result.merchantDecision).toBe("Approve");
+        expect(result.acquisitionTypes).toEqual([AcquisitionType_1.AcquisitionType.Contact]);
+        expect(result.preAuthAmount).toBe(50.0);
+    });
+});
+// ===========================================================================
+// JIRA Story Requirements – Comprehensive Integration Test
+// ===========================================================================
+describe("JIRA Story: UPA Transaction Processing – Comprehensive Integration", () => {
+    let device;
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    /**
+     * Complete transaction with all fields
+     */
+    test("[Integration:Complete] Sale with all JIRA story requirements", async () => {
+        // Build complete sale transaction matching JIRA requirements
+        const builder = device
+            .sale(99.99)
+            .withClerkId(42)
+            .withCardOnFileIndicator(src_1.StoredCredentialInitiator.CardHolder)
+            .withCardBrandTransId("BrandTxnId-2026-001")
+            .withPreAuthAmount(150.0)
+            .withInvoiceNumber("INV-2026-0001")
+            .withRequestMultiUseToken(true);
+        // Verify all properties are accessible (without execution)
+        const builderAsAny = builder;
+        expect(builderAsAny.amount).toBe(99.99);
+        expect(builderAsAny.clerkId).toBe(42);
+        expect(builderAsAny.cardOnFileIndicator).toBe(src_1.StoredCredentialInitiator.CardHolder);
+        expect(builderAsAny.cardBrandTransId).toBe("BrandTxnId-2026-001");
+        expect(builderAsAny.preAuthAmount).toBe(150.0);
+        expect(builderAsAny.invoiceNumber).toBe("INV-2026-0001");
+        expect(builderAsAny.requestMultiUseToken).toBe(true);
+        const response = await builder.withEcrId("13").execute();
+        expect(response.status).toBe("Success");
+    });
+    /**
+     * Refund with cardOnFileIndicator - Merchant initiated
+     *
+     * NOTE: Refund-by-reference with GP-API has a limitation:
+     * - UPA spec requires referenceNumber as AN(4-16)
+     * - Device reference numbers are 12 digits (valid for UPA)
+     * - But GP-API's validation layer expects GatewayTxnId (29 chars)
+     * - This creates a constraint where refund-by-reference through GP-API fails
+     *
+     * Solution: Use refund without reference (card-on-file without transaction ID)
+     * This requires either:
+     * 1. CardData for manual refund
+     * 2. Token from previous tokenized transaction
+     * 3. Or wait for GP-API to support device reference numbers
+     */
+    test("[Integration:Refund] Refund with Merchant cardOnFileIndicator", async () => {
+        // For now, test that refund builder supports cardOnFileIndicator properly
+        // Full refund-by-reference will work once GP-API layer is fixed
+        const refundBuilder = device
+            .refund(50.0)
+            .withClerkId(101)
+            .withCardOnFileIndicator(src_1.StoredCredentialInitiator.Merchant)
+            .withEcrId("13");
+        const builderAsAny = refundBuilder;
+        expect(builderAsAny.amount).toBe(50.0);
+        expect(builderAsAny.clerkId).toBe(101);
+        expect(builderAsAny.cardOnFileIndicator).toBe(src_1.StoredCredentialInitiator.Merchant);
+        const response = await refundBuilder.execute();
+        expect(response.status).toBe("Success");
+        // Note: Actual refund execution requires CardData or reference that GP-API accepts
+        // This test verifies the builder supports the JIRA requirements
+    });
+    /**
+     * Pre-Authorization with all fields
+     */
+    test("[Integration:PreAuth] Pre-Auth with preAuthAmount and processing indicators", async () => {
+        const builder = device
+            .authorize(200.0)
+            .withClerkId(55)
+            .withCardBrandTransId("PreAuthBrandId")
+            .withPreAuthAmount(250.0);
+        const builderAsAny = builder;
+        expect(builderAsAny.amount).toBe(200.0);
+        expect(builderAsAny.clerkId).toBe(55);
+        expect(builderAsAny.cardBrandTransId).toBe("PreAuthBrandId");
+        expect(builderAsAny.preAuthAmount).toBe(250.0);
+        const response = await builder.withEcrId("13").execute();
+        expect(response.status).toBe("Success");
+    });
+});
+// ===========================================================================
 // processCPC serialization for Sale and PreAuth
 // ===========================================================================
 (0, UpaHelpertest_1.describeUpaLive)("UPA Credit – processCPC serialization", () => {