@mohasinac/appkit 3.8.2 → 3.9.1

package/dist/_internal/server/jobs/core/__tests__/onUserBanChange.test.js

@@ -1,161 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-vi.mock("../../../../../errors/normalize", () => ({
-    normalizeError: vi.fn(),
-}));
-import { handleUserBanChange } from "../onUserBanChange";
-// ── Helpers ─────────────────────────────────────────────────────────────────
-function makeBatch() {
-    return {
-        set: vi.fn(),
-        update: vi.fn(),
-        delete: vi.fn(),
-        commit: vi.fn().mockResolvedValue(undefined),
-    };
-}
-function makeCtx(batch = makeBatch()) {
-    const mockDoc = vi.fn().mockReturnValue({});
-    const banHistoryCollection = { doc: mockDoc };
-    const userDoc = { collection: vi.fn().mockReturnValue(banHistoryCollection) };
-    const usersCollection = { doc: vi.fn().mockReturnValue(userDoc) };
-    return {
-        db: {
-            collection: vi.fn().mockReturnValue(usersCollection),
-            batch: vi.fn().mockReturnValue(batch),
-        },
-        batch,
-        now: new Date(),
-        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-    };
-}
-beforeEach(() => {
-    vi.clearAllMocks();
-});
-// ── Tests ────────────────────────────────────────────────────────────────────
-describe("handleUserBanChange — early exit", () => {
-    it("returns immediately when after is null", async () => {
-        const ctx = makeCtx();
-        await handleUserBanChange({ uid: "user-1", before: null, after: null }, ctx);
-        expect(ctx.batch.commit).not.toHaveBeenCalled();
-    });
-    it("returns without writing when no ban changes detected", async () => {
-        // before = active, after = active (same state, no ban)
-        const ctx = makeCtx();
-        await handleUserBanChange({
-            uid: "user-1",
-            before: { isDisabled: false, softBans: [] },
-            after: { isDisabled: false, softBans: [] },
-        }, ctx);
-        expect(ctx.batch.commit).not.toHaveBeenCalled();
-    });
-});
-describe("handleUserBanChange — hard ban applied", () => {
-    it("writes a hard_ban entry when isDisabled transitions false→true", async () => {
-        const batch = makeBatch();
-        const ctx = makeCtx(batch);
-        await handleUserBanChange({
-            uid: "user-1",
-            before: { isDisabled: false },
-            after: { isDisabled: true, hardBanReason: "Violating ToS", hardBannedBy: "admin-1" },
-        }, ctx);
-        expect(batch.set).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({ type: "hard_ban", reason: "Violating ToS" }));
-        expect(batch.commit).toHaveBeenCalled();
-    });
-    it("stores hardBannedBy as performedBy in the history entry", async () => {
-        const batch = makeBatch();
-        const ctx = makeCtx(batch);
-        await handleUserBanChange({
-            uid: "user-1",
-            before: { isDisabled: false },
-            after: { isDisabled: true, hardBanReason: "Fraud", hardBannedBy: "admin-2" },
-        }, ctx);
-        const call = batch.set.mock.calls[0][1];
-        expect(call.performedBy).toBe("admin-2");
-    });
-    it("does NOT write hard_ban when isDisabled stays true (no transition)", async () => {
-        const batch = makeBatch();
-        const ctx = makeCtx(batch);
-        await handleUserBanChange({
-            uid: "user-1",
-            before: { isDisabled: true },
-            after: { isDisabled: true, hardBanReason: "Fraud" },
-        }, ctx);
-        const hardBanCalls = batch.set.mock.calls.filter((c) => c[1].type === "hard_ban");
-        expect(hardBanCalls).toHaveLength(0);
-    });
-});
-describe("handleUserBanChange — hard ban lifted (unban)", () => {
-    it("writes a hard_unban entry when isDisabled transitions true→false", async () => {
-        const batch = makeBatch();
-        const ctx = makeCtx(batch);
-        await handleUserBanChange({
-            uid: "user-1",
-            before: { isDisabled: true },
-            after: { isDisabled: false },
-        }, ctx);
-        expect(batch.set).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({ type: "hard_unban" }));
-    });
-});
-describe("handleUserBanChange — soft ban changes", () => {
-    it("writes a soft_ban entry for each newly added soft ban action", async () => {
-        const batch = makeBatch();
-        const ctx = makeCtx(batch);
-        await handleUserBanChange({
-            uid: "user-1",
-            before: { softBans: [] },
-            after: {
-                softBans: [
-                    { action: "place_bids", reason: "Shill bidding", bannedBy: "admin-1" },
-                ],
-            },
-        }, ctx);
-        expect(batch.set).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({ type: "soft_ban", action: "place_bids" }));
-    });
-    it("writes soft_unban for each removed soft ban", async () => {
-        const batch = makeBatch();
-        const ctx = makeCtx(batch);
-        await handleUserBanChange({
-            uid: "user-1",
-            before: { softBans: [{ action: "place_bids" }] },
-            after: { softBans: [] },
-        }, ctx);
-        expect(batch.set).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({ type: "soft_unban", action: "place_bids" }));
-    });
-    it("does NOT write entry for soft bans that are unchanged", async () => {
-        const batch = makeBatch();
-        const ctx = makeCtx(batch);
-        await handleUserBanChange({
-            uid: "user-1",
-            before: { softBans: [{ action: "place_bids" }] },
-            after: { softBans: [{ action: "place_bids" }] }, // same ban, no change
-        }, ctx);
-        expect(batch.commit).not.toHaveBeenCalled();
-    });
-    it("handles multiple simultaneous soft ban additions", async () => {
-        const batch = makeBatch();
-        const ctx = makeCtx(batch);
-        await handleUserBanChange({
-            uid: "user-1",
-            before: { softBans: [] },
-            after: {
-                softBans: [
-                    { action: "place_bids" },
-                    { action: "post_reviews" },
-                ],
-            },
-        }, ctx);
-        expect(batch.set).toHaveBeenCalledTimes(2);
-    });
-});
-describe("handleUserBanChange — batch failure", () => {
-    it("batch.commit failure is non-fatal — logs error but does not throw", async () => {
-        const batch = makeBatch();
-        batch.commit.mockRejectedValue(new Error("Firestore error"));
-        const ctx = makeCtx(batch);
-        await expect(handleUserBanChange({
-            uid: "user-1",
-            before: { isDisabled: false },
-            after: { isDisabled: true, hardBanReason: "Test" },
-        }, ctx)).resolves.toBeUndefined();
-        expect(ctx.logger.error).toHaveBeenCalled();
-    });
-});

