What test cases should QA add to validate UPI refunds and reversals under higher limit scenarios?

You must work with your bank for merchant verification and interface with a payment gateway that supports the most recent UPI APIs in order to demonstrate real-time eligibility for larger UPI limits.  The higher limit choice can then be dynamically displayed at your e-commerce checkout for purchases in qualified categories like travel, investments, or insurance.

A travel booking engine should adapt its checkout to increased UPI limits by integrating a multi-limit UPI option, providing seamless multi-payment choices for larger transactions, and enhancing user experience through features like split payments and a multi-stage checkout process. By allowing users to pay with different UPI accounts, split a single booking across multiple payments, or combine UPI with other methods like credit cards, the platform can cater to a higher spending capacity and offer greater flexibility, thereby improving conversion rates and user satisfaction.

Gather the constraints up front

• Source per-transaction and per-day caps from your PSP / acquirer (or from a config table you keep updated per NPCI rules + merchant verification status + MCC).
• Also fetch merchant’s remaining daily allowance (from PSP API or your local ledger of successful UPI receipts).
• Enforce any PSP-specific rules (min txn amount, max legs allowed, supported UPI modes).

Decide UX / business rules

• Decide whether splitting is automatic (ERP will try to split) or opt-in (customer chooses split/pay later).
• Prefer showing the user: total, per-leg amounts, number of legs, and which payment methods are alternatives (card/netbanking) before attempting collects.
• For B2B invoices, ask if partial payments are allowed; if not, block UPI and suggest alternate flows.

Algorithm to compute safe splits (basic, robust)

• Let Tcap = per-transaction cap, Dcap = daily cap, R = remaining daily allowance for merchant, Amount = invoice total.
• Effective single-leg ceiling Ceil = min(Tcap, R).
• If Amount <= Ceil → single collect.
• Else compute legs greedily: take as many Ceil legs as needed, last leg = remainder. If last leg < PSP minimum amount, adjust by balancing (e.g., distribute across legs to keep all ≥ min).
• Also check maximum number of legs allowed; if exceeded, fallback to alternate payment or require manual handling.

Orchestration & atomicity (critical)

• •    Create a single InvoicePaymentPlan record linked to invoice with legs array (leg_id, amount, status, psp_txn_id, upi_ref).
• For each leg call PSP pre-check API (if available) to confirm remaining daily limit and allowed amount. If no pre-check, proceed but be prepared to handle failures.
• Execute collects sequentially or in controlled parallelism: prefer sequential (leg1 → leg2 → …) because daily allowances and race conditions can cause mid-flow failures.
• Implement reversible flows via PSP APIs (reversals/refunds) and mark everything in your ledger before returning success to caller.

Idempotency & retries

• Use idempotency keys per leg (invoiceId:legIndex:attemptId) so retries don’t double-charge.
• Backoff / retry on transient errors; on definitive errors (LIMIT_EXCEEDED, DAILY_LIMIT_REACHED) stop retries and surface next steps to user.

Reconciliation & GST / e-invoice mapping

• Store psp_txn_id and upi_ref for every leg and include them in your GST e-invoice Payment array (one entry per leg).
• Ensure your settlement batch logic aggregates legs correctly: settlement files from PSP may show separate credits — map them to invoice via psp_txn_id.
• If auto-reversal happens, generate credit note / adjusted invoice and record reversal UPI ref.

Notifications & UX

• Notify user/customer at three touchpoints: (a) when split is created, (b) as each leg succeeds/fails, (c) final invoice status.
• Provide clear error messages: UPI daily cap reached — try smaller amount, card, or complete tomorrow.

Auditability & monitoring

• Log every API request/response and store raw PSP error codes (to tune thresholds).
• Add alerts for patterns: many LIMIT_EXCEEDED responses, high rate of compensations, reconciliation mismatches.
• Track KPIs: split success rate, average legs per invoice, compensation rate, reconciliation delta, time-to-full-payment.

Edge cases & testing

• Simulate concurrent spends that consume merchant’s remaining allowance mid-flow (race conditions). Build tests that:
• Force second-leg DAILY_LIMIT_REACHED and ensure compensation works.
• Simulate webhook/callback lost and verify polling reconciles status.
• Verify idempotency under duplicate webhooks or client retries.
• Test refunds across split legs: full refund should create refunds across legs proportionally or in defined order (document policy).

Security, compliance

• Don’t store PAN/card data — store only PSP tokens and UPI refs. Ensure logs containing sensitive identifiers are redacted.
• Maintain audit trail for NPCI/RBI compliance — per-txn UPI refs, timestamps, merchant verification status, and settlement files.

Implementation sketch (pseudo-code)
def split_invoice(invoice)

Rollout & Ops

• Roll out with a canary: only for verified merchants and a small % of invoices.
• Feature flag the auto-split behavior so you can disable instantly.
• Provide support playbooks for agents to handle partial payments and reconciliation questions.

To restrict external sharing in Razorpay Subscriptions while still enabling collaboration, you should use Razorpay's native team management features rather than sharing information or links externally. This involves inviting specific users, assigning them roles with limited permissions, and using the secure subscription link feature for customer-facing interactions.

To ensure Adyen features meet WCAG 2.2 AA standards, merchants must perform accessibility checks covering keyboard navigation, visible focus indicators, color contrast, and form controls. Adyen's components themselves are tested for compliance with WCAG 2.1 AA, but since WCAG 2.2 adds new criteria, additional testing is necessary.