globalpayments-api 3.11.4 → 3.13.0

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

@@ -430,32 +430,433 @@ 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}`);
+    });
+});
 // ===========================================================================
-// sale() with enhanced field support
+// COMPREHENSIVE INTEGRATED TEST SCENARIOS FROM SPEC
 // ===========================================================================
-(0, UpaHelpertest_1.describeUpaLive)("UPA Credit – sale() with enhanced fields", () => {
+(0, UpaHelpertest_1.describeUpaLive)("UPA Credit – Comprehensive Builder Scenarios (Spec Compliance)", () => {
     let device;
     beforeEach(() => {
         device = (0, UpaHelpertest_1.createTestDevice)();
     });
-    test("sale() includes clerkId field", async () => {
-        const response = await device
-            .sale(10)
+    test("[UpaCreditTests:SPEC-001] Sale with ClerkId + TaxAmount", async () => {
+        const builder = device
+            .sale(25.0)
+            .withEcrId(13)
+            .withClerkId(1234)
+            .withTaxAmount(2.5);
+        const response = await builder.execute();
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+    });
+    test("[UpaCreditTests:SPEC-003] Sale with CardBrandTransId", async () => {
+        const request = device
+            .sale(75.0)
+            .withEcrId(13)
+            .withCardBrandTransId("MCC0484550831");
+        const response = await request.execute();
+        expect(response).toBeDefined();
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+        expect(response.command).toBe("Sale");
+        expect(response.cardBrandTransId).toBeDefined();
+    });
+    test("[UpaCreditTests:SPEC-004] PreAuth with ClerkId + TaxAmount", async () => {
+        const authresponse = await device
+            .authorize(10.0)
             .withEcrId(13)
-            .withClerkId(123)
             .execute();
+        expect(authresponse).toBeDefined();
+        expect(authresponse.status).toBe("Success");
+        expect(authresponse.deviceResponseCode).toBe("00");
+        const controller = src_1.ServicesContainer.instance().getDeviceController();
+        const builder = device
+            .capture(100.0)
+            .withEcrId(13)
+            .withClerkId(1111)
+            .withTransactionId(authresponse.transactionId)
+            .withTaxAmount(5.0);
+        const request = controller
+            .buildProcessTransaction(builder)
+            .getJsonRequest();
+        expect(request.data.command).toBe("AuthCompletion");
+        expect(request.data.data.params.clerkId).toBe(1111);
+        expect(request.data.data.transaction.taxAmount).toBe("5.00");
+        const response = await builder.execute();
+        expect(response).toBeDefined();
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+    });
+    test("[UpaCreditTests:SPEC-005] Incremental Auth with preAuthAmount - toFixed(2) validation", async () => {
+        const controller = src_1.ServicesContainer.instance().getDeviceController();
+        const builder = device
+            .authorize(10.123)
+            .withEcrId(13)
+            .withPreAuthAmount(10.123);
+        const request = controller
+            .buildProcessTransaction(builder)
+            .getJsonRequest();
+        const response = await builder.execute();
+        expect(response).toBeDefined();
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+        console.log(`[UpaCreditTests:SPEC-005] PreAuth amount 10.123 formatted as:\n` +
+            JSON.stringify(request.data.data.transaction.preAuthAmount, null, 2));
+        // Verify correct toFixed(2) formatting in REQUEST (device doesn't echo preAuthAmount back)
+        expect(request.data.data.transaction.preAuthAmount).toBe("10.12");
+        // Note: preAuthAmount is request-only; device does not echo it in response
+        console.log(`[UpaCreditTests:SPEC-005] Response preAuthAmount: "${response.preAuthAmount ?? "not returned by device"}"`);
+    });
+    test("[UpaCreditTests:SPEC-011] Tax Amount Variants", async () => {
+        const controller = src_1.ServicesContainer.instance().getDeviceController();
+        const builder = device
+            .sale(100.0)
+            .withEcrId(13)
+            .withTaxAmount(5.25);
+        const request = controller
+            .buildProcessTransaction(builder)
+            .getJsonRequest();
+        console.log(`[UpaCreditTests:SPEC-011] TaxAmount Standard tax:\n` +
+            JSON.stringify(request.data.data.transaction.taxAmount));
+        const response = await builder.execute();
         expect(response).toBeDefined();
         expect(response.status).toBe("Success");
-        console.log(`[Sale ClerkId] Amount: ${response.transactionAmount}, Status: ${response.status}`);
+        expect(response.deviceResponseCode).toBe("00");
+        expect(request.data.data.transaction.taxAmount).toBe("5.25");
     });
-    test("sale() includes cardBrandTransId field", async () => {
+    test("[UpaCreditTests:506] sale() serializes prescription amount", async () => {
+        const controller = src_1.ServicesContainer.instance().getDeviceController();
+        const builder = device
+            .sale(6.0)
+            .withEcrId(13)
+            .withPrescriptionAmount(25.5)
+            .withClinicAmount(35.75)
+            .withDentalAmount(40.25);
+        const request = controller
+            .buildProcessTransaction(builder)
+            .getJsonRequest();
+        const response = await builder.execute();
+        expect(response).toBeDefined();
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+        expect(request.data.command).toBe("Sale");
+        expect(request.data.data.transaction.prescriptionAmount).toBe("25.50");
+        expect(request.data.data.transaction.clinicAmount).toBe("35.75");
+        expect(request.data.data.transaction.dentalAmount).toBe("40.25");
+    });
+});
+// ===========================================================================
+// sale() with enhanced field support
+// ===========================================================================
+(0, UpaHelpertest_1.describeUpaLive)("UPA Credit – sale() with enhanced fields", () => {
+    let device;
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    test("verify() includes cardBrandTransId field", async () => {
         const response = await device
-            .sale(15)
+            .verify()
             .withEcrId(13)
-            .withCardBrandTransId("CARD-BRAND-ID-123")
+            .withCardBrandTransId("MCC0484550831")
             .execute();
         expect(response).toBeDefined();
         expect(response.status).toBe("Success");
+        expect(response.cardBrandTransId).toBeDefined();
         console.log(`[Sale CardBrandTransId] Amount: ${response.transactionAmount}, Status: ${response.status}`);
     });
     test("sale() includes directMkt fields (shippingDate)", async () => {
@@ -464,25 +865,11 @@ afterEach(async () => {
             .sale(20)
             .withEcrId(13)
             .withShippingDate(shippingDate)
-            .withInvoiceNumber("INV-2025-001")
+            .withInvoiceNumber("INV2025001")
             .execute();
         expect(response).toBeDefined();
         expect(response.status).toBe("Success");
     });
-    test("sale() includes acquisitionTypes in request", async () => {
-        const builder = device
-            .sale(10)
-            .withEcrId(13)
-            .withAcquisitionTypes([
-            AcquisitionType_1.AcquisitionType.Chip,
-            AcquisitionType_1.AcquisitionType.Contactless,
-        ]);
-        console.log("\n===== EXECUTING SALE WITH ACQUISITION TYPES =====");
-        const response = await builder.execute();
-        console.log("Response Status:", response.status);
-        console.log("Response:", JSON.stringify(response, null, 2));
-        expect(response).toBeDefined();
-    });
 });
 // ===========================================================================
 // authorize() with enhanced field support
@@ -507,7 +894,7 @@ afterEach(async () => {
         const response = await device
             .authorize(30)
             .withEcrId(12)
-            .withCardBrandTransId("BRAND-TRANS-456")
+            .withCardBrandTransId("MCC0484550831")
             .execute();
         expect(response).toBeDefined();
         expect(response.status).toBe("Success");
@@ -524,4 +911,294 @@ afterEach(async () => {
         console.log(`[Auth PreAuthAmount] Amount: ${response.transactionAmount}, Status: ${response.status}`);
     });
 });
+// ===========================================================================
+// 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", () => {
+    let device;
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    test("[UpaCreditTests:ProcessCPC-001] sale() with ProcessCPC(true) serializes processCPC as '1'", async () => {
+        const controller = src_1.ServicesContainer.instance().getDeviceController();
+        const builder = device
+            .sale(10.0)
+            .withEcrId(13)
+            .withProcessCPC(true);
+        // Verify request serialization (processCPC is sent to device)
+        const request = controller
+            .buildProcessTransaction(builder)
+            .getJsonRequest();
+        console.log("[UpaCreditTests:ProcessCPC-001] Sale with ProcessCPC(true) request payload:\n" +
+            JSON.stringify(request, null, 2));
+        expect(request.data.command).toBe("Sale");
+        expect(request.data.data.transaction.processCPC).toBe("1");
+        // Execute transaction and verify success
+        const response = await builder.execute();
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+        console.log("[UpaCreditTests:ProcessCPC-001] Sale response:\n" +
+            JSON.stringify(response, null, 2));
+        // Note: processCPC is request-only; device may not echo it back in response
+        // If device does return it, it will be populated in response.processCPC
+        console.log(`[UpaCreditTests:ProcessCPC-001] Response processCPC value: "${response.processCPC ?? "not returned by device"}"`);
+    });
+    test("[UpaCreditTests:ProcessCPC-002] sale() with ProcessCPC(false) serializes processCPC as '0'", async () => {
+        const controller = src_1.ServicesContainer.instance().getDeviceController();
+        const builder = device
+            .sale(10.0)
+            .withEcrId(13)
+            .withProcessCPC(false);
+        const request = controller
+            .buildProcessTransaction(builder)
+            .getJsonRequest();
+        const response = await builder.execute();
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+        expect(request.data.command).toBe("Sale");
+        expect(request.data.data.transaction.processCPC).toBe("0");
+    });
+    test("[UpaCreditTests:ProcessCPC-003] sale() without ProcessCPC omits processCPC from request", async () => {
+        const controller = src_1.ServicesContainer.instance().getDeviceController();
+        const builder = device.sale(10.0).withEcrId(13);
+        const response = await builder.execute();
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+        const request = controller
+            .buildProcessTransaction(builder)
+            .getJsonRequest();
+        expect(request.data.command).toBe("Sale");
+        expect(request.data.data.transaction.processCPC).toBeUndefined();
+    });
+    test("[UpaCreditTests:ProcessCPC-004] capture() uses totalAmount (not baseAmount)", async () => {
+        const controller = src_1.ServicesContainer.instance().getDeviceController();
+        const authresponse = await device
+            .authorize(10.0)
+            .withEcrId(13)
+            .execute();
+        expect(authresponse.status).toBe("Success");
+        expect(authresponse.deviceResponseCode).toBe("00");
+        const builder = device
+            .capture()
+            .withTransactionId(authresponse.transactionId)
+            .withProcessCPC(true)
+            .withAmount(10.0)
+            .withEcrId(13);
+        const request = controller
+            .buildProcessTransaction(builder)
+            .getJsonRequest();
+        const response = await builder.execute();
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+        expect(request.data.command).toBe("AuthCompletion");
+        expect(request.data.data.transaction.totalAmount).toBe("10.00");
+        expect(request.data.data.transaction.baseAmount).toBeUndefined();
+    });
+});
 //# sourceMappingURL=UpaCredit.test.js.map