package/dist/_internal/server/jobs/core/__tests__/payoutBatch.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/_internal/server/jobs/core/__tests__/payoutBatch.test.js

@@ -1,302 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-const { mockGetPending, mockMarkProcessing, mockRecordSuccess, mockRecordFailure, mockFetch, } = vi.hoisted(() => ({
-    mockGetPending: vi.fn(),
-    mockMarkProcessing: vi.fn(),
-    mockRecordSuccess: vi.fn(),
-    mockRecordFailure: vi.fn(),
-    mockFetch: vi.fn(),
-}));
-vi.mock("../../../../../repositories", () => ({
-    payoutRepository: {
-        getPending: mockGetPending,
-        markProcessing: mockMarkProcessing,
-        recordSuccess: mockRecordSuccess,
-        recordFailure: mockRecordFailure,
-    },
-}));
-vi.mock("../../../../../errors/normalize", () => ({
-    normalizeError: vi.fn(),
-}));
-import { runPayoutBatch } from "../payoutBatch";
-// ── Helpers ─────────────────────────────────────────────────────────────────
-function makeCtx(overrides = {}) {
-    return {
-        env: (key) => {
-            const defaults = {
-                RAZORPAY_KEY_ID: "rzp_test_key",
-                RAZORPAY_KEY_SECRET: "secret",
-                RAZORPAY_ACCOUNT_NUMBER: "ACC123",
-                RAZORPAY_API_BASE_URL: "https://api.razorpay.com/v1",
-                APP_BRAND_NAME: "LetItRip",
-            };
-            return defaults[key];
-        },
-        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
-        ...overrides,
-    };
-}
-function makeRef() {
-    return { id: "payout-ref-1" };
-}
-function makePayout(overrides = {}) {
-    return {
-        id: "payout-store-A-001",
-        storeId: "store-A",
-        sellerEmail: "seller@example.com",
-        amount: 1000,
-        netAmount: 1000,
-        currency: "INR",
-        paymentMethod: "upi",
-        upiId: "seller@upi",
-        failureCount: 0,
-        ...overrides,
-    };
-}
-function makeBankPayout(overrides = {}) {
-    return makePayout({
-        paymentMethod: "bank",
-        upiId: undefined,
-        bankAccount: {
-            accountHolderName: "Seller A",
-            ifscCode: "HDFC0000001",
-            accountNumberMasked: "xxxx1234",
-        },
-        ...overrides,
-    });
-}
-function makeEntry(payoutOverrides = {}) {
-    return {
-        ref: makeRef(),
-        data: makePayout(payoutOverrides),
-    };
-}
-function mockRazorpaySuccess(id = "rzp_payout_1", status = "processing") {
-    mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => ({ id, status }),
-        text: async () => JSON.stringify({ id, status }),
-    });
-}
-function mockRazorpayFailure(statusCode = 500, body = "Internal Server Error") {
-    mockFetch.mockResolvedValue({
-        ok: false,
-        status: statusCode,
-        text: async () => body,
-    });
-}
-beforeEach(() => {
-    vi.clearAllMocks();
-    vi.stubGlobal("fetch", mockFetch);
-    mockMarkProcessing.mockResolvedValue(undefined);
-    mockRecordSuccess.mockResolvedValue(undefined);
-    mockRecordFailure.mockResolvedValue(undefined);
-});
-// ── Tests ────────────────────────────────────────────────────────────────────
-describe("runPayoutBatch — no pending payouts", () => {
-    it("returns early without calling fetch when list is empty", async () => {
-        mockGetPending.mockResolvedValue([]);
-        await runPayoutBatch(makeCtx());
-        expect(mockFetch).not.toHaveBeenCalled();
-    });
-    it("logs 'No pending payouts' when list is empty", async () => {
-        mockGetPending.mockResolvedValue([]);
-        const ctx = makeCtx();
-        await runPayoutBatch(ctx);
-        expect(ctx.logger.info).toHaveBeenCalledWith(expect.stringMatching(/No pending payouts/i));
-    });
-});
-describe("runPayoutBatch — UPI payout", () => {
-    it("marks payout as PROCESSING before dispatching", async () => {
-        const entry = makeEntry();
-        mockGetPending.mockResolvedValue([entry]);
-        mockRazorpaySuccess();
-        await runPayoutBatch(makeCtx());
-        expect(mockMarkProcessing).toHaveBeenCalledWith(entry.ref);
-    });
-    it("builds correct UPI payload (account_type=vpa)", async () => {
-        const entry = makeEntry({ upiId: "seller@okaxis" });
-        mockGetPending.mockResolvedValue([entry]);
-        mockRazorpaySuccess();
-        await runPayoutBatch(makeCtx());
-        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-        expect(body.fund_account.account_type).toBe("vpa");
-        expect(body.fund_account.vpa.address).toBe("seller@okaxis");
-        expect(body.mode).toBe("UPI");
-    });
-    it("converts amount to paise (multiplies by 100)", async () => {
-        const entry = makeEntry({ amount: 500, netAmount: 500 });
-        mockGetPending.mockResolvedValue([entry]);
-        mockRazorpaySuccess();
-        await runPayoutBatch(makeCtx());
-        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-        expect(body.amount).toBe(50000);
-    });
-    it("uses netAmount over gross amount when set (after refund deduction)", async () => {
-        const entry = makeEntry({ amount: 1000, netAmount: 800 });
-        mockGetPending.mockResolvedValue([entry]);
-        mockRazorpaySuccess();
-        await runPayoutBatch(makeCtx());
-        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-        expect(body.amount).toBe(80000); // netAmount 800 * 100
-    });
-    it("sends Authorization: Basic header with base64-encoded credentials", async () => {
-        const entry = makeEntry();
-        mockGetPending.mockResolvedValue([entry]);
-        mockRazorpaySuccess();
-        await runPayoutBatch(makeCtx());
-        const headers = mockFetch.mock.calls[0][1].headers;
-        const expected = "Basic " + Buffer.from("rzp_test_key:secret").toString("base64");
-        expect(headers["Authorization"]).toBe(expected);
-    });
-    it("sets X-Payout-Idempotency header to payout.id", async () => {
-        const entry = makeEntry({ id: "payout-001" });
-        mockGetPending.mockResolvedValue([entry]);
-        mockRazorpaySuccess();
-        await runPayoutBatch(makeCtx());
-        const headers = mockFetch.mock.calls[0][1].headers;
-        expect(headers["X-Payout-Idempotency"]).toBe("payout-001");
-    });
-    it("calls recordSuccess with razorpayId and status on success", async () => {
-        const entry = makeEntry();
-        mockGetPending.mockResolvedValue([entry]);
-        mockRazorpaySuccess("rzp_pout_xyz", "processing");
-        await runPayoutBatch(makeCtx());
-        expect(mockRecordSuccess).toHaveBeenCalledWith(entry.ref, "rzp_pout_xyz", "processing");
-    });
-    it("uses reference_id = payout.id in the request body", async () => {
-        const entry = makeEntry({ id: "payout-store-B-42" });
-        mockGetPending.mockResolvedValue([entry]);
-        mockRazorpaySuccess();
-        await runPayoutBatch(makeCtx());
-        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-        expect(body.reference_id).toBe("payout-store-B-42");
-    });
-});
-describe("runPayoutBatch — bank payout", () => {
-    it("builds correct bank payload (account_type=bank_account)", async () => {
-        const entry = { ref: makeRef(), data: makeBankPayout() };
-        mockGetPending.mockResolvedValue([entry]);
-        mockRazorpaySuccess();
-        await runPayoutBatch(makeCtx());
-        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-        expect(body.fund_account.account_type).toBe("bank_account");
-        expect(body.fund_account.bank_account.ifsc).toBe("HDFC0000001");
-        expect(body.mode).toBe("NEFT");
-    });
-    it("bank payout: account_number_masked used in payload", async () => {
-        const entry = { ref: makeRef(), data: makeBankPayout() };
-        mockGetPending.mockResolvedValue([entry]);
-        mockRazorpaySuccess();
-        await runPayoutBatch(makeCtx());
-        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-        expect(body.fund_account.bank_account.account_number).toBe("xxxx1234");
-    });
-});
-describe("runPayoutBatch — no fund account configured", () => {
-    it("throws and calls recordFailure when paymentMethod is upi but no upiId", async () => {
-        const entry = makeEntry({ paymentMethod: "upi", upiId: undefined });
-        mockGetPending.mockResolvedValue([entry]);
-        await runPayoutBatch(makeCtx());
-        expect(mockFetch).not.toHaveBeenCalled();
-        expect(mockRecordFailure).toHaveBeenCalled();
-    });
-});
-describe("runPayoutBatch — missing Razorpay credentials", () => {
-    it("records failure when RAZORPAY_KEY_ID is missing", async () => {
-        const entry = makeEntry();
-        mockGetPending.mockResolvedValue([entry]);
-        const ctx = makeCtx({ env: (k) => (k === "RAZORPAY_KEY_ID" ? undefined : "value") });
-        await runPayoutBatch(ctx);
-        expect(mockRecordFailure).toHaveBeenCalled();
-        expect(mockFetch).not.toHaveBeenCalled();
-    });
-    it("records failure when RAZORPAY_KEY_SECRET is missing", async () => {
-        const entry = makeEntry();
-        mockGetPending.mockResolvedValue([entry]);
-        const ctx = makeCtx({ env: (k) => (k === "RAZORPAY_KEY_SECRET" ? undefined : "value") });
-        await runPayoutBatch(ctx);
-        expect(mockRecordFailure).toHaveBeenCalled();
-    });
-});
-describe("runPayoutBatch — Razorpay API failure", () => {
-    it("Razorpay returns non-OK → calls recordFailure with incremented failureCount", async () => {
-        const entry = makeEntry({ failureCount: 0 });
-        mockGetPending.mockResolvedValue([entry]);
-        mockRazorpayFailure(500);
-        await runPayoutBatch(makeCtx());
-        expect(mockRecordFailure).toHaveBeenCalledWith(entry.ref, 1, // failureCount incremented from 0 to 1
-        expect.any(String), false);
-    });
-    it("failureCount=1 (2nd attempt) → isFinal = false", async () => {
-        const entry = makeEntry({ failureCount: 1 });
-        mockGetPending.mockResolvedValue([entry]);
-        mockRazorpayFailure();
-        await runPayoutBatch(makeCtx());
-        expect(mockRecordFailure).toHaveBeenCalledWith(entry.ref, 2, expect.any(String), false);
-    });
-    it("failureCount=2 (3rd attempt, MAX_FAILURES) → isFinal = true", async () => {
-        const entry = makeEntry({ failureCount: 2 });
-        mockGetPending.mockResolvedValue([entry]);
-        mockRazorpayFailure();
-        await runPayoutBatch(makeCtx());
-        expect(mockRecordFailure).toHaveBeenCalledWith(entry.ref, 3, expect.any(String), true);
-    });
-    it("final failure → ctx.logger.error called (not just warn)", async () => {
-        const entry = makeEntry({ failureCount: 2 });
-        mockGetPending.mockResolvedValue([entry]);
-        mockRazorpayFailure();
-        const ctx = makeCtx();
-        await runPayoutBatch(ctx);
-        expect(ctx.logger.error).toHaveBeenCalled();
-        expect(ctx.logger.warn).not.toHaveBeenCalled();
-    });
-    it("non-final failure → ctx.logger.warn called (not error)", async () => {
-        const entry = makeEntry({ failureCount: 0 });
-        mockGetPending.mockResolvedValue([entry]);
-        mockRazorpayFailure();
-        const ctx = makeCtx();
-        await runPayoutBatch(ctx);
-        expect(ctx.logger.warn).toHaveBeenCalled();
-        expect(ctx.logger.error).not.toHaveBeenCalled();
-    });
-    it("failure does NOT call recordSuccess", async () => {
-        const entry = makeEntry();
-        mockGetPending.mockResolvedValue([entry]);
-        mockRazorpayFailure();
-        await runPayoutBatch(makeCtx());
-        expect(mockRecordSuccess).not.toHaveBeenCalled();
-    });
-});
-describe("runPayoutBatch — multiple payouts", () => {
-    it("dispatches all payouts independently", async () => {
-        const e1 = makeEntry({ id: "payout-A" });
-        const e2 = makeEntry({ id: "payout-B" });
-        mockGetPending.mockResolvedValue([e1, e2]);
-        mockRazorpaySuccess();
-        await runPayoutBatch(makeCtx());
-        expect(mockMarkProcessing).toHaveBeenCalledTimes(2);
-        expect(mockRecordSuccess).toHaveBeenCalledTimes(2);
-    });
-    it("one payout failure does NOT abort others (Promise.allSettled)", async () => {
-        const e1 = makeEntry({ id: "payout-A", failureCount: 2 });
-        const e2 = makeEntry({ id: "payout-B" });
-        mockGetPending.mockResolvedValue([e1, e2]);
-        // First call fails, second succeeds
-        mockFetch
-            .mockResolvedValueOnce({ ok: false, status: 500, text: async () => "err" })
-            .mockResolvedValueOnce({ ok: true, json: async () => ({ id: "rzp_1", status: "processing" }) });
-        await expect(runPayoutBatch(makeCtx())).resolves.toBeUndefined();
-        expect(mockRecordSuccess).toHaveBeenCalledTimes(1);
-        expect(mockRecordFailure).toHaveBeenCalledTimes(1);
-    });
-    it("logs batch summary with total/succeeded/failed counts", async () => {
-        const e1 = makeEntry({ id: "payout-A" });
-        const e2 = makeEntry({ id: "payout-B" });
-        mockGetPending.mockResolvedValue([e1, e2]);
-        mockRazorpaySuccess();
-        const ctx = makeCtx();
-        await runPayoutBatch(ctx);
-        const summaryCall = ctx.logger.info.mock.calls.find((c) => typeof c[0] === "string" && c[0].toLowerCase().includes("complete"));
-        expect(summaryCall).toBeTruthy();
-    });
-});

package/dist/_internal/server/jobs/core/__tests__/pendingOrderTimeout.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/_internal/server/jobs/core/__tests__/pendingOrderTimeout.test.js

@@ -1,96 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-vi.mock("../../../../../repositories", () => ({
-    orderRepository: {
-        getTimedOutPending: vi.fn(),
-        cancelInBatch: vi.fn(),
-    },
-}));
-vi.mock("../../../../../features/admin/actions/notification-actions", () => ({
-    sendNotification: vi.fn().mockResolvedValue(undefined),
-}));
-vi.mock("../../handlers/messages", () => ({
-    ORDER_MESSAGES: {
-        CANCELLED_TITLE: "Order cancelled",
-        CANCELLED_TIMEOUT_MESSAGE: (title, hours) => `${title} cancelled after ${hours}h`,
-    },
-}));
-import { runPendingOrderTimeout } from "../pendingOrderTimeout";
-import { orderRepository } from "../../../../../repositories";
-import { sendNotification } from "../../../../../features/admin/actions/notification-actions";
-function makeBatch() {
-    return { commit: vi.fn().mockResolvedValue(undefined) };
-}
-function makeCtxWithBatch(envOverrides = {}) {
-    const batch = makeBatch();
-    const ctx = {
-        job: "pending-order-timeout",
-        db: { batch: vi.fn(() => batch) },
-        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-        env: (key) => envOverrides[key],
-        now: new Date("2026-01-15T12:00:00Z"),
-    };
-    return { ctx, batch };
-}
-function makeCtx(envOverrides = {}) {
-    return makeCtxWithBatch(envOverrides).ctx;
-}
-beforeEach(() => {
-    vi.clearAllMocks();
-    sendNotification.mockResolvedValue(undefined);
-});
-describe("runPendingOrderTimeout", () => {
-    it("returns early when no timed-out orders exist", async () => {
-        orderRepository.getTimedOutPending.mockResolvedValue([]);
-        const ctx = makeCtx();
-        await runPendingOrderTimeout(ctx);
-        expect(ctx.db.batch).not.toHaveBeenCalled();
-        expect(sendNotification).not.toHaveBeenCalled();
-    });
-    it("uses DEFAULT_TIMEOUT_HOURS (24) when env var is unset", async () => {
-        orderRepository.getTimedOutPending.mockResolvedValue([]);
-        const ctx = makeCtx();
-        await runPendingOrderTimeout(ctx);
-        expect(orderRepository.getTimedOutPending).toHaveBeenCalledWith(24);
-    });
-    it("uses ORDER_TIMEOUT_HOURS from env when set", async () => {
-        orderRepository.getTimedOutPending.mockResolvedValue([]);
-        const ctx = makeCtx({ ORDER_TIMEOUT_HOURS: "48" });
-        await runPendingOrderTimeout(ctx);
-        expect(orderRepository.getTimedOutPending).toHaveBeenCalledWith(48);
-    });
-    it("cancels timed-out orders in the batch", async () => {
-        const ref1 = { id: "order-ref-1" };
-        const ref2 = { id: "order-ref-2" };
-        const timedOut = [
-            { ref: ref1, data: { userId: "u1", productTitle: "Charizard", id: "order-1" } },
-            { ref: ref2, data: { userId: "u2", productTitle: "Blastoise", id: "order-2" } },
-        ];
-        orderRepository.getTimedOutPending.mockResolvedValue(timedOut);
-        const { ctx, batch } = makeCtxWithBatch();
-        await runPendingOrderTimeout(ctx);
-        expect(orderRepository.cancelInBatch).toHaveBeenCalledTimes(2);
-        expect(orderRepository.cancelInBatch).toHaveBeenCalledWith(batch, ref1);
-        expect(orderRepository.cancelInBatch).toHaveBeenCalledWith(batch, ref2);
-        expect(batch.commit).toHaveBeenCalledOnce();
-    });
-    it("sends a notification for each cancelled order", async () => {
-        const timedOut = [
-            { ref: {}, data: { userId: "u1", productTitle: "Charizard", id: "order-1" } },
-            { ref: {}, data: { userId: "u2", productTitle: "Blastoise", id: "order-2" } },
-        ];
-        orderRepository.getTimedOutPending.mockResolvedValue(timedOut);
-        const ctx = makeCtx();
-        await runPendingOrderTimeout(ctx);
-        expect(sendNotification).toHaveBeenCalledTimes(2);
-        expect(sendNotification).toHaveBeenCalledWith(expect.objectContaining({ userId: "u1", type: "order_cancelled", relatedId: "order-1" }));
-    });
-    it("does not throw when a notification fails (Promise.allSettled)", async () => {
-        const timedOut = [
-            { ref: {}, data: { userId: "u1", productTitle: "Pikachu", id: "order-x" } },
-        ];
-        orderRepository.getTimedOutPending.mockResolvedValue(timedOut);
-        sendNotification.mockRejectedValue(new Error("Notification failed"));
-        const ctx = makeCtx();
-        await expect(runPendingOrderTimeout(ctx)).resolves.toBeUndefined();
-    });
-});

package/dist/_internal/server/jobs/core/__tests__/triggerEventRaffle.test.d.ts

@@ -1 +0,0 @@
-export {};